Refactor LauncherDelegate

chrome/browser/ui/ash/launcher/chrome_launcher_controller_per_app_browsertest.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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include "apps/native_app_window.h"
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "ash/ash_switches.h"
@@ skipping 100 matching lines @@
  protected:
   LauncherPlatformPerAppAppBrowserTest()
       : launcher_(NULL),
         controller_(NULL) {
   }
 
   virtual ~LauncherPlatformPerAppAppBrowserTest() {}
 
   virtual void RunTestOnMainThreadLoop() OVERRIDE {
     launcher_ = ash::Launcher::ForPrimaryDisplay();
-    controller_ =
-        static_cast<ChromeLauncherControllerPerApp*>(launcher_->delegate());
+    controller_ = static_cast<ChromeLauncherControllerPerApp*>
+        (ChromeLauncherController::instance());
+    DCHECK(controller_);
     return extensions::PlatformAppBrowserTest::RunTestOnMainThreadLoop();
   }
 
   ash::LauncherModel* launcher_model() {
     return ash::test::ShellTestApi(ash::Shell::GetInstance()).launcher_model();
   }
 
   ash::LauncherID CreateAppShortcutLauncherItem(const std::string& name) {
     return controller_->CreateAppShortcutLauncherItem(
         name, controller_->model()->item_count());
@@ skipping 49 matching lines @@
       : launcher_(NULL),
         model_(NULL) {
   }
 
   virtual ~LauncherPerAppAppBrowserTest() {}
 
   virtual void RunTestOnMainThreadLoop() OVERRIDE {
     launcher_ = ash::Launcher::ForPrimaryDisplay();
     model_ =
         ash::test::ShellTestApi(ash::Shell::GetInstance()).launcher_model();
+    controller_ = static_cast<ChromeLauncherControllerPerApp*>
+        (ChromeLauncherController::instance());
+    DCHECK(controller_);
+
     return ExtensionBrowserTest::RunTestOnMainThreadLoop();
   }
 
   size_t NumberOfDetectedLauncherBrowsers(bool show_all_tabs) {
-    ChromeLauncherControllerPerApp* controller =
-        static_cast<ChromeLauncherControllerPerApp*>(launcher_->delegate());
     LauncherItemController* item_controller =
-      controller->GetBrowserShortcutLauncherItemController();
+      controller_->GetBrowserShortcutLauncherItemController();
     int items = item_controller->GetApplicationList(
         show_all_tabs ? ui::EF_SHIFT_DOWN : 0).size();
     // If we have at least one item, we have also a title which we remove here.
     return items ? (items - 1) : 0;
   }
 
   const Extension* LoadAndLaunchExtension(
       const char* name,
       extension_misc::LaunchContainer container,
       WindowOpenDisposition disposition) {
@@ skipping 16 matching lines @@
     ExtensionService* service = extensions::ExtensionSystem::Get(
         profile())->extension_service();
     LoadExtension(test_data_dir_.AppendASCII(name));
 
     // First get app_id.
     const Extension* extension =
         service->GetExtensionById(last_loaded_extension_id_, false);
     const std::string app_id = extension->id();
 
     // Then create a shortcut.
-    ChromeLauncherController* controller =
-        static_cast<ChromeLauncherController*>(launcher_->delegate());
     int item_count = model_->item_count();
-    ash::LauncherID shortcut_id = controller->CreateAppShortcutLauncherItem(
+    ash::LauncherID shortcut_id = controller_->CreateAppShortcutLauncherItem(
         app_id,
         item_count);
-    controller->PersistPinnedState();
+    controller_->PersistPinnedState();
     EXPECT_EQ(++item_count, model_->item_count());
     const ash::LauncherItem& item = *model_->ItemByID(shortcut_id);
     EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
     return item.id;
   }
 
   // Activate the launcher item with the given |id|.
   void ActivateLauncherItem(int id) {
     launcher_->ActivateLauncherItem(id);
   }
 
   ash::Launcher* launcher_;
   ash::LauncherModel* model_;
+  ChromeLauncherControllerPerApp* controller_;
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(LauncherPerAppAppBrowserTest);
 };
 
 // TODO(skuhne): Change name to LauncherAppBrowserTestNoBrowser when the
 // old launcher gets ripped out.
 class LauncherPerAppAppBrowserTestNoDefaultBrowser
     : public LauncherPerAppAppBrowserTest {
@@ skipping 566 matching lines @@
 }
 
 // Launches an app in the background and then tries to open it. This is test for
 // a crash we had.
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, LaunchInBackground) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   LoadAndLaunchExtension("app1", extension_misc::LAUNCH_TAB,
                          NEW_BACKGROUND_TAB);
   EXPECT_EQ(++tab_count, tab_strip->count());
