mash: Merge ChromeLauncherController and *Impl subclass.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_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_impl.h"
+#include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <stddef.h>
 
 #include "ash/public/cpp/app_launch_id.h"
 #include "ash/public/cpp/shelf_item_delegate.h"
 #include "ash/public/cpp/window_properties.h"
 #include "ash/shelf/app_list_button.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_model.h"
@@ skipping 14 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/app_list/app_list_controller_delegate.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/ash/app_list/test/app_list_service_ash_test_api.h"
 #include "chrome/browser/ui/ash/launcher/browser_shortcut_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller_util.h"
 #include "chrome/browser/ui/ash/launcher/launcher_context_menu.h"
 #include "chrome/browser/ui/ash/session_controller_client.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
@@ skipping 33 matching lines @@
 #include "ui/events/event_constants.h"
 #include "ui/events/test/event_generator.h"
 
 using ash::WmShelf;
 using extensions::AppWindow;
 using extensions::Extension;
 using content::WebContents;
 
 namespace {
 
-ChromeLauncherControllerImpl* GetChromeLauncherControllerImpl() {
-  return static_cast<ChromeLauncherControllerImpl*>(
-      ChromeLauncherController::instance());
-}
-
 // A callback that records the action taken when a shelf item is selected.
 void SelectItemCallback(ash::ShelfAction* action_taken,
                         base::RunLoop* run_loop,
                         ash::ShelfAction action,
                         base::Optional<ash::MenuItemList>) {
   *action_taken = action;
   run_loop->Quit();
 }
 
 // Calls ShelfItemDelegate::SelectItem with an event type and default arguments.
@@ skipping 113 matching lines @@
     : public extensions::PlatformAppBrowserTest {
  protected:
   LauncherPlatformAppBrowserTest() : controller_(nullptr) {}
 
   ~LauncherPlatformAppBrowserTest() override {}
 
   void SetUpOnMainThread() override {
     // Ensure ash starts the session and creates the shelf and controller.
     SessionControllerClient::FlushForTesting();
 
-    controller_ = GetChromeLauncherControllerImpl();
+    controller_ = ChromeLauncherController::instance();
     ASSERT_TRUE(controller_);
     extensions::PlatformAppBrowserTest::SetUpOnMainThread();
   }
 
   ash::ShelfModel* shelf_model() { return ash::Shell::Get()->shelf_model(); }
 
   ash::ShelfID CreateAppShortcutLauncherItem(
       const ash::AppLaunchId& app_launch_id) {
     return controller_->CreateAppShortcutLauncherItem(
         app_launch_id, shelf_model()->item_count());
   }
 
   const ash::ShelfItem& GetLastLauncherItem() {
     // Unless there are any panels, the item at index [count - 1] will be
     // the desired item.
     return shelf_model()->items()[shelf_model()->item_count() - 1];
   }
 
   const ash::ShelfItem& GetLastLauncherPanelItem() {
     // Panels show up on the right side of the shelf, so the desired item
     // will be the last one.
     return shelf_model()->items()[shelf_model()->item_count() - 1];
   }
 
   ash::ShelfItemDelegate* GetShelfItemDelegate(ash::ShelfID id) {
     return shelf_model()->GetShelfItemDelegate(id);
   }
 
-  ChromeLauncherControllerImpl* controller_;
+  ChromeLauncherController* 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() : shelf_(NULL), model_(NULL), controller_(NULL) {}
 
   ~ShelfAppBrowserTest() override {}
 
   void SetUpOnMainThread() override {
     // Ensure ash starts the session and creates the shelf and controller.
     SessionControllerClient::FlushForTesting();
 
     shelf_ =
         ash::WmShelf::ForWindow(ash::ShellPort::Get()->GetPrimaryRootWindow());
     model_ = ash::Shell::Get()->shelf_model();
-    controller_ = GetChromeLauncherControllerImpl();
+    controller_ = ChromeLauncherController::instance();
     ASSERT_TRUE(controller_);
     ExtensionBrowserTest::SetUpOnMainThread();
   }
 
   size_t NumberOfDetectedLauncherBrowsers(bool show_all_tabs) {
     ash::ShelfItemDelegate* item_controller =
         controller_->GetBrowserShortcutLauncherItemController();
     return item_controller
         ->GetAppMenuItems(show_all_tabs ? ui::EF_SHIFT_DOWN : 0)
         .size();
   }
 
-  const Extension* LoadAndLaunchExtension(
-      const char* name,
-      extensions::LaunchContainer container,
-      WindowOpenDisposition disposition) {
+  const Extension* LoadAndLaunchExtension(const char* name,
+                                          extensions::LaunchContainer container,
+                                          WindowOpenDisposition disposition) {
     EXPECT_TRUE(LoadExtension(test_data_dir_.AppendASCII(name)));
 
-    ExtensionService* service = extensions::ExtensionSystem::Get(
-        profile())->extension_service();
+    ExtensionService* service =
+        extensions::ExtensionSystem::Get(profile())->extension_service();
     const Extension* extension =
         service->GetExtensionById(last_loaded_extension_id(), false);
     EXPECT_TRUE(extension);
 
     OpenApplication(AppLaunchParams(profile(), extension, container,
                                     disposition, extensions::SOURCE_TEST));
     return extension;
   }
 
   ash::ShelfID CreateShortcut(const char* name) {
-    ExtensionService* service = extensions::ExtensionSystem::Get(
-        profile())->extension_service();
+    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.
     int item_count = model_->item_count();
     ash::ShelfID shortcut_id = controller_->CreateAppShortcutLauncherItem(
@@ skipping 62 matching lines @@
     DCHECK(root_window);
     return root_window;
   }
 
   bool IsItemPresentInMenu(LauncherContextMenu* menu, int command_id) {
     return menu->GetIndexOfCommandId(command_id) != -1;
   }
 
   ash::WmShelf* shelf_;
   ash::ShelfModel* model_;
-  ChromeLauncherControllerImpl* controller_;
+  ChromeLauncherController* controller_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserTest);
 };
 
 class ShelfAppBrowserTestNoDefaultBrowser : public ShelfAppBrowserTest {
  protected:
   ShelfAppBrowserTestNoDefaultBrowser() {}
   ~ShelfAppBrowserTestNoDefaultBrowser() override {}
 
@@ skipping 180 matching lines @@
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
   AppWindow* window1 = CreateAppWindow(browser()->profile(), extension1);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   ash::ShelfID item_id1 = item1.id;
   EXPECT_EQ(ash::TYPE_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   // Then run second app.
-  const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2",
-                                                         "Launched");
+  const Extension* extension2 =
+      LoadAndLaunchPlatformApp("launch_2", "Launched");
   AppWindow* window2 = CreateAppWindow(browser()->profile(), extension2);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item2 = GetLastLauncherItem();
   ash::ShelfID item_id2 = item2.id;
   EXPECT_EQ(ash::TYPE_APP, item2.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
 
   EXPECT_NE(item_id1, item_id2);
   EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
@@ skipping 20 matching lines @@
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
   AppWindow* window1 = CreateAppWindow(browser()->profile(), extension1);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   ash::ShelfID item_id1 = item1.id;
   EXPECT_EQ(ash::TYPE_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   // Then run second app.
-  const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2",
-                                                         "Launched");
+  const Extension* extension2 =
+      LoadAndLaunchPlatformApp("launch_2", "Launched");
   AppWindow* window2 = CreateAppWindow(browser()->profile(), extension2);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item2 = GetLastLauncherItem();
   ash::ShelfID item_id2 = item2.id;
   EXPECT_EQ(ash::TYPE_APP, item2.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
 
   EXPECT_NE(item_id1, item_id2);
   EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
@@ skipping 408 matching lines @@
 
 // Confirm that a page can be navigated from and to while maintaining the
 // correct running state.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, Navigation) {
   ash::ShelfID shortcut_id = CreateShortcut("app1");
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
   WmShelf::ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 
   // Navigate away.
-  ui_test_utils::NavigateToURL(
-      browser(), GURL("http://www.example.com/path0/bar.html"));
+  ui_test_utils::NavigateToURL(browser(),
+                               GURL("http://www.example.com/path0/bar.html"));
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
 
   // Navigate back.
-  ui_test_utils::NavigateToURL(
-      browser(), GURL("http://www.example.com/path1/foo.html"));
+  ui_test_utils::NavigateToURL(browser(),
+                               GURL("http://www.example.com/path1/foo.html"));
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 }
 
 // Confirm that a tab can be moved between browsers while maintaining the
 // correct running state.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, TabDragAndDrop) {
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   TabStripModel* tab_strip_model1 = browser()->tab_strip_model();
   EXPECT_EQ(1, tab_strip_model1->count());
   const int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
@@ skipping 14 matching lines @@
   Browser* browser2 = CreateBrowser(profile());
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   TabStripModel* tab_strip_model2 = browser2->tab_strip_model();
   EXPECT_EQ(1, tab_strip_model2->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut_id)).status);
 
   // Detach a tab at index 1 (app1) from |tab_strip_model1| and insert it as an
   // active tab at index 1 to |tab_strip_model2|.
   content::WebContents* detached_tab = tab_strip_model1->DetachWebContentsAt(1);
-  tab_strip_model2->InsertWebContentsAt(1,
-                                        detached_tab,
+  tab_strip_model2->InsertWebContentsAt(1, detached_tab,
                                         TabStripModel::ADD_ACTIVE);
   EXPECT_EQ(1, tab_strip_model1->count());
   EXPECT_EQ(2, tab_strip_model2->count());
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[browser_index].status);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 
   tab_strip_model1->CloseAllTabs();
   tab_strip_model2->CloseAllTabs();
 }
 
@@ skipping 195 matching lines @@
       LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_WINDOW,
                              WindowOpenDisposition::NEW_WINDOW);
   app_browser = FindBrowserForApp(extension->id());
   ASSERT_TRUE(app_browser);
   window = app_browser->window()->GetNativeWindow();
   EXPECT_FALSE(ash::wm::GetWindowState(window)->IsMaximized());
 }
 
 // Checks that a windowed application does not add an item to the browser list.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
