Reland "Optimize KURL protocols"

third_party/WebKit/Source/platform/weborigin/KURL.cpp

 /*
  * Copyright (C) 2004, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
  * Copyright (C) 2008, 2009, 2011 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 16 matching lines @@
 
 #include "platform/weborigin/KURL.h"
 
 #include "platform/weborigin/KnownPorts.h"
 #include "url/url_util.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringHash.h"
+#include "wtf/text/StringStatics.h"
 #include "wtf/text/StringUTF8Adaptor.h"
 #include "wtf/text/TextEncoding.h"
 #include <algorithm>
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 static const int maximumValidPortNumber = 0xFFFE;
 static const int invalidPortNumber = 0xFFFF;
 
 static void assertProtocolIsGood(const char* protocol) {
 #if ENABLE(ASSERT)
+  DCHECK_NE(protocol, "");
   const char* p = protocol;
   while (*p) {
     ASSERT(*p > ' ' && *p < 0x7F && !(*p >= 'A' && *p <= 'Z'));
     ++p;
   }
 #endif
 }
 
 // Note: You must ensure that |spec| is a valid canonicalized URL before calling
 // this function.
@@ skipping 173 matching lines @@
   init(base, relative, &encoding.encodingForFormSubmission());
 }
 
 KURL::KURL(const AtomicString& canonicalString,
            const url::Parsed& parsed,
            bool isValid)
     : m_isValid(isValid),
       m_protocolIsInHTTPFamily(false),
       m_parsed(parsed),
       m_string(canonicalString) {
-  initProtocolIsInHTTPFamily();
+  initProtocolMetadata();
   initInnerURL();
 }
 
 KURL::KURL(WTF::HashTableDeletedValueType)
     : m_isValid(false),
       m_protocolIsInHTTPFamily(false),
       m_string(WTF::HashTableDeletedValue) {}
 
 KURL::KURL(const KURL& other)
     : m_isValid(other.m_isValid),
       m_protocolIsInHTTPFamily(other.m_protocolIsInHTTPFamily),
+      m_protocol(other.m_protocol),
       m_parsed(other.m_parsed),
       m_string(other.m_string) {
   if (other.m_innerURL.get())
     m_innerURL = WTF::wrapUnique(new KURL(other.m_innerURL->copy()));
 }
 
 KURL::~KURL() {}
 
 KURL& KURL::operator=(const KURL& other) {
   m_isValid = other.m_isValid;
   m_protocolIsInHTTPFamily = other.m_protocolIsInHTTPFamily;
+  m_protocol = other.m_protocol;
   m_parsed = other.m_parsed;
   m_string = other.m_string;
   if (other.m_innerURL)
     m_innerURL = WTF::wrapUnique(new KURL(other.m_innerURL->copy()));
   else
     m_innerURL.reset();
   return *this;
 }
 
 KURL KURL::copy() const {
   KURL result;
   result.m_isValid = m_isValid;
   result.m_protocolIsInHTTPFamily = m_protocolIsInHTTPFamily;
+  result.m_protocol = m_protocol.isolatedCopy();
   result.m_parsed = m_parsed;
   result.m_string = m_string.isolatedCopy();
   if (m_innerURL)
     result.m_innerURL = WTF::wrapUnique(new KURL(m_innerURL->copy()));
   return result;
 }
 
 bool KURL::isNull() const {
   return m_string.isNull();
 }
@@ skipping 15 matching lines @@
 }
 
 bool KURL::hasPath() const {
   // Note that http://www.google.com/" has a path, the path is "/". This can
   // return false only for invalid or nonstandard URLs.
   return m_parsed.path.len >= 0;
 }
 
 String KURL::lastPathComponent() const {
   if (!m_isValid)
-    return stringForInvalidComponent();
+    return stringViewForInvalidComponent().toString();
   ASSERT(!m_string.isNull());
 
   // When the output ends in a slash, WebCore has different expectations than
   // the GoogleURL library. For "/foo/bar/" the library will return the empty
   // string, but WebCore wants "bar".
   url::Component path = m_parsed.path;
   if (path.len > 0 && m_string[path.end() - 1] == '/')
     path.len--;
 
   url::Component file;
   if (m_string.is8Bit())
     url::ExtractFileName(asURLChar8Subtle(m_string), path, &file);
   else
     url::ExtractFileName(m_string.characters16(), path, &file);
 
   // Bug: https://bugs.webkit.org/show_bug.cgi?id=21015 this function returns
   // a null string when the path is empty, which we duplicate here.
   if (!file.is_nonempty())
     return String();
   return componentString(file);
 }
 
 String KURL::protocol() const {
-  return componentString(m_parsed.scheme);
+  DCHECK_EQ(componentString(m_parsed.scheme), m_protocol);
+  return m_protocol;
 }
 
 String KURL::host() const {
   return componentString(m_parsed.host);
 }
 
 // Returns 0 when there is no port.
 //
 // We treat URL's with out-of-range port numbers as invalid URLs, and they will
 // be rejected by the canonicalizer. KURL.cpp will allow them in parsing, but
 // return invalidPortNumber from this port() function, so we mirror that
 // behavior here.
 unsigned short KURL::port() const {
   if (!m_isValid || m_parsed.port.len <= 0)
     return 0;
   ASSERT(!m_string.isNull());
   int port = m_string.is8Bit()
                  ? url::ParsePort(asURLChar8Subtle(m_string), m_parsed.port)
                  : url::ParsePort(m_string.characters16(), m_parsed.port);
   ASSERT(port != url::PORT_UNSPECIFIED);  // Checked port.len <= 0 before.
 
   if (port == url::PORT_INVALID ||
       port > maximumValidPortNumber)  // Mimic KURL::port()
     port = invalidPortNumber;
 
   return static_cast<unsigned short>(port);
 }
 
+// TODO(csharrison): Migrate pass() and user() to return a StringView. Most
+// consumers just need to know if the string is empty.
+
 String KURL::pass() const {
   // Bug: https://bugs.webkit.org/show_bug.cgi?id=21015 this function returns
   // a null string when the password is empty, which we duplicate here.
   if (!m_parsed.password.is_nonempty())
     return String();
   return componentString(m_parsed.password);
 }
 
 String KURL::user() const {
   return componentString(m_parsed.username);
@@ skipping 382 matching lines @@
   // non-Atomic input as Atomic here, we will render the (const) input string
   // thread unsafe.
   if (!relative.isNull() && relative.impl()->isAtomic() &&
       StringView(output.data(), static_cast<unsigned>(output.length())) ==
           relative) {
     m_string = relative;
   } else {
     m_string = AtomicString::fromUTF8(output.data(), output.length());
   }
 
-  initProtocolIsInHTTPFamily();
+  initProtocolMetadata();
   initInnerURL();
-  DCHECK_EQ(protocol(), protocol().lower());
 }
 
 void KURL::initInnerURL() {
   if (!m_isValid) {
     m_innerURL.reset();
     return;
   }
   if (url::Parsed* innerParsed = m_parsed.inner_parsed())
     m_innerURL = WTF::wrapUnique(new KURL(
         ParsedURLString,
         m_string.substring(innerParsed->scheme.begin,
                            innerParsed->Length() - innerParsed->scheme.begin)));
   else
     m_innerURL.reset();
 }
 
-template <typename CHAR>
-bool internalProtocolIs(const url::Component& scheme,
-                        const CHAR* spec,
-                        const char* protocol) {
-  const CHAR* begin = spec + scheme.begin;
-  const CHAR* end = begin + scheme.len;
-
-  while (begin != end && *protocol) {
-    ASSERT(toASCIILower(*protocol) == *protocol);
-    if (toASCIILower(*begin++) != *protocol++)
-      return false;
-  }
-
-  // Both strings are equal (ignoring case) if and only if all of the characters
-  // were equal, and the end of both has been reached.
-  return begin == end && !*protocol;
-}
-
-template <typename CHAR>
-bool checkIfProtocolIsInHTTPFamily(const url::Component& scheme,
-                                   const CHAR* spec) {
-  if (scheme.len == 4)
-    return internalProtocolIs(scheme, spec, "http");
-  if (scheme.len == 5)
-    return internalProtocolIs(scheme, spec, "https");
-  if (scheme.len == 7)
-    return internalProtocolIs(scheme, spec, "http-so");
-  if (scheme.len == 8)
-    return internalProtocolIs(scheme, spec, "https-so");
-  return false;
-}
-
-void KURL::initProtocolIsInHTTPFamily() {
+void KURL::initProtocolMetadata() {
   if (!m_isValid) {
     m_protocolIsInHTTPFamily = false;
+    m_protocol = componentString(m_parsed.scheme);
     return;
   }
 
-  ASSERT(!m_string.isNull());
-  m_protocolIsInHTTPFamily =
-      m_string.is8Bit() ? checkIfProtocolIsInHTTPFamily(m_parsed.scheme,
-                                                        m_string.characters8())
-                        : checkIfProtocolIsInHTTPFamily(
-                              m_parsed.scheme, m_string.characters16());
+  DCHECK(!m_string.isNull());
+  StringView protocol = componentStringView(m_parsed.scheme);
+  m_protocolIsInHTTPFamily = true;
+  if (protocol == WTF::httpsAtom) {
+    m_protocol = WTF::httpsAtom;
+  } else if (protocol == WTF::httpAtom) {
+    m_protocol = WTF::httpAtom;
+  } else {
+    m_protocol = protocol.toAtomicString();
+    m_protocolIsInHTTPFamily =
+        m_protocol == "http-so" || m_protocol == "https-so";
+  }
+  DCHECK_EQ(m_protocol, m_protocol.lower());
 }
 
 bool KURL::protocolIs(const char* protocol) const {
   assertProtocolIsGood(protocol);
 
   // JavaScript URLs are "valid" and should be executed even if KURL decides
   // they are invalid.  The free function protocolIsJavaScript() should be used
   // instead.
   // FIXME: Chromium code needs to be fixed for this assert to be enabled.
   // ASSERT(strcmp(protocol, "javascript"));
-
-  if (m_string.isNull() || m_parsed.scheme.len <= 0)
-    return *protocol == '\0';
-
-  return m_string.is8Bit()
-             ? internalProtocolIs(m_parsed.scheme, m_string.characters8(),
-                                  protocol)
-             : internalProtocolIs(m_parsed.scheme, m_string.characters16(),
-                                  protocol);
+  return m_protocol == protocol;
 }
 
-String KURL::stringForInvalidComponent() const {
-  if (m_string.isNull())
-    return String();
-  return emptyString();
+StringView KURL::stringViewForInvalidComponent() const {
+  return m_string.isNull() ? StringView() : StringView("", 0);
 }
 
-String KURL::componentString(const url::Component& component) const {
+StringView KURL::componentStringView(const url::Component& component) const {
   if (!m_isValid || component.len <= 0)
-    return stringForInvalidComponent();
+    return stringViewForInvalidComponent();
   // begin and len are in terms of bytes which do not match
   // if string() is UTF-16 and input contains non-ASCII characters.
   // However, the only part in urlString that can contain non-ASCII
   // characters is 'ref' at the end of the string. In that case,
   // begin will always match the actual value and len (in terms of
   // byte) will be longer than what's needed by 'mid'. However, mid
   // truncates len to avoid go past the end of a string so that we can
   // get away without doing anything here.
-  return getString().substring(component.begin, component.len);
+
+  int maxLength = getString().length() - component.begin;
+  return StringView(getString(), component.begin,
+                    component.len > maxLength ? maxLength : component.len);
+}
+
+String KURL::componentString(const url::Component& component) const {
+  return componentStringView(component).toString();
 }
 
 template <typename CHAR>
 void KURL::replaceComponents(const url::Replacements<CHAR>& replacements) {
   url::RawCanonOutputT<char> output;
   url::Parsed newParsed;
 
   StringUTF8Adaptor utf8(m_string);
   m_isValid = url::ReplaceComponents(utf8.data(), utf8.length(), m_parsed,
                                      replacements, 0, &output, &newParsed);
 
   m_parsed = newParsed;
   m_string = AtomicString::fromUTF8(output.data(), output.length());
+  initProtocolMetadata();
 }
 
 bool KURL::isSafeToSendToAnotherThread() const {
   return m_string.isSafeToSendToAnotherThread() &&
          (!m_innerURL || m_innerURL->isSafeToSendToAnotherThread());
 }
 
 }  // namespace blink