Enable srcset support in HTMLImageElement

Source/core/page/ContentSecurityPolicy.cpp

 /*
  * Copyright (C) 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 23 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/SecurityPolicyViolationEvent.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/PingLoader.h"
 #include "core/page/ContentSecurityPolicyResponseHeaders.h"
 #include "core/page/Frame.h"
 #include "core/page/UseCounter.h"
 #include "core/platform/JSONValues.h"
+#include "core/platform/ParsingUtilities.h"
 #include "core/platform/network/FormData.h"
 #include "core/platform/network/ResourceResponse.h"
 #include "weborigin/KURL.h"
 #include "weborigin/KnownPorts.h"
 #include "weborigin/SchemeRegistry.h"
 #include "weborigin/SecurityOrigin.h"
 #include "wtf/HashSet.h"
 #include "wtf/text/TextPosition.h"
 #include "wtf/text/WTFString.h"
 
@@ skipping 104 matching lines @@
         return UseCounter::PrefixedContentSecurityPolicyReportOnly;
     case ContentSecurityPolicy::Report:
         return UseCounter::ContentSecurityPolicyReportOnly;
     }
     ASSERT_NOT_REACHED();
     return UseCounter::NumberOfFeatures;
 }
 
 } // namespace
 
-static bool skipExactly(const UChar*& position, const UChar* end, UChar delimiter)
-{
-    if (position < end && *position == delimiter) {
-        ++position;
-        return true;
-    }
-    return false;
-}
-
-template<bool characterPredicate(UChar)>
-static bool skipExactly(const UChar*& position, const UChar* end)
-{
-    if (position < end && characterPredicate(*position)) {
-        ++position;
-        return true;
-    }
-    return false;
-}
-
-static void skipUntil(const UChar*& position, const UChar* end, UChar delimiter)
-{
-    while (position < end && *position != delimiter)
-        ++position;
-}
-
-template<bool characterPredicate(UChar)>
-static void skipWhile(const UChar*& position, const UChar* end)
-{
-    while (position < end && characterPredicate(*position))
-        ++position;
-}
-
 static bool isSourceListNone(const UChar* begin, const UChar* end)
 {
-    skipWhile<isASCIISpace>(begin, end);
+    skipWhile<UChar, isASCIISpace>(begin, end);
 
     const UChar* position = begin;
-    skipWhile<isSourceCharacter>(position, end);
+    skipWhile<UChar, isSourceCharacter>(position, end);
     if (!equalIgnoringCase("'none'", begin, position - begin))
         return false;
 
-    skipWhile<isASCIISpace>(position, end);
+    skipWhile<UChar, isASCIISpace>(position, end);
     if (position != end)
         return false;
 
     return true;
 }
 
 class CSPSource {
 public:
     CSPSource(ContentSecurityPolicy* policy, const String& scheme, const String& host, int port, const String& path, bool hostHasWildcard, bool portHasWildcard)
         : m_policy(policy)
@@ skipping 142 matching lines @@
 //                   / *WSP "'none'" *WSP
 //
 void CSPSourceList::parse(const UChar* begin, const UChar* end)
 {
     // We represent 'none' as an empty m_list.
     if (isSourceListNone(begin, end))
         return;
 
     const UChar* position = begin;
     while (position < end) {
-        skipWhile<isASCIISpace>(position, end);
+        skipWhile<UChar, isASCIISpace>(position, end);
         if (position == end)
             return;
 
         const UChar* beginSource = position;
-        skipWhile<isSourceCharacter>(position, end);
+        skipWhile<UChar, isSourceCharacter>(position, end);
 
         String scheme, host, path;
         int port = 0;
         bool hostHasWildcard = false;
         bool portHasWildcard = false;
 
         if (parseSource(beginSource, position, scheme, host, port, path, hostHasWildcard, portHasWildcard)) {
             // Wildcard hosts and keyword sources ('self', 'unsafe-inline',
             // etc.) aren't stored in m_list, but as attributes on the source
             // list itself.
@@ skipping 52 matching lines @@
             addSourceNonce(nonce);
             return true;
         }
     }
 
     const UChar* position = begin;
     const UChar* beginHost = begin;
     const UChar* beginPath = end;
     const UChar* beginPort = 0;
 
-    skipWhile<isNotColonOrSlash>(position, end);
+    skipWhile<UChar, isNotColonOrSlash>(position, end);
 
     if (position == end) {
         // host
         //     ^
         return parseHost(beginHost, position, host, hostHasWildcard);
     }
 
     if (position < end && *position == '/') {
         // host/path || host/ || /
         //     ^            ^    ^
         return parseHost(beginHost, position, host, hostHasWildcard) && parsePath(position, end, path);
     }
 
     if (position < end && *position == ':') {
         if (end - position == 1) {
             // scheme:
             //       ^
             return parseScheme(begin, position, scheme);
         }
 
         if (position[1] == '/') {
             // scheme://host || scheme://
             //       ^                ^
             if (!parseScheme(begin, position, scheme)
-                || !skipExactly(position, end, ':')
-                || !skipExactly(position, end, '/')
-                || !skipExactly(position, end, '/'))
+                || !skipExactly<UChar>(position, end, ':')
+                || !skipExactly<UChar>(position, end, '/')
+                || !skipExactly<UChar>(position, end, '/'))
                 return false;
             if (position == end)
                 return true;
             beginHost = position;
-            skipWhile<isNotColonOrSlash>(position, end);
+            skipWhile<UChar, isNotColonOrSlash>(position, end);
         }
 
         if (position < end && *position == ':') {
             // host:port || scheme://host:port
             //     ^                     ^
             beginPort = position;
-            skipUntil(position, end, '/');
+            skipUntil<UChar>(position, end, '/');
         }
     }
 
     if (position < end && *position == '/') {
         // scheme://host/path || scheme://host:port/path
         //              ^                          ^
         if (position == beginHost)
             return false;
         beginPath = position;
     }
@@ skipping 22 matching lines @@
 bool CSPSourceList::parseNonce(const UChar* begin, const UChar* end, String& nonce)
 {
     DEFINE_STATIC_LOCAL(const String, noncePrefix, ("'nonce-"));
 
     if (!equalIgnoringCase(noncePrefix.characters8(), begin, noncePrefix.length()))
         return true;
 
     const UChar* position = begin + noncePrefix.length();
     const UChar* nonceBegin = position;
 
-    skipWhile<isNonceCharacter>(position, end);
+    skipWhile<UChar, isNonceCharacter>(position, end);
     ASSERT(nonceBegin <= position);
 
     if (((position + 1) != end  && *position != '\'') || !(position - nonceBegin))
         return false;
 
     nonce = String(nonceBegin, position - nonceBegin);
     return true;
 }
 
 //                     ; <scheme> production from RFC 3986
 // scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
 //
 bool CSPSourceList::parseScheme(const UChar* begin, const UChar* end, String& scheme)
 {
     ASSERT(begin <= end);
     ASSERT(scheme.isEmpty());
 
     if (begin == end)
         return false;
 
     const UChar* position = begin;
 
-    if (!skipExactly<isASCIIAlpha>(position, end))
+    if (!skipExactly<UChar, isASCIIAlpha>(position, end))
         return false;
 
-    skipWhile<isSchemeContinuationCharacter>(position, end);
+    skipWhile<UChar, isSchemeContinuationCharacter>(position, end);
 
     if (position != end)
         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)
 {
     ASSERT(begin <= end);
     ASSERT(host.isEmpty());
     ASSERT(!hostHasWildcard);
 
     if (begin == end)
         return false;
 
     const UChar* position = begin;
 
-    if (skipExactly(position, end, '*')) {
+    if (skipExactly<UChar>(position, end, '*')) {
         hostHasWildcard = true;
 
         if (position == end)
             return true;
 
-        if (!skipExactly(position, end, '.'))
+        if (!skipExactly<UChar>(position, end, '.'))
             return false;
     }
 
     const UChar* hostBegin = position;
 
     while (position < end) {
-        if (!skipExactly<isHostCharacter>(position, end))
+        if (!skipExactly<UChar, isHostCharacter>(position, end))
             return false;
 
-        skipWhile<isHostCharacter>(position, end);
+        skipWhile<UChar, isHostCharacter>(position, end);
 
-        if (position < end && !skipExactly(position, end, '.'))
+        if (position < end && !skipExactly<UChar>(position, end, '.'))
             return false;
     }
 
     ASSERT(position == end);
     host = String(hostBegin, end - hostBegin);
     return true;
 }
 
 bool CSPSourceList::parsePath(const UChar* begin, const UChar* end, String& path)
 {
     ASSERT(begin <= end);
     ASSERT(path.isEmpty());
 
     const UChar* position = begin;
-    skipWhile<isPathComponentCharacter>(position, end);
+    skipWhile<UChar, isPathComponentCharacter>(position, end);
     // path/to/file.js?query=string || path/to/file.js#anchor
     //                ^                               ^
     if (position < end)
         m_policy->reportInvalidPathCharacter(m_directiveName, String(begin, end - begin), *position);
 
     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)
 {
     ASSERT(begin <= end);
     ASSERT(!port);
     ASSERT(!portHasWildcard);
 
-    if (!skipExactly(begin, end, ':'))
+    if (!skipExactly<UChar>(begin, end, ':'))
         ASSERT_NOT_REACHED();
 
     if (begin == end)
         return false;
 
     if (end - begin == 1 && *begin == '*') {
         port = 0;
         portHasWildcard = true;
         return true;
     }
 
     const UChar* position = begin;
-    skipWhile<isASCIIDigit>(position, end);
+    skipWhile<UChar, isASCIIDigit>(position, end);
 
     if (position != end)
         return false;
 
     bool ok;
     port = charactersToIntStrict(begin, end - begin, &ok);
     return ok;
 }
 
 void CSPSourceList::addSourceSelf()
@@ skipping 63 matching lines @@
 
         // 'plugin-types ____;' OR 'plugin-types;'
         if (position == end) {
             policy()->reportInvalidPluginTypes(String());
             return;
         }
 
         while (position < end) {
             // _____ OR _____mime1/mime1
             // ^        ^
-            skipWhile<isASCIISpace>(position, end);
+            skipWhile<UChar, isASCIISpace>(position, end);
             if (position == end)
                 return;
 
             // mime1/mime1 mime2/mime2
             // ^
             begin = position;
-            if (!skipExactly<isMediaTypeCharacter>(position, end)) {
-                skipWhile<isNotASCIISpace>(position, end);
+            if (!skipExactly<UChar, isMediaTypeCharacter>(position, end)) {
+                skipWhile<UChar, isNotASCIISpace>(position, end);
                 policy()->reportInvalidPluginTypes(String(begin, position - begin));
                 continue;
             }
-            skipWhile<isMediaTypeCharacter>(position, end);
+            skipWhile<UChar, isMediaTypeCharacter>(position, end);
 
             // mime1/mime1 mime2/mime2
             //      ^
-            if (!skipExactly(position, end, '/')) {
-                skipWhile<isNotASCIISpace>(position, end);
+            if (!skipExactly<UChar>(position, end, '/')) {
+                skipWhile<UChar, isNotASCIISpace>(position, end);
                 policy()->reportInvalidPluginTypes(String(begin, position - begin));
                 continue;
             }
 
             // mime1/mime1 mime2/mime2
             //       ^
-            if (!skipExactly<isMediaTypeCharacter>(position, end)) {
-                skipWhile<isNotASCIISpace>(position, end);
+            if (!skipExactly<UChar, isMediaTypeCharacter>(position, end)) {
+                skipWhile<UChar, isNotASCIISpace>(position, end);
                 policy()->reportInvalidPluginTypes(String(begin, position - begin));
                 continue;
             }
-            skipWhile<isMediaTypeCharacter>(position, end);
+            skipWhile<UChar, isMediaTypeCharacter>(position, end);
 
             // mime1/mime1 mime2/mime2 OR mime1/mime1  OR mime1/mime1/error
             //            ^                          ^               ^
             if (position < end && isNotASCIISpace(*position)) {
-                skipWhile<isNotASCIISpace>(position, end);
+                skipWhile<UChar, isNotASCIISpace>(position, end);
                 policy()->reportInvalidPluginTypes(String(begin, position - begin));
                 continue;
             }
             m_pluginTypes.add(String(begin, position - begin));
 
             ASSERT(position == end || isASCIISpace(*position));
         }
     }
 
     HashSet<String> m_pluginTypes;
@@ skipping 428 matching lines @@
 void CSPDirectiveList::parse(const UChar* begin, const UChar* end)
 {
     m_header = String(begin, end - begin);
 
     if (begin == end)
         return;
 
     const UChar* position = begin;
     while (position < end) {
         const UChar* directiveBegin = position;
-        skipUntil(position, end, ';');
+        skipUntil<UChar>(position, end, ';');
 
         String name, value;
         if (parseDirective(directiveBegin, position, name, value)) {
             ASSERT(!name.isEmpty());
             addDirective(name, value);
         }
 
         ASSERT(position == end || *position == ';');
-        skipExactly(position, end, ';');
+        skipExactly<UChar>(position, end, ';');
     }
 }
 
 // directive         = *WSP [ directive-name [ WSP directive-value ] ]
 // directive-name    = 1*( ALPHA / DIGIT / "-" )
 // directive-value   = *( WSP / <VCHAR except ";"> )
 //
 bool CSPDirectiveList::parseDirective(const UChar* begin, const UChar* end, String& name, String& value)
 {
     ASSERT(name.isEmpty());
     ASSERT(value.isEmpty());
 
     const UChar* position = begin;
-    skipWhile<isASCIISpace>(position, end);
+    skipWhile<UChar, isASCIISpace>(position, end);
 
     // Empty directive (e.g. ";;;"). Exit early.
     if (position == end)
         return false;
 
     const UChar* nameBegin = position;
-    skipWhile<isDirectiveNameCharacter>(position, end);
+    skipWhile<UChar, isDirectiveNameCharacter>(position, end);
 
     // The directive-name must be non-empty.
     if (nameBegin == position) {
-        skipWhile<isNotASCIISpace>(position, end);
+        skipWhile<UChar, isNotASCIISpace>(position, end);
         m_policy->reportUnsupportedDirective(String(nameBegin, position - nameBegin));
         return false;
     }
 
     name = String(nameBegin, position - nameBegin);
 
     if (position == end)
         return true;
 
-    if (!skipExactly<isASCIISpace>(position, end)) {
-        skipWhile<isNotASCIISpace>(position, end);
+    if (!skipExactly<UChar, isASCIISpace>(position, end)) {
+        skipWhile<UChar, isNotASCIISpace>(position, end);
         m_policy->reportUnsupportedDirective(String(nameBegin, position - nameBegin));
         return false;
     }
 
-    skipWhile<isASCIISpace>(position, end);
+    skipWhile<UChar, isASCIISpace>(position, end);
 
     const UChar* valueBegin = position;
-    skipWhile<isDirectiveValueCharacter>(position, end);
+    skipWhile<UChar, isDirectiveValueCharacter>(position, end);
 
     if (position != end) {
         m_policy->reportInvalidDirectiveValueCharacter(name, String(valueBegin, end - valueBegin));
         return false;
     }
 
     // The directive-value may be empty.
     if (valueBegin == position)
         return true;
 
     value = String(valueBegin, position - valueBegin);
     return true;
 }
 
 void CSPDirectiveList::parseReportURI(const String& name, const String& value)
 {
     if (!m_reportURIs.isEmpty()) {
         m_policy->reportDuplicateDirective(name);
         return;
     }
 
     Vector<UChar> characters;
     value.appendTo(characters);
 
     const UChar* position = characters.data();
     const UChar* end = position + characters.size();
 
     while (position < end) {
-        skipWhile<isASCIISpace>(position, end);
+        skipWhile<UChar, isASCIISpace>(position, end);
 
         const UChar* urlBegin = position;
-        skipWhile<isNotASCIISpace>(position, end);
+        skipWhile<UChar, isNotASCIISpace>(position, end);
 
         if (urlBegin < position) {
             String url = String(urlBegin, position - urlBegin);
             m_reportURIs.append(m_policy->completeURL(url));
         }
     }
 }
 
 
 template<class CSPDirectiveType>
@@ skipping 32 matching lines @@
         m_policy->reportInvalidReflectedXSS(value);
         return;
     }
 
     Vector<UChar> characters;
     value.appendTo(characters);
 
     const UChar* position = characters.data();
     const UChar* end = position + characters.size();
 
-    skipWhile<isASCIISpace>(position, end);
+    skipWhile<UChar, isASCIISpace>(position, end);
     const UChar* begin = position;
-    skipWhile<isNotASCIISpace>(position, end);
+    skipWhile<UChar, isNotASCIISpace>(position, end);
 
     // value1
     //       ^
     if (equalIgnoringCase("allow", begin, position - begin))
         m_reflectedXSSDisposition = ContentSecurityPolicy::AllowReflectedXSS;
     else if (equalIgnoringCase("filter", begin, position - begin))
         m_reflectedXSSDisposition = ContentSecurityPolicy::FilterReflectedXSS;
     else if (equalIgnoringCase("block", begin, position - begin))
         m_reflectedXSSDisposition = ContentSecurityPolicy::BlockReflectedXSS;
     else {
         m_reflectedXSSDisposition = ContentSecurityPolicy::ReflectedXSSInvalid;
         m_policy->reportInvalidReflectedXSS(value);
         return;
     }
 
-    skipWhile<isASCIISpace>(position, end);
+    skipWhile<UChar, isASCIISpace>(position, end);
     if (position == end && m_reflectedXSSDisposition != ContentSecurityPolicy::ReflectedXSSUnset)
         return;
 
     // value1 value2
     //        ^
     m_reflectedXSSDisposition = ContentSecurityPolicy::ReflectedXSSInvalid;
     m_policy->reportInvalidReflectedXSS(value);
 }
 
 void CSPDirectiveList::addDirective(const String& name, const String& value)
@@ skipping 86 matching lines @@
     header.appendTo(characters);
 
     const UChar* begin = characters.data();
     const UChar* end = begin + characters.size();
 
     // RFC2616, section 4.2 specifies that headers appearing multiple times can
     // be combined with a comma. Walk the header string, and parse each comma
     // separated chunk as a separate header.
     const UChar* position = begin;
     while (position < end) {
-        skipUntil(position, end, ',');
+        skipUntil<UChar>(position, end, ',');
 
         // header1,header2 OR header1
         //        ^                  ^
         OwnPtr<CSPDirectiveList> policy = CSPDirectiveList::create(this, begin, position, type);
 
         // We disable 'eval()' even in the case of report-only policies, and rely on the check in the V8Initializer::codeGenerationCheckCallbackInMainThread callback to determine whether the call should execute or not.
         if (!policy->allowEval(0, SuppressReport))
             m_scriptExecutionContext->disableEval(policy->evalDisabledErrorMessage());
 
         m_policies.append(policy.release());
 
         // Skip the comma, and begin the next header from the current position.
         ASSERT(position == end || *position == ',');
-        skipExactly(position, end, ',');
+        skipExactly<UChar>(position, end, ',');
         begin = position;
     }
 }
 
 void ContentSecurityPolicy::setOverrideAllowInlineStyle(bool value)
 {
     m_overrideInlineStyleAllowed = value;
 }
 
 const String& ContentSecurityPolicy::deprecatedHeader() const
@@ skipping 416 matching lines @@
     // Collisions have no security impact, so we can save space by storing only the string's hash rather than the whole report.
     return !m_violationReportsSent.contains(report.impl()->hash());
 }
 
 void ContentSecurityPolicy::didSendViolationReport(const String& report)
 {
     m_violationReportsSent.add(report.impl()->hash());
 }
 
 } // namespace WebCore