Make extensions use a correct same-origin check.

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"
 #include "base/memory/linked_ptr.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/url_pattern.h"
 #include "url/gurl.h"
+#include "url/origin.h"
 #include "url/url_constants.h"
 
 namespace extensions {
 
 namespace {
 
 const char kInvalidURLPatternError[] = "Invalid url pattern '*'";
 
 }  // namespace
 
@@ skipping 118 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);
+  if (origin.is_empty())
+    return false;
+  const url::Origin real_origin(origin);
+  DCHECK(real_origin.IsSameOriginWith(url::Origin(origin.GetOrigin())));

[Devlin, 2016/02/03 21:01:25]

Can we not use the static IsSameOriginWith() here?

[palmer, 2016/02/03 21:03:08]

No, I actually want to maintain the check on GURL::GetOrigin.

[Devlin, 2016/02/03 21:10:11]

I'm sure that's right.  Can you tell me why? :) (For my own edification)

   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) {
+  if (origin_pattern.Parse(origin.spec()) != URLPattern::PARSE_SUCCESS) {
     return false;
   }
   origin_pattern.SetPath("/*");
   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))
@@ skipping 107 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