Update URLPatternSet to contain a std::set instead of std::vector.

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2011 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/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 96 matching lines @@
   std::stable_sort(ret_val.begin(), ret_val.end());
 
   return ret_val;
 }
 
 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
-static void AssertEqualExtents(const URLPatternSet& extent1,
-                               const URLPatternSet& extent2) {
-  URLPatternList patterns1 = extent1.patterns();
-  URLPatternList patterns2 = extent2.patterns();
-  std::set<std::string> strings1;
-  EXPECT_EQ(patterns1.size(), patterns2.size());
-
-  for (size_t i = 0; i < patterns1.size(); ++i)
-    strings1.insert(patterns1.at(i).GetAsString());
-
-  std::set<std::string> strings2;
-  for (size_t i = 0; i < patterns2.size(); ++i)
-    strings2.insert(patterns2.at(i).GetAsString());
-
-  EXPECT_EQ(strings1, strings2);
-}
-
 }  // namespace
 
 class MockExtensionProvider : public ExternalExtensionProviderInterface {
  public:
   explicit MockExtensionProvider(
       VisitorInterface* visitor,
       Extension::Location location)
   : location_(location), visitor_(visitor), visit_count_(0) {
   }
   virtual ~MockExtensionProvider() {}
@@ skipping 854 matching lines @@
   EXPECT_EQ(expected_num_extensions, service_->extensions()->size());
 
   ValidatePrefKeyCount(3);
   ValidateIntegerPref(good0, "state", Extension::ENABLED);
   ValidateIntegerPref(good0, "location", Extension::INTERNAL);
   ValidateIntegerPref(good1, "state", Extension::ENABLED);
   ValidateIntegerPref(good1, "location", Extension::INTERNAL);
   ValidateIntegerPref(good2, "state", Extension::ENABLED);
   ValidateIntegerPref(good2, "location", Extension::INTERNAL);
 
+  URLPatternSet expected_patterns;
+  AddPattern(&expected_patterns, "file:///*");
+  AddPattern(&expected_patterns, "http://*.google.com/*");
+  AddPattern(&expected_patterns, "https://*.google.com/*");
   const Extension* extension = loaded_[0];
   const UserScriptList& scripts = extension->content_scripts();
   ASSERT_EQ(2u, scripts.size());
-  EXPECT_EQ(3u, scripts[0].url_patterns().size());
-  EXPECT_EQ("file:///*",
-            scripts[0].url_patterns()[0].GetAsString());
-  EXPECT_EQ("http://*.google.com/*",
-            scripts[0].url_patterns()[1].GetAsString());
-  EXPECT_EQ("https://*.google.com/*",
-            scripts[0].url_patterns()[2].GetAsString());
+  EXPECT_EQ(expected_patterns, scripts[0].url_patterns());
   EXPECT_EQ(2u, scripts[0].js_scripts().size());
   ExtensionResource resource00(extension->id(),
                                scripts[0].js_scripts()[0].extension_root(),
                                scripts[0].js_scripts()[0].relative_path());
   FilePath expected_path(extension->path().AppendASCII("script1.js"));
   ASSERT_TRUE(file_util::AbsolutePath(&expected_path));
   EXPECT_TRUE(resource00.ComparePathWithDefault(expected_path));
   ExtensionResource resource01(extension->id(),
                                scripts[0].js_scripts()[1].extension_root(),
                                scripts[0].js_scripts()[1].relative_path());
   expected_path = extension->path().AppendASCII("script2.js");
   ASSERT_TRUE(file_util::AbsolutePath(&expected_path));
   EXPECT_TRUE(resource01.ComparePathWithDefault(expected_path));
   EXPECT_TRUE(extension->plugins().empty());
-  EXPECT_EQ(1u, scripts[1].url_patterns().size());
-  EXPECT_EQ("http://*.news.com/*", scripts[1].url_patterns()[0].GetAsString());
+  EXPECT_EQ(1u, scripts[1].url_patterns().patterns().size());
+  EXPECT_EQ("http://*.news.com/*",
+            scripts[1].url_patterns().begin()->GetAsString());
   ExtensionResource resource10(extension->id(),
                                scripts[1].js_scripts()[0].extension_root(),
                                scripts[1].js_scripts()[0].relative_path());
   expected_path =
       extension->path().AppendASCII("js_files").AppendASCII("script3.js");
   ASSERT_TRUE(file_util::AbsolutePath(&expected_path));
   EXPECT_TRUE(resource10.ComparePathWithDefault(expected_path));
-  const URLPatternList permissions =
-      extension->permission_set()->explicit_hosts().patterns();
-  ASSERT_EQ(2u, permissions.size());
-  EXPECT_EQ("http://*.google.com/*", permissions[0].GetAsString());
-  EXPECT_EQ("https://*.google.com/*", permissions[1].GetAsString());
+
+  expected_patterns.ClearPatterns();
+  AddPattern(&expected_patterns, "http://*.google.com/*");
+  AddPattern(&expected_patterns, "https://*.google.com/*");
+  EXPECT_EQ(expected_patterns, extension->permission_set()->explicit_hosts());
 
   EXPECT_EQ(std::string(good1), loaded_[1]->id());
   EXPECT_EQ(std::string("My extension 2"), loaded_[1]->name());
   EXPECT_EQ(std::string(""), loaded_[1]->description());
   EXPECT_EQ(loaded_[1]->GetResourceURL("background.html"),
             loaded_[1]->background_url());
   EXPECT_EQ(0u, loaded_[1]->content_scripts().size());
   // We don't parse the plugins section on Chrome OS.
 #if defined(OS_CHROMEOS)
   EXPECT_EQ(0u, loaded_[1]->plugins().size());
@@ skipping 344 matching lines @@
   AddPattern(&expected_host_perms, "http://*.google.com/*");
   AddPattern(&expected_host_perms, "https://*.google.com/*");
   AddPattern(&expected_host_perms, "http://*.google.com.hk/*");
   AddPattern(&expected_host_perms, "http://www.example.com/*");
 
   known_perms.reset(prefs->GetGrantedPermissions(extension_id));
   EXPECT_TRUE(known_perms.get());
   EXPECT_FALSE(known_perms->IsEmpty());
   EXPECT_EQ(expected_api_perms, known_perms->apis());
   EXPECT_FALSE(known_perms->HasEffectiveFullAccess());
-  AssertEqualExtents(expected_host_perms, known_perms->effective_hosts());
+  EXPECT_EQ(expected_host_perms, known_perms->effective_hosts());
 }
 
 #if !defined(OS_CHROMEOS)
 // Tests that the granted permissions full_access bit gets set correctly when
 // an extension contains an NPAPI plugin. Don't run this test on Chrome OS
 // since they don't support plugins.
 TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_
