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

chrome/common/extensions/extension_permission_set_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/common/extensions/extension_permission_set.h"
 
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 40 matching lines @@
   for (size_t i = 0; i < expected.size(); ++i) {
     EXPECT_EQ(expected[i], actual[i]);
   }
 }
 
 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 ExtensionAPIPermissionTest : public testing::Test {
 };
 
 class ExtensionPermissionSetTest : public testing::Test {
 };
 
 
 // Tests GetByID.
@@ skipping 241 matching lines @@
   AddPattern(&effective_hosts, "http://*.google.com/*");
 
   set1.reset(new ExtensionPermissionSet(
       apis1, explicit_hosts1, scriptable_hosts1));
   set2.reset(new ExtensionPermissionSet(
       apis2, explicit_hosts2, scriptable_hosts2));
   union_set.reset(ExtensionPermissionSet::CreateUnion(set1.get(), set2.get()));
 
   EXPECT_FALSE(union_set->HasEffectiveFullAccess());
   EXPECT_EQ(expected_apis, union_set->apis());
-  AssertEqualExtents(expected_explicit_hosts, union_set->explicit_hosts());
-  AssertEqualExtents(expected_scriptable_hosts, union_set->scriptable_hosts());
-  AssertEqualExtents(expected_explicit_hosts, union_set->effective_hosts());
+  EXPECT_EQ(expected_explicit_hosts, union_set->explicit_hosts());
+  EXPECT_EQ(expected_scriptable_hosts, union_set->scriptable_hosts());
+  EXPECT_EQ(expected_explicit_hosts, union_set->effective_hosts());
 
   // Now use a real second set.
   apis2.insert(ExtensionAPIPermission::kTab);
   apis2.insert(ExtensionAPIPermission::kProxy);
   apis2.insert(ExtensionAPIPermission::kClipboardWrite);
   apis2.insert(ExtensionAPIPermission::kPlugin);
   expected_apis.insert(ExtensionAPIPermission::kTab);
   expected_apis.insert(ExtensionAPIPermission::kProxy);
   expected_apis.insert(ExtensionAPIPermission::kClipboardWrite);
   expected_apis.insert(ExtensionAPIPermission::kPlugin);
 
   AddPattern(&explicit_hosts2, "http://*.example.com/*");
   AddPattern(&scriptable_hosts2, "http://*.google.com/*");
   AddPattern(&expected_explicit_hosts, "http://*.example.com/*");
   AddPattern(&expected_scriptable_hosts, "http://*.google.com/*");
 
   effective_hosts.ClearPatterns();
   AddPattern(&effective_hosts, "<all_urls>");
 
   set2.reset(new ExtensionPermissionSet(
       apis2, explicit_hosts2, scriptable_hosts2));
   union_set.reset(ExtensionPermissionSet::CreateUnion(set1.get(), set2.get()));
   EXPECT_TRUE(union_set->HasEffectiveFullAccess());
   EXPECT_TRUE(union_set->HasEffectiveAccessToAllHosts());
   EXPECT_EQ(expected_apis, union_set->apis());
