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

chrome/browser/extensions/extension_prefs_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 "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
@@ skipping 26 matching lines @@
 const char kDefaultPref3[] = "default pref 3";
 const char kDefaultPref4[] = "default pref 4";
 
 }  // namespace
 
 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();
-  EXPECT_EQ(patterns1.size(), patterns2.size());
-
-  std::set<std::string> strings1;
-  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);
-}
-
 // Base class for tests.
 class ExtensionPrefsTest : public testing::Test {
  public:
   ExtensionPrefsTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_) {
   }
 
   // This function will get called once, and is the right place to do operations
   // on ExtensionPrefs that write data.
@@ skipping 184 matching lines @@
     granted_permissions.reset();
 
     // Add part of the explicit host permissions.
     permissions.reset(new ExtensionPermissionSet(
         empty_set, ehost_perm_set1_, empty_extent));
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
     granted_permissions.reset(prefs()->GetGrantedPermissions(extension_id_));
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
     EXPECT_EQ(expected_apis, granted_permissions->apis());
-    AssertEqualExtents(ehost_perm_set1_,
-                       granted_permissions->explicit_hosts());
-    AssertEqualExtents(ehost_perm_set1_,
-                       granted_permissions->effective_hosts());
+    EXPECT_EQ(ehost_perm_set1_,
+              granted_permissions->explicit_hosts());
+    EXPECT_EQ(ehost_perm_set1_,
+              granted_permissions->effective_hosts());
 
     // Add part of the scriptable host permissions.
     permissions.reset(new ExtensionPermissionSet(
         empty_set, empty_extent, shost_perm_set1_));
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
     granted_permissions.reset(prefs()->GetGrantedPermissions(extension_id_));
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
     EXPECT_EQ(expected_apis, granted_permissions->apis());
-    AssertEqualExtents(ehost_perm_set1_,
-                       granted_permissions->explicit_hosts());
-    AssertEqualExtents(shost_perm_set1_,
-                       granted_permissions->scriptable_hosts());
+    EXPECT_EQ(ehost_perm_set1_,
+              granted_permissions->explicit_hosts());
+    EXPECT_EQ(shost_perm_set1_,
+              granted_permissions->scriptable_hosts());
+
     URLPatternSet::CreateUnion(ehost_perm_set1_, shost_perm_set1_,
                                &effective_permissions_);
-    AssertEqualExtents(effective_permissions_,
-                       granted_permissions->effective_hosts());
+    EXPECT_EQ(effective_permissions_, granted_permissions->effective_hosts());
 
     // Add the rest of both the permissions.
     permissions.reset(new ExtensionPermissionSet(
        api_perm_set2_, ehost_perm_set2_, shost_perm_set2_));
 
     std::set_union(expected_apis.begin(), expected_apis.end(),
                    api_perm_set2_.begin(), api_perm_set2_.end(),
                    std::inserter(api_permissions_, api_permissions_.begin()));
 
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
     granted_permissions.reset(prefs()->GetGrantedPermissions(extension_id_));
     EXPECT_TRUE(granted_permissions.get());
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_EQ(api_permissions_, granted_permissions->apis());
-    AssertEqualExtents(ehost_permissions_,
-                       granted_permissions->explicit_hosts());
-    AssertEqualExtents(shost_permissions_,
-                       granted_permissions->scriptable_hosts());
+    EXPECT_EQ(ehost_permissions_,
+              granted_permissions->explicit_hosts());
+    EXPECT_EQ(shost_permissions_,
+              granted_permissions->scriptable_hosts());
     effective_permissions_.ClearPatterns();
     URLPatternSet::CreateUnion(ehost_permissions_, shost_permissions_,
                                &effective_permissions_);
-    AssertEqualExtents(effective_permissions_,
-                       granted_permissions->effective_hosts());
+    EXPECT_EQ(effective_permissions_, granted_permissions->effective_hosts());
   }
 
   virtual void Verify() {
     scoped_ptr<ExtensionPermissionSet> permissions(
         prefs()->GetGrantedPermissions(extension_id_));
     EXPECT_TRUE(permissions.get());
     EXPECT_FALSE(permissions->HasEffectiveFullAccess());
     EXPECT_EQ(api_permissions_, permissions->apis());
-    AssertEqualExtents(ehost_permissions_, permissions->explicit_hosts());
-    AssertEqualExtents(shost_permissions_, permissions->scriptable_hosts());
+    EXPECT_EQ(ehost_permissions_,
+              permissions->explicit_hosts());
+    EXPECT_EQ(shost_permissions_,
+              permissions->scriptable_hosts());
   }
 
  private:
   std::string extension_id_;
   ExtensionAPIPermissionSet api_perm_set1_;
   ExtensionAPIPermissionSet api_perm_set2_;
   URLPatternSet ehost_perm_set1_;
   URLPatternSet ehost_perm_set2_;
   URLPatternSet shost_perm_set1_;
   URLPatternSet shost_perm_set2_;
@@ skipping 667 matching lines @@
     testing::Mock::VerifyAndClearExpectations(v1i);
     testing::Mock::VerifyAndClearExpectations(v2);
     testing::Mock::VerifyAndClearExpectations(v2i);
   }
 
   virtual void Verify() {
   }
 };
 TEST_F(ExtensionPrefsSetExtensionControlledPref,
     ExtensionPrefsSetExtensionControlledPref) {}