CSP: Fix 'strict-dynamic' with multiple policies.

third_party/WebKit/Source/core/fetch/ResourceLoaderOptions.h

 /*
  * 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:
  *
  *     * 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 49 matching lines @@
   ClientRequestedCredentials,
   ClientDidNotRequestCredentials
 };
 
 enum SynchronousPolicy { RequestSynchronously, RequestAsynchronously };
 
 // A resource fetch can be marked as being CORS enabled. The loader must perform
 // an access check upon seeing the response.
 enum CORSEnabled { NotCORSEnabled, IsCORSEnabled };
 
+// Was the request generated from a "parser-inserted" element?
+// https://html.spec.whatwg.org/multipage/scripting.html#parser-inserted
+enum ParserDisposition { ParserInserted, NotParserInserted };

[jochen (gone - plz use gerrit), 2016/10/06 14:00:08]

why not an enum class?

[Mike West, 2016/10/06 14:47:15]

Because nothing else in this file is an enum class?

I'll make it an enum class if you like, no big deal.

+
 struct ResourceLoaderOptions {
   USING_FAST_MALLOC(ResourceLoaderOptions);
 
  public:
   ResourceLoaderOptions()
       : dataBufferingPolicy(BufferData),
         allowCredentials(DoNotAllowStoredCredentials),
         credentialsRequested(ClientDidNotRequestCredentials),
         contentSecurityPolicyOption(CheckContentSecurityPolicy),
         requestInitiatorContext(DocumentContext),
         synchronousPolicy(RequestAsynchronously),
-        corsEnabled(NotCORSEnabled) {}
+        corsEnabled(NotCORSEnabled),
+        parserDisposition(ParserInserted) {}
 
   ResourceLoaderOptions(
       DataBufferingPolicy dataBufferingPolicy,
       StoredCredentials allowCredentials,
       CredentialRequest credentialsRequested,
       ContentSecurityPolicyDisposition contentSecurityPolicyOption,
       RequestInitiatorContext requestInitiatorContext)
       : dataBufferingPolicy(dataBufferingPolicy),
         allowCredentials(allowCredentials),
         credentialsRequested(credentialsRequested),
         contentSecurityPolicyOption(contentSecurityPolicyOption),
         requestInitiatorContext(requestInitiatorContext),
         synchronousPolicy(RequestAsynchronously),
-        corsEnabled(NotCORSEnabled) {}
+        corsEnabled(NotCORSEnabled),
+        parserDisposition(ParserInserted) {}
 
   // Answers the question "can a separate request with these different options
   // be re-used" (e.g. preload request) The safe (but possibly slow) answer is
   // always false.
   bool canReuseRequest(const ResourceLoaderOptions& other) const {
     // dataBufferingPolicy differences are believed to be safe for re-use.
     // FIXME: check allowCredentials.
     // FIXME: check credentialsRequested.
     // FIXME: check contentSecurityPolicyOption.
     // initiatorInfo is purely informational and should be benign for re-use.
@@ skipping 19 matching lines @@
   FetchInitiatorInfo initiatorInfo;
   RequestInitiatorContext requestInitiatorContext;
   SynchronousPolicy synchronousPolicy;
 
   // If the resource is loaded out-of-origin, whether or not to use CORS.
   CORSEnabled corsEnabled;
 
   RefPtr<SecurityOrigin> securityOrigin;
   String contentSecurityPolicyNonce;
   IntegrityMetadataSet integrityMetadata;
+  ParserDisposition parserDisposition;
 };
 
 // Encode AtomicString (in FetchInitiatorInfo) as String to cross threads.
 struct CrossThreadResourceLoaderOptionsData {
   DISALLOW_NEW();
   explicit CrossThreadResourceLoaderOptionsData(
       const ResourceLoaderOptions& options)
       : dataBufferingPolicy(options.dataBufferingPolicy),
         allowCredentials(options.allowCredentials),
         credentialsRequested(options.credentialsRequested),
         contentSecurityPolicyOption(options.contentSecurityPolicyOption),
         initiatorInfo(options.initiatorInfo),
         requestInitiatorContext(options.requestInitiatorContext),
         synchronousPolicy(options.synchronousPolicy),
         corsEnabled(options.corsEnabled),
         securityOrigin(options.securityOrigin
                            ? options.securityOrigin->isolatedCopy()
                            : nullptr),
         contentSecurityPolicyNonce(options.contentSecurityPolicyNonce),
-        integrityMetadata(options.integrityMetadata) {}
+        integrityMetadata(options.integrityMetadata),
+        parserDisposition(options.parserDisposition) {}
 
   operator ResourceLoaderOptions() const {
     ResourceLoaderOptions options;
     options.dataBufferingPolicy = dataBufferingPolicy;
     options.allowCredentials = allowCredentials;
     options.credentialsRequested = credentialsRequested;
     options.contentSecurityPolicyOption = contentSecurityPolicyOption;
     options.initiatorInfo = initiatorInfo;
     options.requestInitiatorContext = requestInitiatorContext;
     options.synchronousPolicy = synchronousPolicy;
     options.corsEnabled = corsEnabled;
     options.securityOrigin = securityOrigin;
     options.contentSecurityPolicyNonce = contentSecurityPolicyNonce;
     options.integrityMetadata = integrityMetadata;
+    options.parserDisposition = parserDisposition;
     return options;
   }
 
   DataBufferingPolicy dataBufferingPolicy;
   StoredCredentials allowCredentials;
   CredentialRequest credentialsRequested;
   ContentSecurityPolicyDisposition contentSecurityPolicyOption;
   CrossThreadFetchInitiatorInfoData initiatorInfo;
   RequestInitiatorContext requestInitiatorContext;
   SynchronousPolicy synchronousPolicy;
   CORSEnabled corsEnabled;
   RefPtr<SecurityOrigin> securityOrigin;
   String contentSecurityPolicyNonce;
   IntegrityMetadataSet integrityMetadata;
+  ParserDisposition parserDisposition;
 };
 
 template <>
 struct CrossThreadCopier<ResourceLoaderOptions> {
   using Type = CrossThreadResourceLoaderOptionsData;
   static Type copy(const ResourceLoaderOptions& options) {
     return CrossThreadResourceLoaderOptionsData(options);
   }
 };
 
 }  // namespace blink
 
 #endif  // ResourceLoaderOptions_h