Share schemes needed for CSP between the browser and the renderer.

url/url_util.cc

 // Copyright 2013 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 "url/url_util.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include "base/debug/leak_annotations.h"
@@ skipping 68 matching lines @@
 // are lazily initialized by Initialize and are leaked on shutdown to prevent
 // any destructors from being called that will slow us down or cause problems.
 std::vector<SchemeWithType>* standard_schemes = nullptr;
 std::vector<SchemeWithType>* referrer_schemes = nullptr;
 
 // Similar to above, initialized by the Init*Schemes methods.
 std::vector<std::string>* secure_schemes = nullptr;
 std::vector<std::string>* local_schemes = nullptr;
 std::vector<std::string>* no_access_schemes = nullptr;
 std::vector<std::string>* cors_enabled_schemes = nullptr;
+std::vector<std::string>* bypassing_csp_schemes = nullptr;
 
 // See the LockSchemeRegistries declaration in the header.
 bool scheme_registries_locked = false;
 
 // This template converts a given character type to the corresponding
 // StringPiece type.
 template<typename CHAR> struct CharToStringPiece {
 };
 template<> struct CharToStringPiece<char> {
   typedef base::StringPiece Piece;
@@ skipping 406 matching lines @@
   InitSchemesWithType(&standard_schemes, kStandardURLSchemes,
                       arraysize(kStandardURLSchemes));
   InitSchemesWithType(&referrer_schemes, kReferrerURLSchemes,
                       arraysize(kReferrerURLSchemes));
   InitSchemes(&secure_schemes, kSecureSchemes, arraysize(kSecureSchemes));
   InitSchemes(&local_schemes, kLocalSchemes, arraysize(kLocalSchemes));
   InitSchemes(&no_access_schemes, kNoAccessSchemes,
               arraysize(kNoAccessSchemes));
   InitSchemes(&cors_enabled_schemes, kCORSEnabledSchemes,
               arraysize(kCORSEnabledSchemes));
+  InitSchemes(&bypassing_csp_schemes, nullptr, 0);
   initialized = true;
 }
 
 void Shutdown() {
   initialized = false;
   delete standard_schemes;
   standard_schemes = nullptr;
   delete referrer_schemes;
   referrer_schemes = nullptr;
   delete secure_schemes;
   secure_schemes = nullptr;
   delete local_schemes;
   local_schemes = nullptr;
   delete no_access_schemes;
   no_access_schemes = nullptr;
   delete cors_enabled_schemes;
   cors_enabled_schemes = nullptr;
+  delete bypassing_csp_schemes;
+  bypassing_csp_schemes = nullptr;
 }
 
 void AddStandardScheme(const char* new_scheme, SchemeType type) {
   Initialize();
   DoAddSchemeWithType(new_scheme, type, standard_schemes);
 }
 
 void AddReferrerScheme(const char* new_scheme, SchemeType type) {
   Initialize();
   DoAddSchemeWithType(new_scheme, type, referrer_schemes);
@@ skipping 32 matching lines @@
 void AddCORSEnabledScheme(const char* new_scheme) {
   Initialize();
   DoAddScheme(new_scheme, cors_enabled_schemes);
 }
 
 const std::vector<std::string>& GetCORSEnabledSchemes() {
   Initialize();
   return *cors_enabled_schemes;
 }
 
+void AddBypassingCSPScheme(const char* new_scheme) {
+  Initialize();
+  DoAddScheme(new_scheme, bypassing_csp_schemes);
+}
+
+const std::vector<std::string>& GetBypassingCSPSchemes() {
+  Initialize();
+  return *bypassing_csp_schemes;
+}
+
 void LockSchemeRegistries() {
   scheme_registries_locked = true;
 }
 
 bool IsStandard(const char* spec, const Component& scheme) {
   SchemeType unused_scheme_type;
   return DoIsStandard(spec, scheme, &unused_scheme_type);
 }
 
 bool GetStandardSchemeType(const char* spec,
@@ skipping 221 matching lines @@
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
 bool CompareSchemeComponent(const base::char16* spec,
                             const Component& component,
                             const char* compare_to) {
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
 }  // namespace url