@@ skipping 74 matching lines @@
   ASSERT_TRUE(prefs->GetExtensionState(extension_id) == Extension::ENABLED);
   ASSERT_TRUE(service_->IsExtensionEnabled(extension_id));
   ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
 
   scoped_ptr<ExtensionPermissionSet> current_perms(
       prefs->GetGrantedPermissions(extension_id));
   ASSERT_TRUE(current_perms.get());
   ASSERT_FALSE(current_perms->IsEmpty());
   ASSERT_FALSE(current_perms->HasEffectiveFullAccess());
   ASSERT_EQ(expected_api_permissions, current_perms->apis());
-  AssertEqualExtents(expected_host_permissions,
-                     current_perms->effective_hosts());
+  ASSERT_EQ(expected_host_permissions, current_perms->effective_hosts());
 
   // Tests that the extension is disabled when a host permission is missing from
   // the extension's granted host permissions preference. (This simulates
   // updating the browser to a version which recognizes additional host
   // permissions).
   host_permissions.clear();
   current_perms.reset();
 
   host_permissions.insert("http://*.google.com/*");
   host_permissions.insert("https://*.google.com/*");
@@ skipping 20 matching lines @@
   service_->GrantPermissionsAndEnableExtension(extension);
 
   ASSERT_TRUE(service_->IsExtensionEnabled(extension_id));
   ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
 
   current_perms.reset(prefs->GetGrantedPermissions(extension_id));
   ASSERT_TRUE(current_perms.get());
   ASSERT_FALSE(current_perms->IsEmpty());
   ASSERT_FALSE(current_perms->HasEffectiveFullAccess());
   ASSERT_EQ(expected_api_permissions, current_perms->apis());
-  AssertEqualExtents(expected_host_permissions,
-                     current_perms->effective_hosts());
+  ASSERT_EQ(expected_host_permissions, current_perms->effective_hosts());
 }
 
 // Test Packaging and installing an extension.
 TEST_F(ExtensionServiceTest, PackExtension) {
   InitializeEmptyExtensionService();
   FilePath input_directory = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
@@ skipping 2248 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, true);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }