[Extensions Toolbar] Add a finch config for the redesign

chrome/browser/extensions/lazy_background_page_apitest.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 "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/scoped_observer.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/extensions/browser_action_test_util.h"
+#include "chrome/browser/extensions/extension_action_test_util.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/lazy_background_page_test_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/location_bar/location_bar.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
@@ skipping 12 matching lines @@
 #include "extensions/common/extension.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "extensions/test/result_catcher.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using bookmarks::BookmarkModel;
 using bookmarks::BookmarkNode;
-using extensions::Extension;
-using extensions::ResultCatcher;
+
+namespace extensions {
 
 namespace {
 
 // This unfortunate bit of silliness is necessary when loading an extension in
 // incognito. The goal is to load the extension, enable incognito, then wait
 // for both background pages to load and close. The problem is that enabling
 // incognito involves reloading the extension - and the background pages may
 // have already loaded once before then. So we wait until the extension is
 // unloaded before listening to the background page notifications.
-class LoadedIncognitoObserver : public extensions::ExtensionRegistryObserver {
+class LoadedIncognitoObserver : public ExtensionRegistryObserver {
  public:
   explicit LoadedIncognitoObserver(Profile* profile)
       : profile_(profile), extension_registry_observer_(this) {
-    extension_registry_observer_.Add(
-        extensions::ExtensionRegistry::Get(profile_));
+    extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
   }
 
   void Wait() {
     ASSERT_TRUE(original_complete_.get());
     original_complete_->Wait();
     incognito_complete_->Wait();
   }
 
  private:
-  void OnExtensionUnloaded(
-      content::BrowserContext* browser_context,
-      const Extension* extension,
-      extensions::UnloadedExtensionInfo::Reason reason) override {
+  void OnExtensionUnloaded(content::BrowserContext* browser_context,
+                           const Extension* extension,
+                           UnloadedExtensionInfo::Reason reason) override {
     original_complete_.reset(new LazyBackgroundObserver(profile_));
     incognito_complete_.reset(
         new LazyBackgroundObserver(profile_->GetOffTheRecordProfile()));
   }
 
   Profile* profile_;
-  ScopedObserver<extensions::ExtensionRegistry,
-                 extensions::ExtensionRegistryObserver>
+  ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
   scoped_ptr<LazyBackgroundObserver> original_complete_;
   scoped_ptr<LazyBackgroundObserver> incognito_complete_;
 };
 
 }  // namespace
 
 class LazyBackgroundPageApiTest : public ExtensionApiTest {
  public:
   LazyBackgroundPageApiTest() {}
   ~LazyBackgroundPageApiTest() override {}
 
   void SetUpInProcessBrowserTestFixture() override {
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
     // Set shorter delays to prevent test timeouts.
-    extensions::ProcessManager::SetEventPageIdleTimeForTesting(1);
-    extensions::ProcessManager::SetEventPageSuspendingTimeForTesting(1);
+    ProcessManager::SetEventPageIdleTimeForTesting(1);
+    ProcessManager::SetEventPageSuspendingTimeForTesting(1);
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     ExtensionApiTest::SetUpCommandLine(command_line);
     // Disable background network activity as it can suddenly bring the Lazy
     // Background Page alive.
     command_line->AppendSwitch(switches::kDisableBackgroundNetworking);
     command_line->AppendSwitch(switches::kNoProxyServer);
   }
 
   // Loads the extension, which temporarily starts the lazy background page
   // to dispatch the onInstalled event. We wait until it shuts down again.
   const Extension* LoadExtensionAndWait(const std::string& test_name) {
     LazyBackgroundObserver page_complete;
     base::FilePath extdir = test_data_dir_.AppendASCII("lazy_background_page").
         AppendASCII(test_name);
     const Extension* extension = LoadExtension(extdir);
     if (extension)
       page_complete.Wait();
     return extension;
   }
 
   // Returns true if the lazy background page for the extension with
   // |extension_id| is still running.
   bool IsBackgroundPageAlive(const std::string& extension_id) {
-    extensions::ProcessManager* pm =
-        extensions::ProcessManager::Get(browser()->profile());
+    ProcessManager* pm = ProcessManager::Get(browser()->profile());
     return pm->GetBackgroundHostForExtension(extension_id);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LazyBackgroundPageApiTest);
 };
 
 IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, BrowserActionCreateTab) {
   ASSERT_TRUE(LoadExtensionAndWait("browser_action_create_tab"));
 
@@ skipping 48 matching lines @@
   // Open a tab to a URL that will trigger the page action to show.
   LazyBackgroundObserver page_complete;
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL("/extensions/test_file.html"));
   page_complete.Wait();
 
   EXPECT_FALSE(IsBackgroundPageAlive(last_loaded_extension_id()));
 
   // Page action is shown.
   WaitForPageActionVisibilityChangeTo(num_page_actions + 1);
-  EXPECT_EQ(num_page_actions + 1,
-            browser()->window()->GetLocationBar()->
-                GetLocationBarForTesting()->PageActionVisibleCount());
+  EXPECT_EQ(static_cast<size_t>(num_page_actions + 1),
+            extension_action_test_util::GetVisiblePageActionCount(

[Devlin, 2015/09/21 23:28:15]

This handy method checks for page actions in the right place. I must have missed
this call when I made it and updated most of them.

+                browser()->tab_strip_model()->GetActiveWebContents()));
 }
 
 IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, Filters) {
   ASSERT_TRUE(StartEmbeddedTestServer());
 
   const Extension* extension = LoadExtensionAndWait("filters");
   ASSERT_TRUE(extension);
 
   // Lazy Background Page doesn't exist yet.
   EXPECT_FALSE(IsBackgroundPageAlive(last_loaded_extension_id()));
@@ skipping 25 matching lines @@
   ASSERT_TRUE(extension);
 
   // The test extension opens a dialog on installation.
   app_modal::AppModalDialog* dialog = ui_test_utils::WaitForAppModalDialog();
   ASSERT_TRUE(dialog);
 
   // With the dialog open the background page is still alive.
   EXPECT_TRUE(IsBackgroundPageAlive(extension->id()));
 
   // Close the dialog. The keep alive count is decremented.
-  extensions::ProcessManager* pm =
-      extensions::ProcessManager::Get(browser()->profile());
+  ProcessManager* pm = ProcessManager::Get(browser()->profile());
   int previous_keep_alive_count = pm->GetLazyKeepaliveCount(extension);
   dialog->CloseModalDialog();
   EXPECT_EQ(previous_keep_alive_count - 1,
             pm->GetLazyKeepaliveCount(extension));
 
   // The background page closes now that the dialog is gone.
   background_observer.WaitUntilClosed();
   EXPECT_FALSE(IsBackgroundPageAlive(extension->id()));
 }
 
