Allow extensions on chrome:// URLs, when flag is set and permission is explicitly requested

chrome/common/extensions/user_script.cc

 // Copyright (c) 2012 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 "chrome/common/extensions/user_script.h"
 
+#include "base/command_line.h"
 #include "base/pickle.h"
 #include "base/string_util.h"
+#include "chrome/common/chrome_switches.h"
 
 namespace {
 
 bool UrlMatchesGlobs(const std::vector<std::string>* globs,
                      const GURL& url) {
   for (std::vector<std::string>::const_iterator glob = globs->begin();
        glob != globs->end(); ++glob) {
     if (MatchPattern(url.spec(), *glob))
       return true;
   }
 
   return false;
 }
 
 }  // namespace
 
 namespace extensions {
 
 // static
 const char UserScript::kFileExtension[] = ".user.js";
 
 bool UserScript::IsURLUserScript(const GURL& url,
                                  const std::string& mime_type) {
   return EndsWith(url.ExtractFileName(), kFileExtension, false) &&
       mime_type != "text/html";
 }
 
+// static
+int UserScript::ValidUserScriptSchemes(bool canExecuteScriptEverywhere) {
+  if (canExecuteScriptEverywhere)
+    return URLPattern::SCHEME_ALL;
+  int valid_schemes = kValidUserScriptSchemes;
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kExtensionsOnChromeURLs)) {
+    valid_schemes &= ~URLPattern::SCHEME_CHROMEUI;
+  }
+  return valid_schemes;
+}
+
 UserScript::File::File(const base::FilePath& extension_root,
                        const base::FilePath& relative_path,
                        const GURL& url)
     : extension_root_(extension_root),
       relative_path_(relative_path),
       url_(url) {
 }
 
 UserScript::File::File() {}
 
@@ skipping 75 matching lines @@
        glob != globs.end(); ++glob) {
     pickle->WriteString(*glob);
   }
 }
 
 void UserScript::PickleURLPatternSet(::Pickle* pickle,
                                      const URLPatternSet& pattern_list) const {
   pickle->WriteUInt64(pattern_list.patterns().size());
   for (URLPatternSet::const_iterator pattern = pattern_list.begin();
        pattern != pattern_list.end(); ++pattern) {
+    pickle->WriteString(pattern->GetAsString());

[Matt Perry, 2013/03/19 17:49:32]

Why change this?

[aboxhall, 2013/03/20 22:04:59]

Because I don't want to set valid_schemes until after parsing the pattern. I
could unpickle it and then add it after parsing the pattern, I guess; this could
conceivably break stuff?

[Matt Perry, 2013/03/20 22:32:48]

Yeah I'd prefer to keep the old pickle order, just to avoid churn. You can
unpickle both the pattern and valid_schemes before parsing/setting the schemes.
(As in, the order you read the vars has no effect on the order of parsing.)

[aboxhall, 2013/03/20 22:51:48]

Good call, done.

     pickle->WriteInt(pattern->valid_schemes());
-    pickle->WriteString(pattern->GetAsString());
   }
 }
 
 void UserScript::PickleScripts(::Pickle* pickle,
                                const FileList& scripts) const {
   pickle->WriteUInt64(scripts.size());
   for (FileList::const_iterator file = scripts.begin();
        file != scripts.end(); ++file) {
     file->Pickle(pickle);
   }
@@ skipping 32 matching lines @@
 }
 
 void UserScript::UnpickleURLPatternSet(const ::Pickle& pickle,
                                        PickleIterator* iter,
                                        URLPatternSet* pattern_list) {
   uint64 num_patterns = 0;
   CHECK(pickle.ReadUInt64(iter, &num_patterns));
 
   pattern_list->ClearPatterns();
   for (uint64 i = 0; i < num_patterns; ++i) {
+    std::string pattern_str;
+    URLPattern pattern(kValidUserScriptSchemes);
+    CHECK(pickle.ReadString(iter, &pattern_str));
+
+    URLPattern::ParseResult result = pattern.Parse(pattern_str);
+    CHECK(URLPattern::PARSE_SUCCESS == result) <<
+        URLPattern::GetParseResultString(result) << " " << pattern_str.c_str();
+
     int valid_schemes;
     CHECK(pickle.ReadInt(iter, &valid_schemes));
-    std::string pattern_str;
-    URLPattern pattern(valid_schemes);
-    CHECK(pickle.ReadString(iter, &pattern_str));
-
-    // We remove the file scheme if it's not actually allowed (see Extension::
-    // LoadUserScriptHelper), but we need it temporarily while loading the
-    // pattern so that it's valid.
-    bool had_file_scheme = (valid_schemes & URLPattern::SCHEME_FILE) != 0;
-    if (!had_file_scheme)
-      pattern.SetValidSchemes(valid_schemes | URLPattern::SCHEME_FILE);
-    CHECK(URLPattern::PARSE_SUCCESS == pattern.Parse(pattern_str));
-    if (!had_file_scheme)
-      pattern.SetValidSchemes(valid_schemes);
-
+    pattern.SetValidSchemes(valid_schemes);
     pattern_list->AddPattern(pattern);
   }
 }
 
 void UserScript::UnpickleScripts(const ::Pickle& pickle, PickleIterator* iter,
                                  FileList* scripts) {
   uint64 num_files = 0;
   CHECK(pickle.ReadUInt64(iter, &num_files));
   scripts->clear();
   for (uint64 i = 0; i < num_files; ++i) {
     File file;
     file.Unpickle(pickle, iter);
     scripts->push_back(file);
   }
 }
 
 }  // namespace extensions