Make it possible to initialize KURLGoogle from a CString. This is so that I...

third_party/WebKit/WebCore/platform/KURLGoogle.cpp

 /*
  * Copyright (C) 2008, 2009 Google Inc. All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  * 
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 116 matching lines @@
     , m_protocolInHTTPFamily(false)
     , m_parsed(parsed)
     , m_utf8IsASCII(true)
     , m_stringIsValid(false)
 {
 }
 
 // Setters for the data. Using the ASCII version when you know the
 // data is ASCII will be slightly more efficient. The UTF-8 version
 // will always be correct if the caller is unsure.
-void KURLGooglePrivate::setUtf8(const char* data, int dataLength)
+void KURLGooglePrivate::setUtf8(const CString& str)
 {
+    const char* data = str.data();
+    unsigned dataLength = str.length();
+
     // The m_utf8IsASCII must always be correct since the DeprecatedString
     // getter must create it with the proper constructor. This test can be
     // removed when DeprecatedString is gone, but it still might be a
     // performance win.
     m_utf8IsASCII = true;
-    for (int i = 0; i < dataLength; i++) {
+    for (unsigned i = 0; i < dataLength; i++) {
         if (static_cast<unsigned char>(data[i]) >= 0x80) {
             m_utf8IsASCII = false;
             break;
         }
     }
 
-    m_utf8 = CString(data, dataLength);
+    m_utf8 = str;
     m_stringIsValid = false;
     initProtocolInHTTPFamily();
 }
 
-void KURLGooglePrivate::setAscii(const char* data, int dataLength)
+void KURLGooglePrivate::setAscii(const CString& str)
 {
-    m_utf8 = CString(data, dataLength);
+    m_utf8 = str;
     m_utf8IsASCII = true;
     m_stringIsValid = false;
     initProtocolInHTTPFamily();
 }
 
 void KURLGooglePrivate::init(const KURL& base,
                              const String& relative,
                              const TextEncoding* queryEncoding)
 {
     init(base, relative.characters(), relative.length(), queryEncoding);
@@ skipping 27 matching lines @@
     // changed the string, we can avoid an extra allocation by using assignment.
     //
     // When KURL encounters an error such that the URL is invalid and empty
     // (for example, resolving a relative URL on a non-hierarchical base), it
     // will produce an isNull URL, and calling setUtf8 will produce an empty
     // non-null URL. This is unlikely to affect anything, but we preserve this
     // just in case.
     if (m_isValid || output.length()) {
         // Without ref, the whole url is guaranteed to be ASCII-only.
         if (m_parsed.ref.is_nonempty())
-            setUtf8(output.data(), output.length());
+            setUtf8(CString(output.data(), output.length()));
         else
-            setAscii(output.data(), output.length());
+            setAscii(CString(output.data(), output.length()));
     } else {
         // WebCore expects resolved URLs to be empty rather than NULL.
-        setUtf8("", 0);
+        setUtf8(CString("", 0));
     }
 }
 
 // Note: code mostly duplicated above. See FIXMEs and comments there.
 void KURLGooglePrivate::init(const KURL& base, const UChar* rel, int relLength,
                              const TextEncoding* queryEncoding)
 {
     KURLCharsetConverter charsetConverterObject(queryEncoding);
     KURLCharsetConverter* charsetConverter =
         (!queryEncoding || isUnicodeEncoding(queryEncoding)) ? 0 :
         &charsetConverterObject;
 
     url_canon::RawCanonOutputT<char> output;
     const CString& baseStr = base.m_url.utf8String();
     m_isValid = url_util::ResolveRelative(baseStr.data(), baseStr.length(),
                                           base.m_url.m_parsed, rel, relLength,
                                           charsetConverter,
                                           &output, &m_parsed);
 
 
     if (m_isValid || output.length()) {
         if (m_parsed.ref.is_nonempty())
-            setUtf8(output.data(), output.length());
+            setUtf8(CString(output.data(), output.length()));
         else
-            setAscii(output.data(), output.length());
+            setAscii(CString(output.data(), output.length()));
     } else
-        setUtf8("", 0);
+        setUtf8(CString("", 0));
 }
 
 void KURLGooglePrivate::initProtocolInHTTPFamily()
 {
     if (!m_isValid) {
         m_protocolInHTTPFamily = false;
         return;
     }
 
     const char* scheme = m_utf8.data() + m_parsed.scheme.begin;
@@ skipping 40 matching lines @@
 void KURLGooglePrivate::replaceComponents(const Replacements& replacements)
 {
     url_canon::RawCanonOutputT<char> output;
     url_parse::Parsed newParsed;
 
     m_isValid = url_util::ReplaceComponents(utf8String().data(),
                                             utf8String().length(), m_parsed, replacements, 0, &output, &newParsed);
 
     m_parsed = newParsed;
     if (m_parsed.ref.is_nonempty())
-        setUtf8(output.data(), output.length());
+        setUtf8(CString(output.data(), output.length()));
     else
-        setAscii(output.data(), output.length());
+        setAscii(CString(output.data(), output.length()));
 }
 
 const String& KURLGooglePrivate::string() const
 {
     if (!m_stringIsValid) {
         // Must special case the NULL case, since constructing the
         // string like we do below will generate an empty rather than
         // a NULL string.
         if (m_utf8.isNull())
             m_string = String();
@@ skipping 14 matching lines @@
 KURL::KURL(const char *url)
 {
     // FIXME The Mac code checks for beginning with a slash and converting to a
     // file: URL. We will want to add this as well once we can compile on a
     // system like that.
     m_url.init(KURL(), url, strlen(url), 0);
 
     // The one-argument constructors should never generate a NULL string.
     // This is a funny quirk of KURL.cpp (probably a bug) which we preserve.
     if (m_url.utf8String().isNull())
-        m_url.setAscii("", 0);
+        m_url.setAscii(CString("", 0));
 }
 
 // Initializes with a string representing an absolute URL. No encoding
 // information is specified. This generally happens when a KURL is converted
 // to a string and then converted back. In this case, the URL is already
 // canonical and in proper escaped form so needs no encoding. We treat it was
 // UTF-8 just in case.
 KURL::KURL(const String& url)
 {
     if (!url.isNull())
@@ skipping 16 matching lines @@
 
 // Constructs a new URL given a base URL and a possibly relative input URL.
 // Any query portion of the relative URL will be encoded in the given encoding.
 KURL::KURL(const KURL& base,
            const String& relative,
            const TextEncoding& encoding)
 {
     m_url.init(base, relative, &encoding.encodingForFormSubmission());
 }
 
-KURL::KURL(const char* canonicalSpec, int canonicalSpecLen,
+KURL::KURL(const CString& canonicalSpec,
            const url_parse::Parsed& parsed, bool isValid)
     : m_url(parsed, isValid)
 {
     // We know the reference fragment is the only part that can be UTF-8, so
     // we know it's ASCII when there is no ref.
     if (parsed.ref.is_nonempty())
-        m_url.setUtf8(canonicalSpec, canonicalSpecLen);
+        m_url.setUtf8(canonicalSpec);
     else
-        m_url.setAscii(canonicalSpec, canonicalSpecLen);
+        m_url.setAscii(canonicalSpec);
 }
 
 #if PLATFORM(CF)
 KURL::KURL(CFURLRef)
 {
     notImplemented();
     invalidate();
 }
 
 CFURLRef KURL::createCFURL() const
@@ skipping 543 matching lines @@
 }
 
 inline bool KURL::protocolIs(const String& string, const char* protocol)
 {
     return WebCore::protocolIs(string, protocol);
 }
 
 } // namespace WebCore
 
 #endif // USE(GOOGLEURL)