-    WindowedAppDoesNotAddToBrowser) {
+                       WindowedAppDoesNotAddToBrowser) {
   // Get the number of items in the browser menu.
   size_t items = NumberOfDetectedLauncherBrowsers(false);
   size_t running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(0u, items);
   EXPECT_EQ(0u, running_browser);
 
   LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_WINDOW,
                          WindowOpenDisposition::NEW_WINDOW);
 
   // No new browser should get detected, even though one more is running.
@@ skipping 76 matching lines @@
 
   EXPECT_EQ(content2, browser()->tab_strip_model()->GetActiveWebContents());
   WmShelf::ActivateShelfItem(shortcut_index);
   EXPECT_EQ(content1, browser()->tab_strip_model()->GetActiveWebContents());
   WmShelf::ActivateShelfItem(shortcut_index);
   EXPECT_EQ(content2, browser()->tab_strip_model()->GetActiveWebContents());
 }
 
 // Check that the keyboard activation of a launcher item tabs properly through
 // the items at hand.
-IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest,
-                       AltNumberAppsTabbing) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, AltNumberAppsTabbing) {
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
   ui::BaseWindow* window1 =
       CreateAppWindow(browser()->profile(), extension1)->GetBaseWindow();
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   ash::ShelfID app_id = item1.id;
   int app_index = shelf_model()->ItemIndexByID(app_id);
 
   EXPECT_EQ(ash::TYPE_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
-  const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2",
-                                                         "Launched");
+  const Extension* extension2 =
+      LoadAndLaunchPlatformApp("launch_2", "Launched");
   ui::BaseWindow* window2 =
       CreateAppWindow(browser()->profile(), extension2)->GetBaseWindow();
 
   // By now the browser should be active. Issue Alt keystrokes several times to
   // see that we stay on that application.
   EXPECT_TRUE(window2->IsActive());
   WmShelf::ActivateShelfItem(app_index);
   EXPECT_TRUE(window1->IsActive());
   WmShelf::ActivateShelfItem(app_index);
   EXPECT_TRUE(window1->IsActive());
@@ skipping 543 matching lines @@
   CreateShortcut("app1");
   test.RunMessageLoopUntilAnimationsDone();
   EXPECT_EQ(3, model_->item_count());
 
   // Test #1: Ripping out the browser item should not change anything.
   int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
   EXPECT_LE(0, browser_index);
   RipOffItemIndex(browser_index, &generator, &test, RIP_OFF_ITEM);
   // => It should not have been removed and the location should be unchanged.
   EXPECT_EQ(3, model_->item_count());
-  EXPECT_EQ(browser_index,
-            GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT));
+  EXPECT_EQ(browser_index, GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT));
   // Make sure that the hide state has been unset after the snap back animation
   // finished.
   ash::ShelfButton* button = test.GetButton(browser_index);
   EXPECT_FALSE(button->state() & ash::ShelfButton::STATE_HIDDEN);
 
   // Test #2: Ripping out the application and canceling the operation should
   // not change anything.
   int app_index = GetIndexOfShelfItemType(ash::TYPE_PINNED_APP);
   EXPECT_LE(0, app_index);
   RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM_AND_CANCEL);
