void KURL::setHostAndPort(const String& hostAndPort) { size_t separator = hostAndPort.find(':'); if (!separator) return; if (separator == kNotFound) { url::Replacements<char> replacements; StringUTF8Adaptor hostUTF8(hostAndPort); replacements.SetHost(charactersOrEmpty(hostUTF8), url::Component(0, hostUTF8.length())); replaceComponents(replacements); return; } String host = hostAndPort.substring(0, separator); String port = parsePortFromStringPosition(hostAndPort, separator + 1); StringUTF8Adaptor hostUTF8(host); StringUTF8Adaptor portUTF8(port); url::Replacements<char> replacements; replacements.SetHost(charactersOrEmpty(hostUTF8), url::Component(0, hostUTF8.length())); replacements.SetPort(charactersOrEmpty(portUTF8), url::Component(0, portUTF8.length())); replaceComponents(replacements); }
void KURL::setHost(const String& host) { StringUTF8Adaptor hostUTF8(host); url::Replacements<char> replacements; replacements.SetHost(charactersOrEmpty(hostUTF8), url::Component(0, hostUTF8.length())); replaceComponents(replacements); }
bool KURL::setProtocol(const String& protocol) { // Firefox and IE remove everything after the first ':'. int separatorPosition = protocol.find(':'); String newProtocol = protocol.substring(0, separatorPosition); StringUTF8Adaptor newProtocolUTF8(newProtocol); // If KURL is given an invalid scheme, it returns failure without modifying // the URL at all. This is in contrast to most other setters which modify // the URL and set "m_isValid." url::RawCanonOutputT<char> canonProtocol; url::Component protocolComponent; if (!url::CanonicalizeScheme(newProtocolUTF8.data(), url::Component(0, newProtocolUTF8.length()), &canonProtocol, &protocolComponent) || !protocolComponent.is_nonempty()) return false; url::Replacements<char> replacements; replacements.SetScheme(charactersOrEmpty(newProtocolUTF8), url::Component(0, newProtocolUTF8.length())); replaceComponents(replacements); // isValid could be false but we still return true here. This is because // WebCore or JS scripts can build up a URL by setting individual // components, and a JS exception is based on the return value of this // function. We want to throw the exception and stop the script only when // its trying to set a bad protocol, and not when it maybe just hasn't // finished building up its final scheme. return true; }
void KURL::removePort() { if (!hasPort()) return; url::Replacements<char> replacements; replacements.ClearPort(); replaceComponents(replacements); }
void KURL::setPath(const String& path) { // Empty paths will be canonicalized to "/", so we don't have to worry // about calling ClearPath(). StringUTF8Adaptor pathUTF8(path); url::Replacements<char> replacements; replacements.SetPath(charactersOrEmpty(pathUTF8), url::Component(0, pathUTF8.length())); replaceComponents(replacements); }
void KURL::setPort(unsigned short i) { String portString = String::number(i); ASSERT(portString.is8Bit()); url_canon::Replacements<char> replacements; replacements.SetPort(reinterpret_cast<const char*>(portString.characters8()), url_parse::Component(0, portString.length())); replaceComponents(replacements); }
void KURL::setPass(const String& pass) { // This function is commonly called to clear the password, which we // normally don't have, so we optimize this case. if (pass.isEmpty() && !m_parsed.password.is_valid()) return; // The canonicalizer will clear any passwords that are empty, so we // don't have to explicitly call ClearUsername() here. StringUTF8Adaptor passUTF8(pass); url::Replacements<char> replacements; replacements.SetPassword(charactersOrEmpty(passUTF8), url::Component(0, passUTF8.length())); replaceComponents(replacements); }
void KURL::setPort(unsigned short port) { if (isDefaultPortForProtocol(port, protocol())) { removePort(); return; } String portString = String::number(port); ASSERT(portString.is8Bit()); url::Replacements<char> replacements; replacements.SetPort(reinterpret_cast<const char*>(portString.characters8()), url::Component(0, portString.length())); replaceComponents(replacements); }
void KURL::setUser(const String& user) { // This function is commonly called to clear the username, which we // normally don't have, so we optimize this case. if (user.isEmpty() && !m_parsed.username.is_valid()) return; // The canonicalizer will clear any usernames that are empty, so we // don't have to explicitly call ClearUsername() here. StringUTF8Adaptor userUTF8(user); url_canon::Replacements<char> replacements; replacements.SetUsername(charactersOrEmpty(userUTF8), url_parse::Component(0, userUTF8.length())); replaceComponents(replacements); }
void KURL::setFragmentIdentifier(const String& fragment) { // This function is commonly called to clear the ref, which we // normally don't have, so we optimize this case. if (fragment.isNull() && !m_parsed.ref.is_valid()) return; StringUTF8Adaptor fragmentUTF8(fragment); url::Replacements<char> replacements; if (fragment.isNull()) replacements.ClearRef(); else replacements.SetRef(charactersOrEmpty(fragmentUTF8), url::Component(0, fragmentUTF8.length())); replaceComponents(replacements); }
void KURL::setQuery(const String& query) { StringUTF8Adaptor queryUTF8(query); url::Replacements<char> replacements; if (query.isNull()) { // KURL.cpp sets to null to clear any query. replacements.ClearQuery(); } else if (query.length() > 0 && query[0] == '?') { // WebCore expects the query string to begin with a question mark, but // GoogleURL doesn't. So we trim off the question mark when setting. replacements.SetQuery(charactersOrEmpty(queryUTF8), url::Component(1, queryUTF8.length() - 1)); } else { // When set with the empty string or something that doesn't begin with // a question mark, KURL.cpp will add a question mark for you. The only // way this isn't compatible is if you call this function with an empty // string. KURL.cpp will leave a '?' with nothing following it in the // URL, whereas we'll clear it. // FIXME We should eliminate this difference. replacements.SetQuery(charactersOrEmpty(queryUTF8), url::Component(0, queryUTF8.length())); } replaceComponents(replacements); }
void KURL::setHostAndPort(const String& hostAndPort) { String host = hostAndPort; String port; int hostEnd = hostAndPort.find(":"); if (hostEnd != -1) { host = hostAndPort.left(hostEnd); port = hostAndPort.substring(hostEnd + 1); } StringUTF8Adaptor hostUTF8(host); StringUTF8Adaptor portUTF8(port); url_canon::Replacements<char> replacements; // Host can't be removed, so we always set. replacements.SetHost(charactersOrEmpty(hostUTF8), url_parse::Component(0, hostUTF8.length())); if (!portUTF8.length()) // Port may be removed, so we support clearing. replacements.ClearPort(); else replacements.SetPort(charactersOrEmpty(portUTF8), url_parse::Component(0, portUTF8.length())); replaceComponents(replacements); }
void KURL::removeFragmentIdentifier() { url::Replacements<char> replacements; replacements.ClearRef(); replaceComponents(replacements); }