Fix handling of external protocols with PlzNavigate.

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 63 matching lines @@
 
 const char* kWebStorageSchemes[] = {
   kHttpScheme,
   kHttpsScheme,
   kFileScheme,
   kFtpScheme,
   kWsScheme,
   kWssScheme,
 };
 
+const char* kEmptyDocumentSchemes[] = {
+    kAboutScheme,

[brettw, 2017/03/23 22:02:13]

Indenting.

[jam, 2017/03/23 22:36:04]

I'll do this in a followup if you don't mind, just because of CQ time.

+};
+
 bool initialized = false;
 
 // Lists of the currently installed standard and referrer schemes. These lists
 // 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>* web_storage_schemes = nullptr;
 std::vector<std::string>* csp_bypassing_schemes = nullptr;
+std::vector<std::string>* empty_document_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 409 matching lines @@
                       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(&web_storage_schemes, kWebStorageSchemes,
               arraysize(kWebStorageSchemes));
   InitSchemes(&csp_bypassing_schemes, nullptr, 0);
+  InitSchemes(&empty_document_schemes, kEmptyDocumentSchemes,
+              arraysize(kEmptyDocumentSchemes));
   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 web_storage_schemes;
   web_storage_schemes = nullptr;
   delete csp_bypassing_schemes;
   csp_bypassing_schemes = nullptr;
+  delete empty_document_schemes;
+  empty_document_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 52 matching lines @@
 void AddCSPBypassingScheme(const char* new_scheme) {
   Initialize();
   DoAddScheme(new_scheme, csp_bypassing_schemes);
 }
 
 const std::vector<std::string>& GetCSPBypassingSchemes() {
   Initialize();
   return *csp_bypassing_schemes;
 }
 
+void AddEmptyDocumentScheme(const char* new_scheme) {
+  Initialize();
+  DoAddScheme(new_scheme, empty_document_schemes);
+}
+
+const std::vector<std::string>& GetEmptyDocumentSchemes() {
+  Initialize();
+  return *empty_document_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 206 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