Revert of Revert of CSP: Convert CSPSource constructor bools into a enum.

Source/core/frame/csp/CSPSourceList.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/frame/csp/CSPSourceList.h"
 
 #include "core/frame/csp/CSPSource.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "platform/ParsingUtilities.h"
@@ skipping 93 matching lines @@
     while (position < end) {
         skipWhile<UChar, isASCIISpace>(position, end);
         if (position == end)
             return;
 
         const UChar* beginSource = position;
         skipWhile<UChar, isSourceCharacter>(position, end);
 
         String scheme, host, path;
         int port = 0;
-        bool hostHasWildcard = false;
-        bool portHasWildcard = false;
+        CSPSource::WildcardDisposition hostWildcard = CSPSource::NoWildcard;
+        CSPSource::WildcardDisposition portWildcard = CSPSource::NoWildcard;
 
-        if (parseSource(beginSource, position, scheme, host, port, path, hostHasWildcard, portHasWildcard)) {
+        if (parseSource(beginSource, position, scheme, host, port, path, hostWildcard, portWildcard)) {
             // Wildcard hosts and keyword sources ('self', 'unsafe-inline',
             // etc.) aren't stored in m_list, but as attributes on the source
             // list itself.
             if (scheme.isEmpty() && host.isEmpty())
                 continue;
             if (m_policy->isDirectiveName(host))
                 m_policy->reportDirectiveAsSourceExpression(m_directiveName, host);
-            m_list.append(CSPSource(m_policy, scheme, host, port, path, hostHasWildcard, portHasWildcard));
+            m_list.append(CSPSource(m_policy, scheme, host, port, path, hostWildcard, portWildcard));
         } else {
             m_policy->reportInvalidSourceExpression(m_directiveName, String(beginSource, position - beginSource));
         }
 
         ASSERT(position == end || isASCIISpace(*position));
     }
 }
 
 // source            = scheme ":"
 //                   / ( [ scheme "://" ] host [ port ] [ path ] )
 //                   / "'self'"
-bool CSPSourceList::parseSource(const UChar* begin, const UChar* end, String& scheme, String& host, int& port, String& path, bool& hostHasWildcard, bool& portHasWildcard)
+bool CSPSourceList::parseSource(const UChar* begin, const UChar* end, String& scheme, String& host, int& port, String& path, CSPSource::WildcardDisposition& hostWildcard, CSPSource::WildcardDisposition& portWildcard)
 {
     if (begin == end)
         return false;
 
     if (equalIgnoringCase("'none'", begin, end - begin))
         return false;
 
     if (end - begin == 1 && *begin == '*') {
         addSourceStar();
         return true;
@@ skipping 36 matching lines @@
     const UChar* position = begin;
     const UChar* beginHost = begin;
     const UChar* beginPath = end;
     const UChar* beginPort = 0;
 
     skipWhile<UChar, isNotColonOrSlash>(position, end);
 
     if (position == end) {
         // host
         //     ^
-        return parseHost(beginHost, position, host, hostHasWildcard);
+        return parseHost(beginHost, position, host, hostWildcard);
     }
 
     if (position < end && *position == '/') {
         // host/path || host/ || /
         //     ^            ^    ^
-        return parseHost(beginHost, position, host, hostHasWildcard) && parsePath(position, end, path);
+        return parseHost(beginHost, position, host, hostWildcard) && parsePath(position, end, path);
     }
 
     if (position < end && *position == ':') {
         if (end - position == 1) {
             // scheme:
             //       ^
             return parseScheme(begin, position, scheme);
         }
 
         if (position[1] == '/') {
@@ skipping 19 matching lines @@
     }
 
     if (position < end && *position == '/') {
         // scheme://host/path || scheme://host:port/path
         //              ^                          ^
         if (position == beginHost)
             return false;
         beginPath = position;
     }
 
-    if (!parseHost(beginHost, beginPort ? beginPort : beginPath, host, hostHasWildcard))
+    if (!parseHost(beginHost, beginPort ? beginPort : beginPath, host, hostWildcard))
         return false;
 
     if (beginPort) {
-        if (!parsePort(beginPort, beginPath, port, portHasWildcard))
+        if (!parsePort(beginPort, beginPath, port, portWildcard))
             return false;
     } else {
         port = 0;
     }
 
     if (beginPath != end) {
         if (!parsePath(beginPath, end, path))
             return false;
     }
 
@@ skipping 104 matching lines @@
         return false;
 
     scheme = String(begin, end - begin);
     return true;
 }
 
 // host              = [ "*." ] 1*host-char *( "." 1*host-char )
 //                   / "*"
 // host-char         = ALPHA / DIGIT / "-"
 //
-bool CSPSourceList::parseHost(const UChar* begin, const UChar* end, String& host, bool& hostHasWildcard)
+bool CSPSourceList::parseHost(const UChar* begin, const UChar* end, String& host, CSPSource::WildcardDisposition& hostWildcard)
 {
     ASSERT(begin <= end);
     ASSERT(host.isEmpty());
-    ASSERT(!hostHasWildcard);
+    ASSERT(hostWildcard == CSPSource::NoWildcard);
 
     if (begin == end)
         return false;
 
     const UChar* position = begin;
 
     if (skipExactly<UChar>(position, end, '*')) {
-        hostHasWildcard = true;
+        hostWildcard = CSPSource::HasWildcard;
 
         if (position == end)
             return true;
 
         if (!skipExactly<UChar>(position, end, '.'))
             return false;
     }
 
     const UChar* hostBegin = position;
 
@@ skipping 26 matching lines @@
 
     path = decodeURLEscapeSequences(String(begin, position - begin));
 
     ASSERT(position <= end);
     ASSERT(position == end || (*position == '#' || *position == '?'));
     return true;
 }
 
 // port              = ":" ( 1*DIGIT / "*" )
 //
-bool CSPSourceList::parsePort(const UChar* begin, const UChar* end, int& port, bool& portHasWildcard)
+bool CSPSourceList::parsePort(const UChar* begin, const UChar* end, int& port, CSPSource::WildcardDisposition& portWildcard)
 {
     ASSERT(begin <= end);
     ASSERT(!port);
-    ASSERT(!portHasWildcard);
+    ASSERT(portWildcard == CSPSource::NoWildcard);
 
     if (!skipExactly<UChar>(begin, end, ':'))
         ASSERT_NOT_REACHED();
 
     if (begin == end)
         return false;
 
     if (end - begin == 1 && *begin == '*') {
         port = 0;
-        portHasWildcard = true;
+        portWildcard = CSPSource::HasWildcard;
         return true;
     }
 
     const UChar* position = begin;
     skipWhile<UChar, isASCIIDigit>(position, end);
 
     if (position != end)
         return false;
 
     bool ok;
@@ skipping 27 matching lines @@
 }
 
 void CSPSourceList::addSourceHash(const ContentSecurityPolicyHashAlgorithm& algorithm, const DigestValue& hash)
 {
     m_hashes.add(CSPHashValue(algorithm, hash));
     m_hashAlgorithmsUsed |= algorithm;
 }
 
 
 } // namespace blink