Move MatchPattern to its own header and the base namespace.

chrome/browser/extensions/api/tabs/tabs_test.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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
+#include "base/strings/pattern.h"
+#include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/devtools/devtools_window_testing.h"
 #include "chrome/browser/extensions/api/tabs/tabs_api.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 35 matching lines @@
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, GetWindow) {
   int window_id = ExtensionTabUtil::GetWindowId(browser());
 
   // Invalid window ID error.
   scoped_refptr<WindowsGetFunction> function = new WindowsGetFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
-  EXPECT_TRUE(MatchPattern(
+  EXPECT_TRUE(base::MatchPattern(
       utils::RunFunctionAndReturnError(
-          function.get(),
-          base::StringPrintf("[%u]", window_id + 1),
-          browser()),
+          function.get(), base::StringPrintf("[%u]", window_id + 1), browser()),
       keys::kWindowNotFoundError));
 
   // Basic window details.
   gfx::Rect bounds;
   if (browser()->window()->IsMinimized())
     bounds = browser()->window()->GetRestoredBounds();
   else
     bounds = browser()->window()->GetBounds();
 
   function = new WindowsGetFunction();
@@ skipping 49 matching lines @@
           browser())));
   EXPECT_EQ("popup", api_test_utils::GetString(result.get(), "type"));
 
   // Incognito.
   Browser* incognito_browser = CreateIncognitoBrowser();
   int incognito_window_id = ExtensionTabUtil::GetWindowId(incognito_browser);
 
   // Without "include_incognito".
   function = new WindowsGetFunction();
   function->set_extension(extension.get());