-  AssertEqualExtents(expected_explicit_hosts, union_set->explicit_hosts());
-  AssertEqualExtents(expected_scriptable_hosts, union_set->scriptable_hosts());
-  AssertEqualExtents(effective_hosts, union_set->effective_hosts());
+  EXPECT_EQ(expected_explicit_hosts, union_set->explicit_hosts());
+  EXPECT_EQ(expected_scriptable_hosts, union_set->scriptable_hosts());
+  EXPECT_EQ(effective_hosts, union_set->effective_hosts());
 }
 
 TEST(ExtensionPermissionSetTest, HasLessPrivilegesThan) {
   const struct {
     const char* base_name;
     // Increase these sizes if you have more than 10.
     const char* granted_apis[10];
     const char* granted_hosts[10];
     bool full_access;
     bool expect_increase;
@@ skipping 177 matching lines @@
   }
 }
 
 TEST(ExtensionPermissionSetTest, GetWarningMessages_ManyHosts) {
   scoped_refptr<Extension> extension;
 
   extension = LoadManifest("permissions", "many-hosts.json");
   std::vector<string16> warnings =
       extension->permission_set()->GetWarningMessages();
   ASSERT_EQ(1u, warnings.size());
-  EXPECT_EQ("Your data on www.google.com and encrypted.google.com",
+  EXPECT_EQ("Your data on encrypted.google.com and www.google.com",
             UTF16ToUTF8(warnings[0]));
 }
 
 TEST(ExtensionPermissionSetTest, GetWarningMessages_Plugins) {
   scoped_refptr<Extension> extension;
   scoped_ptr<ExtensionPermissionSet> permissions;
 
   extension = LoadManifest("permissions", "plugins.json");
   std::vector<string16> warnings =
       extension->permission_set()->GetWarningMessages();
   // We don't parse the plugins key on Chrome OS, so it should not ask for any
   // permissions.
 #if defined(OS_CHROMEOS)
   ASSERT_EQ(0u, warnings.size());
 #else
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("All data on your computer and the websites you visit",
             UTF16ToUTF8(warnings[0]));
 #endif
 }
 
 TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
   scoped_ptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet empty_perms;
-  std::vector<std::string> expected;
-  expected.push_back("www.foo.com");
-  expected.push_back("www.bar.com");
-  expected.push_back("www.baz.com");
+  std::set<std::string> expected;
+  expected.insert("www.foo.com");
+  expected.insert("www.bar.com");
+  expected.insert("www.baz.com");
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
 
   {
     SCOPED_TRACE("no dupes");
 
     // Simple list with no dupes.
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.bar.com/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.baz.com/path"));
     perm_set.reset(new ExtensionPermissionSet(
        empty_perms, explicit_hosts, scriptable_hosts));
-    CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+    EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
   {
     SCOPED_TRACE("two dupes");
 
     // Add some dupes.
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.baz.com/path"));
     perm_set.reset(new ExtensionPermissionSet(
             empty_perms, explicit_hosts, scriptable_hosts));
-    CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+    EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
   {
     SCOPED_TRACE("schemes differ");
 
     // Add a pattern that differs only by scheme. This should be filtered out.
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTPS, "https://www.bar.com/path"));
     perm_set.reset(new ExtensionPermissionSet(
             empty_perms, explicit_hosts, scriptable_hosts));
-    CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+    EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
   {
     SCOPED_TRACE("paths differ");
 
     // Add some dupes by path.
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.bar.com/pathypath"));
     perm_set.reset(new ExtensionPermissionSet(
             empty_perms, explicit_hosts, scriptable_hosts));
-    CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+    EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
   {
     SCOPED_TRACE("subdomains differ");
 
     // We don't do anything special for subdomains.
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://monkey.www.bar.com/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://bar.com/path"));
 
-    expected.push_back("monkey.www.bar.com");
-    expected.push_back("bar.com");
+    expected.insert("monkey.www.bar.com");
+    expected.insert("bar.com");
 
     perm_set.reset(new ExtensionPermissionSet(
             empty_perms, explicit_hosts, scriptable_hosts));
-    CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+    EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
   {
     SCOPED_TRACE("RCDs differ");
 
     // Now test for RCD uniquing.
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.de/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca.us/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.net/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com.my/path"));
 
     // This is an unknown RCD, which shouldn't be uniqued out.
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.xyzzy/path"));
     // But it should only occur once.
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.xyzzy/path"));
 
-    expected.push_back("www.foo.xyzzy");
+    expected.insert("www.foo.xyzzy");
 
     perm_set.reset(new ExtensionPermissionSet(
             empty_perms, explicit_hosts, scriptable_hosts));
-    CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+    EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
   {
     SCOPED_TRACE("wildcards");
 
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://*.google.com/*"));
 
-    expected.push_back("*.google.com");
+    expected.insert("*.google.com");
 
     perm_set.reset(new ExtensionPermissionSet(
             empty_perms, explicit_hosts, scriptable_hosts));
-    CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+    EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
   {
     SCOPED_TRACE("scriptable hosts");
     explicit_hosts.ClearPatterns();
     scriptable_hosts.ClearPatterns();
     expected.clear();
 
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://*.google.com/*"));
     scriptable_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://*.example.com/*"));
 
-    expected.push_back("*.google.com");
-    expected.push_back("*.example.com");
+    expected.insert("*.google.com");
+    expected.insert("*.example.com");
 
     perm_set.reset(new ExtensionPermissionSet(
             empty_perms, explicit_hosts, scriptable_hosts));
-    CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+    EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 }
 
 TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay_ComIsBestRcd) {
   scoped_ptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.org/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.net/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
 
-  std::vector<std::string> expected;
-  expected.push_back("www.foo.com");
+  std::set<std::string> expected;
+  expected.insert("www.foo.com");
   perm_set.reset(new ExtensionPermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts));
-  CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+  EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
 TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay_NetIs2ndBestRcd) {
   scoped_ptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.org/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.net/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
   // No http://www.foo.com/path
 
-  std::vector<std::string> expected;
-  expected.push_back("www.foo.net");
+  std::set<std::string> expected;
+  expected.insert("www.foo.net");
   perm_set.reset(new ExtensionPermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts));
-  CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+  EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
 TEST(ExtensionPermissionSetTest,
      GetDistinctHostsForDisplay_OrgIs3rdBestRcd) {
   scoped_ptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.org/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
   // No http://www.foo.net/path
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
   // No http://www.foo.com/path
 
-  std::vector<std::string> expected;
-  expected.push_back("www.foo.org");
+  std::set<std::string> expected;
+  expected.insert("www.foo.org");
   perm_set.reset(new ExtensionPermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts));
-  CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+  EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
 TEST(ExtensionPermissionSetTest,
      GetDistinctHostsForDisplay_FirstInListIs4thBestRcd) {
   scoped_ptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
   // No http://www.foo.org/path
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
   // No http://www.foo.net/path
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
   // No http://www.foo.com/path
 
-  std::vector<std::string> expected;
-  expected.push_back("www.foo.ca");
+  std::set<std::string> expected;
+  expected.insert("www.foo.ca");
   perm_set.reset(new ExtensionPermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts));
-  CompareLists(expected, perm_set->GetDistinctHostsForDisplay());
+  EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
 TEST(ExtensionPermissionSetTest, HasLessHostPrivilegesThan) {
   URLPatternSet elist1;
   URLPatternSet elist2;
   URLPatternSet slist1;
   URLPatternSet slist2;
   scoped_ptr<ExtensionPermissionSet> set1;
   scoped_ptr<ExtensionPermissionSet> set2;
   ExtensionAPIPermissionSet empty_perms;
@@ skipping 98 matching lines @@
   AddPattern(&non_empty_extent, "http://www.google.com/*");
 
   perm_set = ExtensionPermissionSet(
       empty_apis, non_empty_extent, empty_extent);
   EXPECT_FALSE(perm_set.IsEmpty());
 
   perm_set = ExtensionPermissionSet(
       empty_apis, empty_extent, non_empty_extent);
   EXPECT_FALSE(perm_set.IsEmpty());
 }