Support "always allow" for runtime script execution

extensions/common/url_pattern_set.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 "extensions/common/url_pattern_set.h"
 
 #include <iterator>
 #include <ostream>
 
 #include "base/logging.h"
@@ skipping 124 matching lines @@
 
 void URLPatternSet::AddPatterns(const URLPatternSet& set) {
   patterns_.insert(set.patterns().begin(),
                    set.patterns().end());
 }
 
 void URLPatternSet::ClearPatterns() {
   patterns_.clear();
 }
 
+bool URLPatternSet::AddOrigin(int valid_schemes, const GURL& origin) {
+  DCHECK_EQ(origin.GetOrigin(), origin);
+  URLPattern origin_pattern(valid_schemes);
+  // Origin adding could fail if |origin| does not match |valid_schemes|.
+  if (origin_pattern.Parse(origin.GetOrigin().spec()) !=
+      URLPattern::PARSE_SUCCESS) {
+    return false;
+  }
+  origin_pattern.SetPath("/*");

[not at google - send to devlin, 2014/08/14 21:03:55]

Just "*" should do it?

You need to add tests for this function.

[gpdavis, 2014/08/14 21:59:53]

That's what I thought as well, but without the slash, the browser crashes when
"always run" is clicked.

Adding tests...

Is there a reason we pass in |valid_schemes| here?  Can't this method just use
URLPattern::SCHEME_ALL by default?  Will/should passing in something different
affect the pattern that's added at all?  It's already intended to match only the
scheme of the origin.

In fact, it seems like the scheme should be extracted from |origin|.

[not at google - send to devlin, 2014/08/14 22:05:33]

Good question. The scheme would reject origins like chrome://foo and
chrome-extension://asdf, as just a low-level layer of sanity checking that we
don't accidentally give extensions access to those URLs.

[gpdavis, 2014/08/14 23:31:33]

Ah, okay.  I just realized we're passing in ValidUserScriptSchemes, not
SCHEME_ALL.  So this is fine as is?

+  return AddPattern(origin_pattern);
+}
+
 bool URLPatternSet::Contains(const URLPatternSet& other) const {
   for (URLPatternSet::const_iterator it = other.begin();
        it != other.end(); ++it) {
     if (!ContainsPattern(*it))
       return false;
   }
 
   return true;
 }
 
@@ skipping 102 matching lines @@
   for (size_t i = 0; i < value.GetSize(); ++i) {
     std::string item;
     if (!value.GetString(i, &item))
       return false;
     patterns.push_back(item);
   }
   return Populate(patterns, valid_schemes, allow_file_access, error);
 }
 
 }  // namespace extensions