Adding ChromeLauncherController interface.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl_browsertest.cc

 // Copyright 2013 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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl.h"
 
 #include <stddef.h>
 
 #include "ash/ash_switches.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_util.h"
@@ skipping 60 matching lines @@
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/test/event_generator.h"
 
 using extensions::AppWindow;
 using extensions::Extension;
 using content::WebContents;
 
 namespace {
 
+ChromeLauncherControllerImpl* GetChromeLauncherControllerImpl() {
+  return static_cast<ChromeLauncherControllerImpl*>(
+      ChromeLauncherController::instance());
+}
+
 class TestEvent : public ui::Event {
  public:
   explicit TestEvent(ui::EventType type)
       : ui::Event(type, base::TimeTicks(), 0) {}
   ~TestEvent() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestEvent);
 };
 
@@ skipping 85 matching lines @@
 class LauncherPlatformAppBrowserTest
     : public extensions::PlatformAppBrowserTest {
  protected:
   LauncherPlatformAppBrowserTest() : shelf_(NULL), controller_(NULL) {
   }
 
   ~LauncherPlatformAppBrowserTest() override {}
 
   void RunTestOnMainThreadLoop() override {
     shelf_ = ash::Shelf::ForPrimaryDisplay();
-    controller_ = ChromeLauncherController::instance();
+    controller_ = GetChromeLauncherControllerImpl();
     return extensions::PlatformAppBrowserTest::RunTestOnMainThreadLoop();
   }
 
   ash::ShelfModel* shelf_model() {
     return ash::test::ShellTestApi(ash::Shell::GetInstance()).shelf_model();
   }
 
   ash::ShelfID CreateAppShortcutLauncherItem(const std::string& name) {
     return controller_->CreateAppShortcutLauncherItem(
         name, shelf_model()->item_count());
@@ skipping 28 matching lines @@
     }
     return num_items;
   }
 
   // Activate the shelf item with the given |id|.
   void ActivateShelfItem(int id) {
     shelf_->ActivateShelfItem(id);
   }
 
   ash::Shelf* shelf_;
-  ChromeLauncherController* controller_;
+  ChromeLauncherControllerImpl* controller_;
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(LauncherPlatformAppBrowserTest);
 };
 
 enum RipOffCommand {
   // Drag the item off the shelf and let the mouse go.
   RIP_OFF_ITEM,
   // Drag the item off the shelf, move the mouse back and then let go.
   RIP_OFF_ITEM_AND_RETURN,
   // Drag the item off the shelf and then issue a cancel command.
   RIP_OFF_ITEM_AND_CANCEL,
   // Drag the item off the shelf and do not release the mouse.
   RIP_OFF_ITEM_AND_DONT_RELEASE_MOUSE,
 };
 
 class ShelfAppBrowserTest : public ExtensionBrowserTest {
  protected:
   ShelfAppBrowserTest() : shelf_(NULL), model_(NULL), controller_(NULL) {
   }
 
   ~ShelfAppBrowserTest() override {}
 
   void RunTestOnMainThreadLoop() override {
     shelf_ = ash::Shelf::ForPrimaryDisplay();
     model_ = ash::test::ShellTestApi(ash::Shell::GetInstance()).shelf_model();
-    controller_ = ChromeLauncherController::instance();
+    controller_ = GetChromeLauncherControllerImpl();
     return ExtensionBrowserTest::RunTestOnMainThreadLoop();
   }
 
   size_t NumberOfDetectedLauncherBrowsers(bool show_all_tabs) {
     LauncherItemController* item_controller =
       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;
@@ skipping 103 matching lines @@
     DCHECK(root_window);
     return root_window;
   }
 
   bool IsItemPresentInMenu(LauncherContextMenu* menu, int command_id) {
     return menu->GetIndexOfCommandId(command_id) != -1;
   }
 
   ash::Shelf* shelf_;
   ash::ShelfModel* model_;
-  ChromeLauncherController* controller_;
+  ChromeLauncherControllerImpl* controller_;
 
  private:
-
   DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserTest);
 };
 
 class ShelfAppBrowserTestNoDefaultBrowser : public ShelfAppBrowserTest {
  protected:
   ShelfAppBrowserTestNoDefaultBrowser() {}
   ~ShelfAppBrowserTestNoDefaultBrowser() override {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     ShelfAppBrowserTest::SetUpCommandLine(command_line);
@@ skipping 487 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(ShelfAppBrowserTest, LaunchInBackground) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB,
                          NEW_BACKGROUND_TAB);
   EXPECT_EQ(++tab_count, tab_strip->count());
-  ChromeLauncherController::instance()->LaunchApp(last_loaded_extension_id(),
-                                                  ash::LAUNCH_FROM_UNKNOWN,
-                                                  0);
+  controller_->LaunchApp(last_loaded_extension_id(),
+                                               ash::LAUNCH_FROM_UNKNOWN,
+                                               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(ShelfAppBrowserTest, LaunchMaximized) {
   aura::Window* window1 = browser()->window()->GetNativeWindow();
   ash::wm::WindowState* window1_state = ash::wm::GetWindowState(window1);
   window1_state->Maximize();
   content::WindowedNotificationObserver open_observer(
       chrome::NOTIFICATION_BROWSER_WINDOW_READY,
@@ skipping 19 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(ShelfAppBrowserTest, 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(),
-                                                    ash::LAUNCH_FROM_UNKNOWN,
-                                                    0);
+  controller_->ActivateApp(extension->id(),
+                                                 ash::LAUNCH_FROM_UNKNOWN,
+                                                 0);
   EXPECT_EQ(++tab_count, tab_strip->count());
-  ChromeLauncherController::instance()->ActivateApp(extension->id(),
-                                                    ash::LAUNCH_FROM_UNKNOWN,
-                                                    0);
+  controller_->ActivateApp(extension->id(),
+                                                 ash::LAUNCH_FROM_UNKNOWN,
+                                                 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(ShelfAppBrowserTest, 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(),
-                                                  ash::LAUNCH_FROM_UNKNOWN,
-                                                  0);
+  controller_->LaunchApp(extension->id(),
+                                               ash::LAUNCH_FROM_UNKNOWN,
+                                               0);
   EXPECT_EQ(++tab_count, tab_strip->count());
-  ChromeLauncherController::instance()->LaunchApp(extension->id(),
-                                                  ash::LAUNCH_FROM_UNKNOWN,
-                                                  0);
+  controller_->LaunchApp(extension->id(),
+                                               ash::LAUNCH_FROM_UNKNOWN,
+                                               0);
   EXPECT_EQ(++tab_count, tab_strip->count());
 }
 
 // Launch 2 apps and toggle which is active.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, MultipleApps) {
   int item_count = model_->item_count();
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::ShelfID shortcut1 = CreateShortcut("app1");
   EXPECT_EQ(++item_count, model_->item_count());
@@ skipping 1312 matching lines @@
   // Close all windows.
   CloseBrowserWindow(browser(), menu1.get(), LauncherContextMenu::MENU_CLOSE);
   EXPECT_EQ(0u, BrowserList::GetInstance()->size());
 
   // Check if "Close" is removed from the context menu.
   std::unique_ptr<LauncherContextMenu> menu2 =
       CreateLauncherContextMenu(ash::TYPE_BROWSER_SHORTCUT);
   ASSERT_FALSE(
       IsItemPresentInMenu(menu2.get(), LauncherContextMenu::MENU_CLOSE));
 }