-  ChromeLauncherController::instance()->LaunchApp(last_loaded_extension_id_, 0);
+  controller_->LaunchApp(last_loaded_extension_id_, 0);
 }
 
 // Confirm that clicking a icon for an app running in one of 2 maxmized windows
 // activates the right window.
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, LaunchMaximized) {
   aura::Window* window1 = browser()->window()->GetNativeWindow();
   ash::wm::MaximizeWindow(window1);
   content::WindowedNotificationObserver open_observer(
       chrome::NOTIFICATION_BROWSER_WINDOW_READY,
       content::NotificationService::AllSources());
@@ skipping 18 matching lines @@
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 }
 
 // Activating the same app multiple times should launch only a single copy.
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, ActivateApp) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("app1"));
 
-  ChromeLauncherController::instance()->ActivateApp(extension->id(), 0);
+  controller_->ActivateApp(extension->id(), 0);
   EXPECT_EQ(++tab_count, tab_strip->count());
-  ChromeLauncherController::instance()->ActivateApp(extension->id(), 0);
+  controller_->ActivateApp(extension->id(), 0);
   EXPECT_EQ(tab_count, tab_strip->count());
 }
 
 // Launching the same app multiple times should launch a copy for each call.
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, LaunchApp) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("app1"));
 
-  ChromeLauncherController::instance()->LaunchApp(extension->id(), 0);
+  controller_->LaunchApp(extension->id(), 0);
   EXPECT_EQ(++tab_count, tab_strip->count());