@@ skipping 34 matching lines @@
 
   LazyBackgroundObserver page_complete;
   ResultCatcher catcher;
   base::FilePath extdir = test_data_dir_.AppendASCII("lazy_background_page").
       AppendASCII("wait_for_request");
   const Extension* extension = LoadExtension(extdir);
   ASSERT_TRUE(extension);
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 
   // Lazy Background Page still exists, because the extension started a request.
-  extensions::ProcessManager* pm =
-      extensions::ProcessManager::Get(browser()->profile());
-  extensions::ExtensionHost* host =
+  ProcessManager* pm = ProcessManager::Get(browser()->profile());
+  ExtensionHost* host =
       pm->GetBackgroundHostForExtension(last_loaded_extension_id());
   ASSERT_TRUE(host);
 
   // Abort the request.
   bool result = false;
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
       host->render_view_host(), "abortRequest()", &result));
   EXPECT_TRUE(result);
   page_complete.Wait();
 
@@ skipping 81 matching lines @@
   // Load the extension with incognito enabled.
   {
     LoadedIncognitoObserver loaded(browser()->profile());
     base::FilePath extdir = test_data_dir_.AppendASCII("lazy_background_page").
         AppendASCII("incognito_split");
     ASSERT_TRUE(LoadExtensionIncognito(extdir));
     loaded.Wait();
   }
 
   // Lazy Background Page doesn't exist yet.
-  extensions::ProcessManager* pm =
-      extensions::ProcessManager::Get(browser()->profile());
-  extensions::ProcessManager* pmi =
-      extensions::ProcessManager::Get(incognito_browser->profile());
+  ProcessManager* pm = ProcessManager::Get(browser()->profile());
+  ProcessManager* pmi = ProcessManager::Get(incognito_browser->profile());
   EXPECT_FALSE(pm->GetBackgroundHostForExtension(last_loaded_extension_id()));
   EXPECT_FALSE(pmi->GetBackgroundHostForExtension(last_loaded_extension_id()));
 
   // Trigger a browserAction event in the original profile and ensure only
   // the original event page received it (since the event is scoped to the
   // profile).
   {
     ExtensionTestMessageListener listener("waiting", false);
     ExtensionTestMessageListener listener_incognito("waiting_incognito", false);
 
@@ skipping 65 matching lines @@
 }
 
 // Tests that a KeepaliveImpulse increments the keep alive count, but eventually
 // times out and background page will still close.
 IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, ImpulseAddsCount) {
   ASSERT_TRUE(StartEmbeddedTestServer());
   const Extension* extension = LoadExtensionAndWait("messaging");
   ASSERT_TRUE(extension);
 
   // Lazy Background Page doesn't exist yet.
-  extensions::ProcessManager* pm =
-      extensions::ProcessManager::Get(browser()->profile());
+  ProcessManager* pm = ProcessManager::Get(browser()->profile());
   EXPECT_FALSE(pm->GetBackgroundHostForExtension(last_loaded_extension_id()));
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 
   // Navigate to a page that opens a message channel to the background page.
   ResultCatcher catcher;
   LazyBackgroundObserver lazybg;
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL("/extensions/test_file.html"));
   lazybg.WaitUntilLoaded();
 
@@ skipping 25 matching lines @@
   ASSERT_EQ(1, browser_action.NumberOfBrowserActions());
   EXPECT_EQ("Success", browser_action.GetTooltip(0));
 }
 
 // Tests that both a regular page and an event page will receive events when
 // the event page is not loaded.
 IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, EventDispatchToTab) {
   ResultCatcher catcher;
   catcher.RestrictToBrowserContext(browser()->profile());
 
-  const extensions::Extension* extension =
-      LoadExtensionAndWait("event_dispatch_to_tab");
+  const Extension* extension = LoadExtensionAndWait("event_dispatch_to_tab");
 
   ExtensionTestMessageListener page_ready("ready", true);
   GURL page_url = extension->GetResourceURL("page.html");
   ui_test_utils::NavigateToURL(browser(), page_url);
   EXPECT_TRUE(page_ready.WaitUntilSatisfied());
 
   // After the event is sent below, wait for the event page to have received
   // the event before proceeding with the test.  This allows the regular page
   // to test that the event page received the event, which makes the pass/fail
   // logic simpler.
@@ skipping 73 matching lines @@
 
 // Tests that the lazy background page will be unloaded if the onSuspend event
 // handler calls an API function such as chrome.storage.local.set().
 // See: http://crbug.com/296834
 IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, OnSuspendUseStorageApi) {
   EXPECT_TRUE(LoadExtensionAndWait("on_suspend"));
 }
 
 // TODO: background page with timer.
 // TODO: background page that interacts with popup.
+
+}  // namespace extensions