@@ skipping 14 matching lines @@
   // => It should not have been removed and the location should be unchanged.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_EQ(-1, GetIndexOfShelfItemType(ash::TYPE_PINNED_APP));
 
   // Test #5: Uninstalling an application while it is being ripped off should
   // not crash.
   CreateShortcut("app2");
   test.RunMessageLoopUntilAnimationsDone();
   int app2_index = GetIndexOfShelfItemType(ash::TYPE_PINNED_APP);
   EXPECT_EQ(3, model_->item_count());  // And it remains that way.
-  RipOffItemIndex(app2_index,
-                  &generator,
-                  &test,
+  RipOffItemIndex(app2_index, &generator, &test,
                   RIP_OFF_ITEM_AND_DONT_RELEASE_MOUSE);
   controller_->UnpinAppWithID("app2");
   test.RunMessageLoopUntilAnimationsDone();
   EXPECT_EQ(2, model_->item_count());  // The item should now be gone.
   generator.ReleaseLeftButton();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2, model_->item_count());  // And it remains that way.
   EXPECT_EQ(-1, GetIndexOfShelfItemType(ash::TYPE_PINNED_APP));
 
   // Test #6: Ripping out the application when the overflow button exists.
@@ skipping 217 matching lines @@
       chrome::SettingsWindowManager::GetInstance();
   ash::ShelfModel* shelf_model = ash::Shell::Get()->shelf_model();
 
   // Get the number of items in the shelf and browser menu.
   int item_count = shelf_model->item_count();
   size_t browser_count = NumberOfDetectedLauncherBrowsers(false);
 
   // Open a settings window. Number of browser items should remain unchanged,
   // number of shelf items should increase.
   settings_manager->ShowChromePageForProfile(
-      browser()->profile(),
-      chrome::GetSettingsUrl(std::string()));
+      browser()->profile(), chrome::GetSettingsUrl(std::string()));
   Browser* settings_browser =
       settings_manager->FindBrowserForProfile(browser()->profile());
   ASSERT_TRUE(settings_browser);
   EXPECT_EQ(browser_count, NumberOfDetectedLauncherBrowsers(false));
   EXPECT_EQ(item_count + 1, shelf_model->item_count());
 
   // TODO(stevenjb): Test multiprofile on Chrome OS when test support is addded.
   // crbug.com/230464.
 }
 
@@ skipping 109 matching lines @@
 
   // Close all windows via the menu item.
   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 = CreateBrowserItemContextMenu();
   ASSERT_FALSE(
       IsItemPresentInMenu(menu2.get(), LauncherContextMenu::MENU_CLOSE));
 }