// This function is used only in the JSC build.
void KURL::setHostAndPort(const String& s)
{
String newhost = s.left(s.find(":"));
String newport = s.substring(s.find(":") + 1);
KURLGooglePrivate::Replacements replacements;
// Host can't be removed, so we always set.
replacements.SetHost(CharactersOrEmpty(newhost),
url_parse::Component(0, newhost.length()));
if (newport.isEmpty()) // Port may be removed, so we support clearing.
replacements.ClearPort();
else
replacements.SetPort(CharactersOrEmpty(newport), url_parse::Component(0, newport.length()));
m_url.replaceComponents(replacements);
}
void KURL::setHost(const String& host)
{
KURLGooglePrivate::Replacements replacements;
replacements.SetHost(CharactersOrEmpty(host),
url_parse::Component(0, host.length()));
m_url.replaceComponents(replacements);
}
void KURL::setProtocol(const String& protocol)
{
KURLGooglePrivate::Replacements replacements;
replacements.SetScheme(CharactersOrEmpty(protocol),
url_parse::Component(0, protocol.length()));
m_url.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);
// 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_canon::RawCanonOutputT<char> canonProtocol;
url_parse::Component protocolComponent;
if (!url_canon::CanonicalizeScheme(newProtocol.characters(),
url_parse::Component(0, newProtocol.length()),
&canonProtocol, &protocolComponent)
|| !protocolComponent.is_nonempty())
return false;
KURLGooglePrivate::Replacements replacements;
replacements.SetScheme(CharactersOrEmpty(newProtocol),
url_parse::Component(0, newProtocol.length()));
m_url.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::setPath(const String& path)
{
// Empty paths will be canonicalized to "/", so we don't have to worry
// about calling ClearPath().
KURLGooglePrivate::Replacements replacements;
replacements.SetPath(CharactersOrEmpty(path),
url_parse::Component(0, path.length()));
m_url.replaceComponents(replacements);
}
void KURL::setHostAndPort(const String& s)
{
String host = s;
String port;
int hostEnd = s.find(":");
if (hostEnd != -1) {
host = s.left(hostEnd);
port = s.substring(hostEnd + 1);
}
KURLGooglePrivate::Replacements replacements;
// Host can't be removed, so we always set.
replacements.SetHost(CharactersOrEmpty(host),
url_parse::Component(0, host.length()));
if (port.isEmpty()) // Port may be removed, so we support clearing.
replacements.ClearPort();
else
replacements.SetPort(CharactersOrEmpty(port), url_parse::Component(0, port.length()));
m_url.replaceComponents(replacements);
}
void KURL::setQuery(const String& query)
{
KURLGooglePrivate::Replacements 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(query),
url_parse::Component(1, query.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(query),
url_parse::Component(0, query.length()));
}
m_url.replaceComponents(replacements);
}
void KURL::setFragmentIdentifier(const String& s)
{
// This function is commonly called to clear the ref, which we
// normally don't have, so we optimize this case.
if (s.isNull() && !m_url.m_parsed.ref.is_valid())
return;
KURLGooglePrivate::Replacements replacements;
if (s.isNull())
replacements.ClearRef();
else
replacements.SetRef(CharactersOrEmpty(s), url_parse::Component(0, s.length()));
m_url.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_url.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.
KURLGooglePrivate::Replacements replacements;
replacements.SetPassword(CharactersOrEmpty(pass),
url_parse::Component(0, pass.length()));
m_url.replaceComponents(replacements);
}
