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

chrome/common/extensions/extension_manifests_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.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 12 matching lines @@
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_sidebar_defaults.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "content/common/json_value_serializer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
+
+namespace {
+
+static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
+  int schemes = URLPattern::SCHEME_ALL;
+  extent->AddPattern(URLPattern(schemes, pattern));
+}
+
+}
+
 namespace errors = extension_manifest_errors;
 namespace keys = extension_manifest_keys;
 
 class ExtensionManifestTest : public testing::Test {
  public:
   ExtensionManifestTest() : enable_apps_(true) {}
 
  protected:
   DictionaryValue* LoadManifestFile(const std::string& filename,
                                     std::string* error) {
@@ skipping 252 matching lines @@
 // backwards compatibility (we renamed it to "unlimitedStorage").
 TEST_F(ExtensionManifestTest, OldUnlimitedStoragePermission) {
   scoped_refptr<Extension> extension = LoadStrictAndExpectSuccess(
       "old_unlimited_storage.json");
   EXPECT_TRUE(extension->HasAPIPermission(
       ExtensionAPIPermission::kUnlimitedStorage));
 }
 
 TEST_F(ExtensionManifestTest, ValidApp) {
   scoped_refptr<Extension> extension(LoadAndExpectSuccess("valid_app.json"));
-  ASSERT_EQ(2u, extension->web_extent().patterns().size());
-  EXPECT_EQ("http://www.google.com/mail/*",
-            extension->web_extent().patterns()[0].GetAsString());
-  EXPECT_EQ("http://www.google.com/foobar/*",
-            extension->web_extent().patterns()[1].GetAsString());
+  URLPatternSet expected_patterns;
+  AddPattern(&expected_patterns, "http://www.google.com/mail/*");
+  AddPattern(&expected_patterns, "http://www.google.com/foobar/*");
+  EXPECT_EQ(expected_patterns, extension->web_extent());
   EXPECT_EQ(extension_misc::LAUNCH_TAB, extension->launch_container());
   EXPECT_EQ("http://www.google.com/mail/", extension->launch_web_url());
 }
 
 TEST_F(ExtensionManifestTest, AppWebUrls) {
   LoadAndExpectError("web_urls_wrong_type.json",
                      errors::kInvalidWebURLs);
   LoadAndExpectError(
       "web_urls_invalid_1.json",
       ExtensionErrorUtils::FormatErrorMessage(
@@ skipping 38 matching lines @@
       ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidWebURL,
           base::IntToString(1),
           URLPattern::GetParseResultString(URLPattern::PARSE_ERROR_HAS_COLON)));
 
 
   scoped_refptr<Extension> extension(
       LoadAndExpectSuccess("web_urls_default.json"));
   ASSERT_EQ(1u, extension->web_extent().patterns().size());
   EXPECT_EQ("*://www.google.com/*",
-            extension->web_extent().patterns()[0].GetAsString());
+            extension->web_extent().patterns().begin()->GetAsString());
 }
 
 TEST_F(ExtensionManifestTest, AppLaunchContainer) {
   scoped_refptr<Extension> extension;
 
   extension = LoadAndExpectSuccess("launch_tab.json");
   EXPECT_EQ(extension_misc::LAUNCH_TAB, extension->launch_container());
 
   extension = LoadAndExpectSuccess("launch_panel.json");
   EXPECT_EQ(extension_misc::LAUNCH_PANEL, extension->launch_container());
@@ skipping 306 matching lines @@
 
   extension = LoadAndExpectSuccess("homepage_externally_hosted.json");
   EXPECT_EQ(GURL(), extension->GetHomepageURL());
 }
 
 TEST_F(ExtensionManifestTest, DefaultPathForExtent) {
   scoped_refptr<Extension> extension(
       LoadAndExpectSuccess("default_path_for_extent.json"));
 
   ASSERT_EQ(1u, extension->web_extent().patterns().size());
-  EXPECT_EQ("/*", extension->web_extent().patterns()[0].path());
+  EXPECT_EQ("/*", extension->web_extent().patterns().begin()->path());
   EXPECT_TRUE(extension->web_extent().MatchesURL(
       GURL("http://www.google.com/monkey")));
 }
 
 TEST_F(ExtensionManifestTest, DefaultLocale) {
   LoadAndExpectError("default_locale_invalid.json",
                      extension_manifest_errors::kInvalidDefaultLocale);
 
   scoped_refptr<Extension> extension(
       LoadAndExpectSuccess("default_locale_valid.json"));
@@ skipping 77 matching lines @@
                                               "http:*.html"));
 
   scoped_refptr<Extension> extension(
       LoadAndExpectSuccess("filebrowser_valid.json"));
   ASSERT_TRUE(extension->file_browser_handlers() != NULL);
   ASSERT_EQ(extension->file_browser_handlers()->size(), 1U);
   const FileBrowserHandler* action =
       extension->file_browser_handlers()->at(0).get();
   EXPECT_EQ(action->title(), "Default title");
   EXPECT_EQ(action->icon_path(), "icon.png");
-  const URLPatternList& patterns = action->file_url_patterns();
-  ASSERT_EQ(patterns.size(), 1U);
+  const URLPatternSet& patterns = action->file_url_patterns();
+  ASSERT_EQ(patterns.patterns().size(), 1U);
   ASSERT_TRUE(action->MatchesURL(
       GURL("filesystem:chrome-extension://foo/local/test.txt")));
 }