-  EXPECT_TRUE(MatchPattern(
+  EXPECT_TRUE(base::MatchPattern(
       utils::RunFunctionAndReturnError(
-          function.get(),
-          base::StringPrintf("[%u]", incognito_window_id),
+          function.get(), base::StringPrintf("[%u]", incognito_window_id),
           browser()),
       keys::kWindowNotFoundError));
 
   // With "include_incognito".
   function = new WindowsGetFunction();
   function->set_extension(extension.get());
   result.reset(utils::ToDictionary(
       utils::RunFunctionAndReturnSingleResult(
           function.get(),
           base::StringPrintf("[%u]", incognito_window_id),
@@ skipping 206 matching lines @@
   static const char kArgsWithExplicitIncognitoParam[] =
       "[{\"url\": \"about:blank\", \"incognito\": false }]";
   // Force Incognito mode.
   IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(),
                                       IncognitoModePrefs::FORCED);
 
   // Run with an explicit "incognito" param.
   scoped_refptr<WindowsCreateFunction> function = new WindowsCreateFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
-  EXPECT_TRUE(MatchPattern(
-      utils::RunFunctionAndReturnError(function.get(),
-                                       kArgsWithExplicitIncognitoParam,
-                                       browser()),
+  EXPECT_TRUE(base::MatchPattern(
+      utils::RunFunctionAndReturnError(
+          function.get(), kArgsWithExplicitIncognitoParam, browser()),
       keys::kIncognitoModeIsForced));
 
   // Now try opening a normal window from incognito window.
   Browser* incognito_browser = CreateIncognitoBrowser();
   // Run with an explicit "incognito" param.
   function = new WindowsCreateFunction();
   function->set_extension(extension.get());
-  EXPECT_TRUE(MatchPattern(
-      utils::RunFunctionAndReturnError(function.get(),
-                                       kArgsWithExplicitIncognitoParam,
-                                       incognito_browser),
+  EXPECT_TRUE(base::MatchPattern(
+      utils::RunFunctionAndReturnError(
+          function.get(), kArgsWithExplicitIncognitoParam, incognito_browser),
       keys::kIncognitoModeIsForced));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest,
                        DontCreateIncognitoWindowWhenIncognitoDisabled) {
   static const char kArgs[] =
       "[{\"url\": \"about:blank\", \"incognito\": true }]";
 
   Browser* incognito_browser = CreateIncognitoBrowser();
   // Disable Incognito mode.
   IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(),
                                       IncognitoModePrefs::DISABLED);
   // Run in normal window.
   scoped_refptr<WindowsCreateFunction> function = new WindowsCreateFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
-  EXPECT_TRUE(MatchPattern(
-      utils::RunFunctionAndReturnError(function.get(),
-                                       kArgs,
-                                       browser()),
+  EXPECT_TRUE(base::MatchPattern(
+      utils::RunFunctionAndReturnError(function.get(), kArgs, browser()),
       keys::kIncognitoModeIsDisabled));
 
   // Run in incognito window.
   function = new WindowsCreateFunction();
   function->set_extension(extension.get());
-  EXPECT_TRUE(MatchPattern(
-      utils::RunFunctionAndReturnError(function.get(),
-                                       kArgs,
-                                       incognito_browser),
-      keys::kIncognitoModeIsDisabled));
+  EXPECT_TRUE(base::MatchPattern(utils::RunFunctionAndReturnError(
+                                     function.get(), kArgs, incognito_browser),
+                                 keys::kIncognitoModeIsDisabled));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, QueryCurrentWindowTabs) {
   const size_t kExtraWindows = 3;
   for (size_t i = 0; i < kExtraWindows; ++i)
     CreateBrowser(browser()->profile());
 
   GURL url(url::kAboutBlankURL);
   AddTabAtIndex(0, url, ui::PAGE_TRANSITION_LINK);
   int window_id = ExtensionTabUtil::GetWindowId(browser());
@@ skipping 100 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, InvalidUpdateWindowState) {
   int window_id = ExtensionTabUtil::GetWindowId(browser());
 
   static const char kArgsMinimizedWithFocus[] =
       "[%u, {\"state\": \"minimized\", \"focused\": true}]";
   scoped_refptr<WindowsUpdateFunction> function = new WindowsUpdateFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
-  EXPECT_TRUE(MatchPattern(
+  EXPECT_TRUE(base::MatchPattern(
       utils::RunFunctionAndReturnError(
           function.get(),
-          base::StringPrintf(kArgsMinimizedWithFocus, window_id),
-          browser()),
+          base::StringPrintf(kArgsMinimizedWithFocus, window_id), browser()),
       keys::kInvalidWindowStateError));
 
   static const char kArgsMaximizedWithoutFocus[] =
       "[%u, {\"state\": \"maximized\", \"focused\": false}]";
   function = new WindowsUpdateFunction();
   function->set_extension(extension.get());
-  EXPECT_TRUE(MatchPattern(
+  EXPECT_TRUE(base::MatchPattern(
       utils::RunFunctionAndReturnError(
           function.get(),
-          base::StringPrintf(kArgsMaximizedWithoutFocus, window_id),
-          browser()),
+          base::StringPrintf(kArgsMaximizedWithoutFocus, window_id), browser()),
       keys::kInvalidWindowStateError));
 
   static const char kArgsMinimizedWithBounds[] =
       "[%u, {\"state\": \"minimized\", \"width\": 500}]";
   function = new WindowsUpdateFunction();
   function->set_extension(extension.get());
-  EXPECT_TRUE(MatchPattern(
+  EXPECT_TRUE(base::MatchPattern(
       utils::RunFunctionAndReturnError(
           function.get(),
-          base::StringPrintf(kArgsMinimizedWithBounds, window_id),
-          browser()),
+          base::StringPrintf(kArgsMinimizedWithBounds, window_id), browser()),
       keys::kInvalidWindowStateError));
 
   static const char kArgsMaximizedWithBounds[] =
       "[%u, {\"state\": \"maximized\", \"width\": 500}]";
   function = new WindowsUpdateFunction();
   function->set_extension(extension.get());
-  EXPECT_TRUE(MatchPattern(
+  EXPECT_TRUE(base::MatchPattern(
       utils::RunFunctionAndReturnError(
           function.get(),
-          base::StringPrintf(kArgsMaximizedWithBounds, window_id),
-          browser()),
+          base::StringPrintf(kArgsMaximizedWithBounds, window_id), browser()),
       keys::kInvalidWindowStateError));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionWindowCreateTest, AcceptState) {
   scoped_refptr<WindowsCreateFunction> function(new WindowsCreateFunction());
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
 
   scoped_ptr<base::DictionaryValue> result(
       utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
@@ skipping 19 matching lines @@
       utils::INCLUDE_INCOGNITO)));
   window_id = api_test_utils::GetInteger(result.get(), "id");
   new_window = ExtensionTabUtil::GetBrowserFromWindowID(function.get(),
                                                         window_id, &error);
   EXPECT_TRUE(error.empty());
   EXPECT_TRUE(new_window->window()->IsFullscreen());
 #endif  // !defined(OS_MACOSX)
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionWindowCreateTest, ValidateCreateWindowState) {
+  EXPECT_TRUE(base::MatchPattern(
+      RunCreateWindowExpectError(
+          "[{\"state\": \"fullscreen\", \"type\": \"panel\"}]"),
+      keys::kInvalidWindowStateError));
+  EXPECT_TRUE(base::MatchPattern(
+      RunCreateWindowExpectError(
+          "[{\"state\": \"maximized\", \"type\": \"panel\"}]"),
+      keys::kInvalidWindowStateError));
+  EXPECT_TRUE(base::MatchPattern(
+      RunCreateWindowExpectError(
+          "[{\"state\": \"minimized\", \"type\": \"panel\"}]"),
+      keys::kInvalidWindowStateError));
   EXPECT_TRUE(
-      MatchPattern(RunCreateWindowExpectError(
-                       "[{\"state\": \"fullscreen\", \"type\": \"panel\"}]"),
-                   keys::kInvalidWindowStateError));
+      base::MatchPattern(RunCreateWindowExpectError(
+                             "[{\"state\": \"minimized\", \"focused\": true}]"),
+                         keys::kInvalidWindowStateError));
+  EXPECT_TRUE(base::MatchPattern(
+      RunCreateWindowExpectError(
+          "[{\"state\": \"maximized\", \"focused\": false}]"),
+      keys::kInvalidWindowStateError));
+  EXPECT_TRUE(base::MatchPattern(
+      RunCreateWindowExpectError(
+          "[{\"state\": \"fullscreen\", \"focused\": false}]"),
+      keys::kInvalidWindowStateError));
   EXPECT_TRUE(
-      MatchPattern(RunCreateWindowExpectError(
-                       "[{\"state\": \"maximized\", \"type\": \"panel\"}]"),
-                   keys::kInvalidWindowStateError));
+      base::MatchPattern(RunCreateWindowExpectError(
+                             "[{\"state\": \"minimized\", \"width\": 500}]"),
+                         keys::kInvalidWindowStateError));
   EXPECT_TRUE(
-      MatchPattern(RunCreateWindowExpectError(
-                       "[{\"state\": \"minimized\", \"type\": \"panel\"}]"),
-                   keys::kInvalidWindowStateError));
+      base::MatchPattern(RunCreateWindowExpectError(
+                             "[{\"state\": \"maximized\", \"width\": 500}]"),
+                         keys::kInvalidWindowStateError));
   EXPECT_TRUE(
-      MatchPattern(RunCreateWindowExpectError(
-                       "[{\"state\": \"minimized\", \"focused\": true}]"),
-                   keys::kInvalidWindowStateError));
-  EXPECT_TRUE(
-      MatchPattern(RunCreateWindowExpectError(
-                       "[{\"state\": \"maximized\", \"focused\": false}]"),
-                   keys::kInvalidWindowStateError));
-  EXPECT_TRUE(
-      MatchPattern(RunCreateWindowExpectError(
-                       "[{\"state\": \"fullscreen\", \"focused\": false}]"),
-                   keys::kInvalidWindowStateError));
-  EXPECT_TRUE(MatchPattern(RunCreateWindowExpectError(
-                               "[{\"state\": \"minimized\", \"width\": 500}]"),
-                           keys::kInvalidWindowStateError));
-  EXPECT_TRUE(MatchPattern(RunCreateWindowExpectError(
-                               "[{\"state\": \"maximized\", \"width\": 500}]"),
-                           keys::kInvalidWindowStateError));
-  EXPECT_TRUE(MatchPattern(RunCreateWindowExpectError(
-                               "[{\"state\": \"fullscreen\", \"width\": 500}]"),
-                           keys::kInvalidWindowStateError));
+      base::MatchPattern(RunCreateWindowExpectError(
+                             "[{\"state\": \"fullscreen\", \"width\": 500}]"),
+                         keys::kInvalidWindowStateError));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DuplicateTab) {
   content::OpenURLParams params(GURL(url::kAboutBlankURL),
                                 content::Referrer(),
                                 NEW_FOREGROUND_TAB,
                                 ui::PAGE_TRANSITION_LINK,
                                 false);
   content::WebContents* web_contents = browser()->OpenURL(params);
   int tab_id = ExtensionTabUtil::GetTabId(web_contents);
@@ skipping 418 matching lines @@
   EXPECT_TRUE(RunSetZoomSettings(tab_id_A1, "manual", NULL));
   EXPECT_TRUE(RunSetZoom(tab_id_A1, 1.3f));
   EXPECT_FLOAT_EQ(
       1.3f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
   EXPECT_FLOAT_EQ(
       1.1f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
 
   // Test 'disabled' mode, which will reset A1's zoom to 1.f.
   EXPECT_TRUE(RunSetZoomSettings(tab_id_A1, "disabled", NULL));
   std::string error = RunSetZoomExpectError(tab_id_A1, 1.4f);
-  EXPECT_TRUE(MatchPattern(error, keys::kCannotZoomDisabledTabError));
+  EXPECT_TRUE(base::MatchPattern(error, keys::kCannotZoomDisabledTabError));
   EXPECT_FLOAT_EQ(
       1.f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A1)));
   // We should still be able to zoom A2 though.
   EXPECT_TRUE(RunSetZoom(tab_id_A2, 1.4f));
   EXPECT_FLOAT_EQ(
       1.4f, content::ZoomLevelToZoomFactor(GetZoomLevel(web_contents_A2)));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, PerTabResetsOnNavigation) {
   net::SpawnedTestServer http_server(
@@ skipping 36 matching lines @@
   EXPECT_EQ("per-origin", scope);
 
   EXPECT_TRUE(RunSetZoomSettings(tab_id, "automatic", "per-tab"));
   EXPECT_TRUE(RunGetZoomSettings(tab_id, &mode, &scope));
 
   EXPECT_EQ("automatic", mode);
   EXPECT_EQ("per-tab", scope);
 
   std::string error =
       RunSetZoomSettingsExpectError(tab_id, "manual", "per-origin");
-  EXPECT_TRUE(MatchPattern(error,
-                           keys::kPerOriginOnlyInAutomaticError));
+  EXPECT_TRUE(base::MatchPattern(error, keys::kPerOriginOnlyInAutomaticError));
   error =
       RunSetZoomSettingsExpectError(tab_id, "disabled", "per-origin");
-  EXPECT_TRUE(MatchPattern(error,
-                           keys::kPerOriginOnlyInAutomaticError));
+  EXPECT_TRUE(base::MatchPattern(error, keys::kPerOriginOnlyInAutomaticError));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, CannotZoomInvalidTab) {
   content::OpenURLParams params(GetOpenParams(url::kAboutBlankURL));
   content::WebContents* web_contents = OpenUrlAndWaitForLoad(params.url);
   int tab_id = ExtensionTabUtil::GetTabId(web_contents);
 
   int bogus_id = tab_id + 100;
   std::string error = RunSetZoomExpectError(bogus_id, 3.14159);
-  EXPECT_TRUE(MatchPattern(error, keys::kTabNotFoundError));
+  EXPECT_TRUE(base::MatchPattern(error, keys::kTabNotFoundError));
 
   error = RunSetZoomSettingsExpectError(bogus_id, "manual", "per-tab");
-  EXPECT_TRUE(MatchPattern(error, keys::kTabNotFoundError));
+  EXPECT_TRUE(base::MatchPattern(error, keys::kTabNotFoundError));
 
   const char kNewTestTabArgs[] = "chrome://version";
   params = GetOpenParams(kNewTestTabArgs);
   web_contents = browser()->OpenURL(params);
   tab_id = ExtensionTabUtil::GetTabId(web_contents);
 
   // Test chrome.tabs.setZoom().
   error = RunSetZoomExpectError(tab_id, 3.14159);
-  EXPECT_TRUE(MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
+  EXPECT_TRUE(
+      base::MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 
   // chrome.tabs.setZoomSettings().
   error = RunSetZoomSettingsExpectError(tab_id, "manual", "per-tab");
-  EXPECT_TRUE(MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
+  EXPECT_TRUE(
+      base::MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 }
 
 }  // namespace extensions