-  ChromeLauncherController::instance()->LaunchApp(extension->id(), 0);
+  controller_->LaunchApp(extension->id(), 0);
   EXPECT_EQ(++tab_count, tab_strip->count());
 }
 
 // Launch 2 apps and toggle which is active.
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, MultipleApps) {
   int item_count = model_->item_count();
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut1 = CreateShortcut("app1");
   EXPECT_EQ(++item_count, model_->item_count());
@@ skipping 94 matching lines @@
   // No longer active.
   EXPECT_EQ(ash::STATUS_RUNNING, model_->ItemByID(shortcut_id)->status);
 
   // Activating app makes first tab active again.
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(tab_strip->GetActiveWebContents(), first_tab);
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, RefocusFilter) {
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   WebContents* first_tab = tab_strip->GetActiveWebContents();
 
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
   // Create new tab owned by app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path2/bar.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   EXPECT_EQ(++tab_count, tab_strip->count());
   // Confirm app is still active.
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
 
   // Create new tab not owned by app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path3/foo.html"),
       NEW_FOREGROUND_TAB,
       0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   // No longer active.
   EXPECT_EQ(ash::STATUS_RUNNING, model_->ItemByID(shortcut_id)->status);
 
   // Activating app makes first tab active again, because second tab isn't
   // in its refocus url path.
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(tab_strip->GetActiveWebContents(), first_tab);
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, RefocusFilterLaunch) {
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
 
   // Create new tab.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example2.com/path2/bar.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   EXPECT_EQ(++tab_count, tab_strip->count());
   WebContents* first_tab = tab_strip->GetActiveWebContents();
   // Confirm app is not active.
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
 
   // Activating app should launch new tab, because second tab isn't
   // in its refocus url path.
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   WebContents* second_tab = tab_strip->GetActiveWebContents();
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   EXPECT_NE(first_tab, second_tab);
   EXPECT_EQ(tab_strip->GetActiveWebContents(), second_tab);
 }
 
 // Check the launcher activation state for applications and browser.
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, ActivationStateCheck) {
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
   TabStripModel* tab_strip = browser()->tab_strip_model();
   // Get the browser item index
-  int browser_index = ash::launcher::GetBrowserItemIndex(*controller->model());
+  int browser_index = ash::launcher::GetBrowserItemIndex(*controller_->model());
   EXPECT_TRUE(browser_index >= 0);
 
   // Even though we are just comming up, the browser should be active.
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
 
   ash::LauncherID shortcut_id = CreateShortcut("app1");
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
 
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
 
   // Create new tab which would be the running app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path1/bar.html"),
       NEW_FOREGROUND_TAB,
@@ skipping 14 matching lines @@
   ash::wm::DeactivateWindow(browser()->window()->GetNativeWindow());
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[browser_index].status);
 }
 
 // Check that the launcher activation state for a V1 application stays closed
 // even after an asynchronous browser event comes in after the tab got
 // destroyed.
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest,
                        AsyncActivationStateCheck) {
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
   TabStripModel* tab_strip = browser()->tab_strip_model();
 
   ash::LauncherID shortcut_id = CreateShortcut("app1");
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
 
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
 
   // Create new tab which would be the running app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path1/bar.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
@@ skipping 52 matching lines @@
                          NEW_FOREGROUND_TAB);
 
   EXPECT_EQ(browsers, NumberOfDetectedLauncherBrowsers(false));
   EXPECT_EQ(++tabs, NumberOfDetectedLauncherBrowsers(true));
 }
 
 // Check that the keyboard activation of a launcher item tabs properly through
 // the items at hand.
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, AltNumberTabsTabbing) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
 
   ash::LauncherID shortcut_id = CreateShortcut("app");
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path/*"));
   std::string url = "http://www.example.com/path/bla";
 
   int shortcut_index = model_->ItemIndexByID(shortcut_id);
 
   // Create an application handled browser tab.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL(url),
       NEW_FOREGROUND_TAB,
@@ skipping 124 matching lines @@
   EXPECT_EQ(window1, ash::wm::GetActiveWindow());
 }
 
 // Checks that after a session restore, we do not start applications on an
 // activation.
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest,
     ActivateAfterSessionRestore) {
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 
   // Create a known application.
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
   ash::LauncherID shortcut_id = CreateShortcut("app1");
 
   // Create a new browser - without activating it - and load an "app" into it.
   Browser::CreateParams params =
       Browser::CreateParams(profile(), chrome::GetActiveDesktop());
   params.initial_show_state = ui::SHOW_STATE_INACTIVE;
   Browser* browser2 = new Browser(params);
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path/*"));
   std::string url = "http://www.example.com/path/bla";
   ui_test_utils::NavigateToURLWithDisposition(
       browser2,
       GURL(url),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Remember the number of tabs for each browser.
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count1 = tab_strip->count();
   TabStripModel* tab_strip2 = browser2->tab_strip_model();
   int tab_count2 = tab_strip2->count();
 
   // Check that we have two browsers and the inactive browser remained inactive.
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow()),
             browser());
   // Check that the LRU browser list does only contain the original browser.
   BrowserList* ash_browser_list =
       BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH);
   BrowserList::const_reverse_iterator it =
       ash_browser_list->begin_last_active();
   EXPECT_EQ(*it, browser());
   ++it;
   EXPECT_EQ(it, ash_browser_list->end_last_active());
 
   // Now request to either activate an existing app or create a new one.
-  controller->ItemSelected(*model_->ItemByID(shortcut_id),
+  controller_->ItemSelected(*model_->ItemByID(shortcut_id),
                            ui::KeyEvent(ui::ET_KEY_RELEASED,
                                         ui::VKEY_RETURN,
                                         0,
                                         false));
 
   // Check that we have set focus on the existing application and nothing new
   // was created.
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(tab_count1, tab_strip->count());
   EXPECT_EQ(tab_count2, tab_strip2->count());
@@ skipping 136 matching lines @@
   // Test now that a click does create a new application tab.
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
                         bounds_grid_1.CenterPoint().y());
   generator.ClickLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(tab_count + 1, tab_strip->count());
 }
 
-// Check LauncherItemController of Browser Shortcut functionality.
+// Check LauncherItemController of Browser Shortcut functionality and its
+// status.
 IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTestNoDefaultBrowser,
-    BrowserShortcutLauncherItemController) {
-  ChromeLauncherControllerPerApp* controller =
-      static_cast<ChromeLauncherControllerPerApp*>(launcher_->delegate());
+    BrowserShortcutLauncherItemTest) {
   LauncherItemController* item_controller =
-      controller->GetBrowserShortcutLauncherItemController();
+      controller_->GetBrowserShortcutLauncherItemController();
 
   // Get the number of browsers.
   size_t running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(0u, running_browser);
   EXPECT_FALSE(item_controller->IsOpen());
 
   // Activate. This creates new browser
   item_controller->Activate();
   // New Window is created.
   running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(1u, running_browser);
   EXPECT_TRUE(item_controller->IsOpen());
 
   // Minimize Window.
   aura::Window* window = ash::wm::GetActiveWindow();
   ash::wm::MinimizeWindow(window);
   EXPECT_TRUE(ash::wm::IsWindowMinimized(window));
 
   // Activate again. This doesn't create new browser.
   // It activates window.
   item_controller->Activate();
   running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(1u, running_browser);
   EXPECT_TRUE(item_controller->IsOpen());
   EXPECT_FALSE(ash::wm::IsWindowMinimized(window));
 }