Make KURL::protocolIs take StringView (+ DCHECK cleanups)

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 29 matching lines @@
 #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 DCHECK_IS_ON()
-  DCHECK_NE(protocol, "");
-  const char* p = protocol;
-  while (*p) {
-    ASSERT(*p > ' ' && *p < 0x7F && !(*p >= 'A' && *p <= 'Z'));
-    ++p;
+static void assertProtocolIsGood(const StringView protocol) {
+  DCHECK(protocol != "");
+  for (size_t i = 0; i < protocol.length(); ++i) {
+    LChar c = protocol.characters8()[i];
+    DCHECK(c > ' ' && c < 0x7F && !(c >= 'A' && c <= 'Z'));

[esprehn, 2017/01/20 17:50:04]

This could probably be simpler I think? You want isalnum and dashes?

No need to fix in this patch though.

   }
+}
 #endif
-}
 
 // Note: You must ensure that |spec| is a valid canonicalized URL before calling
 // this function.
 static const char* asURLChar8Subtle(const String& spec) {
-  ASSERT(spec.is8Bit());
+  DCHECK(spec.is8Bit());
   // characters8 really return characters in Latin-1, but because we
   // canonicalize URL strings, we know that everything before the fragment
   // identifier will actually be ASCII, which means this cast is safe as long as
   // you don't look at the fragment component.
   return reinterpret_cast<const char*>(spec.characters8());
 }
 
 // Returns the characters for the given string, or a pointer to a static empty
 // string if the input string is null. This will always ensure we have a non-
 // null character pointer since ReplaceComponents has special meaning for null.
@@ skipping 236 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 stringViewForInvalidComponent().toString();
-  ASSERT(!m_string.isNull());
+  DCHECK(!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())
@@ skipping 19 matching lines @@
 
 // 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());
+  DCHECK(!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.
+  DCHECK_NE(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.
@@ skipping 143 matching lines @@
   setPort(parsedPort.toUInt());
 }
 
 void KURL::setPort(unsigned short port) {
   if (isDefaultPortForProtocol(port, protocol())) {
     removePort();
     return;
   }
 
   String portString = String::number(port);
-  ASSERT(portString.is8Bit());
+  DCHECK(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.
@@ skipping 167 matching lines @@
     return m_parsed.CountCharactersBefore(url::Parsed::PATH, false);
   url::Component filename;
   if (m_string.is8Bit())
     url::ExtractFileName(asURLChar8Subtle(m_string), m_parsed.path, &filename);
   else
     url::ExtractFileName(m_string.characters16(), m_parsed.path, &filename);
   return filename.begin;
 }
 
 bool protocolIs(const String& url, const char* protocol) {
+#if DCHECK_IS_ON()
   assertProtocolIsGood(protocol);
+#endif
   if (url.isNull())
     return false;
   if (url.is8Bit())
     return url::FindAndCompareScheme(asURLChar8Subtle(url), url.length(),
                                      protocol, 0);
   return url::FindAndCompareScheme(url.characters16(), url.length(), protocol,
                                    0);
 }
 
 void KURL::init(const KURL& base,
@@ skipping 81 matching lines @@
   } 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 {
+bool KURL::protocolIs(const StringView protocol) const {
+#if DCHECK_IS_ON()
   assertProtocolIsGood(protocol);
+#endif
 
   // 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"));
   return m_protocol == protocol;
 }
 
 StringView KURL::stringViewForInvalidComponent() const {
@@ skipping 34 matching lines @@
   m_string = AtomicString::fromUTF8(output.data(), output.length());
   initProtocolMetadata();
 }
 
 bool KURL::isSafeToSendToAnotherThread() const {
   return m_string.isSafeToSendToAnotherThread() &&
          (!m_innerURL || m_innerURL->isSafeToSendToAnotherThread());
 }
 
 }  // namespace blink