mash: Move LauncherItemController to ash, rename ShelfItemDelegate.

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_impl.h"
 
 #include <stddef.h>
 
 #include "ash/common/shelf/app_list_button.h"
 #include "ash/common/shelf/shelf_button.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/shelf_view.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.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/shell.h"
 #include "ash/test/shelf_view_test_api.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #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_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/launcher/launcher_item_controller.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"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/extensions/app_launch_params.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/settings_window_manager.h"
@@ skipping 37 matching lines @@
 
 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<MenuItemList>) {
+                        base::Optional<ash::MenuItemList>) {
   *action_taken = action;
   run_loop->Quit();
 }
 
 // Calls ShelfItemDelegate::SelectItem with an event type and default arguments.
-ash::ShelfAction SelectItem(ash::mojom::ShelfItemDelegate* delegate,
+ash::ShelfAction SelectItem(ash::ShelfItemDelegate* delegate,
                             ui::EventType event_type) {
   std::unique_ptr<ui::Event> event;
   if (event_type == ui::ET_MOUSE_PRESSED) {
     event =
         base::MakeUnique<ui::MouseEvent>(event_type, gfx::Point(), gfx::Point(),
                                          ui::EventTimeForNow(), ui::EF_NONE, 0);
   } else if (event_type == ui::ET_KEY_RELEASED) {
     event = base::MakeUnique<ui::KeyEvent>(event_type, ui::VKEY_UNKNOWN,
                                            ui::EF_NONE);
   }
@@ skipping 127 matching lines @@
     // 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];
   }
 
-  LauncherItemController* GetItemController(ash::ShelfID id) {
-    return controller_->GetLauncherItemController(id);
+  ash::ShelfItemDelegate* GetShelfItemDelegate(ash::ShelfID id) {
+    return controller_->GetShelfItemDelegate(id);
   }
 
   ChromeLauncherControllerImpl* controller_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LauncherPlatformAppBrowserTest);
 };
 
 enum RipOffCommand {
   // Drag the item off the shelf and let the mouse go.
@@ skipping 19 matching lines @@
 
     shelf_ =
         ash::WmShelf::ForWindow(ash::WmShell::Get()->GetPrimaryRootWindow());
     model_ = ash::Shell::Get()->shelf_model();
     controller_ = GetChromeLauncherControllerImpl();
     ASSERT_TRUE(controller_);
     return ExtensionBrowserTest::RunTestOnMainThreadLoop();
   }
 
   size_t NumberOfDetectedLauncherBrowsers(bool show_all_tabs) {
-    LauncherItemController* item_controller =
-      controller_->GetBrowserShortcutLauncherItemController();
+    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) {
     EXPECT_TRUE(LoadExtension(test_data_dir_.AppendASCII(name)));
@@ skipping 408 matching lines @@
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest,
                        PackagedAppClickBehaviorInMinimizeMode) {
   // Launch one platform app and create a window for it.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
   AppWindow* window1 = CreateAppWindow(browser()->profile(), extension1);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
 
   // Confirm that a controller item was created and is the correct state.
   const ash::ShelfItem& item1 = GetLastLauncherItem();
-  LauncherItemController* item1_controller = GetItemController(item1.id);
+  ash::ShelfItemDelegate* item1_delegate = GetShelfItemDelegate(item1.id);
   EXPECT_EQ(ash::TYPE_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
   // Since it is already active, clicking it should minimize.
-  SelectItem(item1_controller, ui::ET_MOUSE_PRESSED);
+  SelectItem(item1_delegate, ui::ET_MOUSE_PRESSED);
   EXPECT_FALSE(window1->GetNativeWindow()->IsVisible());
   EXPECT_FALSE(window1->GetBaseWindow()->IsActive());
   EXPECT_TRUE(window1->GetBaseWindow()->IsMinimized());
   EXPECT_EQ(ash::STATUS_RUNNING, item1.status);
   // Clicking the item again should activate the window again.
-  SelectItem(item1_controller, ui::ET_MOUSE_PRESSED);
+  SelectItem(item1_delegate, ui::ET_MOUSE_PRESSED);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
   // Maximizing a window should preserve state after minimize + click.
   window1->GetBaseWindow()->Maximize();
   window1->GetBaseWindow()->Minimize();
-  SelectItem(item1_controller, ui::ET_MOUSE_PRESSED);
+  SelectItem(item1_delegate, ui::ET_MOUSE_PRESSED);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_TRUE(window1->GetBaseWindow()->IsMaximized());
   window1->GetBaseWindow()->Restore();
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_FALSE(window1->GetBaseWindow()->IsMaximized());
 
   // Creating a second window of the same type should change the behavior so
   // that a click does not change the activation state.
   AppWindow* window1a = CreateAppWindow(browser()->profile(), extension1);
   EXPECT_TRUE(window1a->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1a->GetBaseWindow()->IsActive());
   // The first click does nothing.
-  SelectItem(item1_controller, ui::ET_MOUSE_PRESSED);
+  SelectItem(item1_delegate, ui::ET_MOUSE_PRESSED);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1a->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_FALSE(window1a->GetBaseWindow()->IsActive());
   // The second neither.
-  SelectItem(item1_controller, ui::ET_MOUSE_PRESSED);
+  SelectItem(item1_delegate, ui::ET_MOUSE_PRESSED);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1a->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_FALSE(window1a->GetBaseWindow()->IsActive());
 }
 
 // Confirm that ash::ShelfWindowWatcher correctly handles app panels.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, AppPanel) {
   // Enable experimental APIs to allow panel creation.
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       extensions::switches::kEnableExperimentalExtensionApis);
   // Launch a platform app and create a panel window for it.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
   AppWindow::CreateParams params;
   params.window_type = AppWindow::WINDOW_TYPE_PANEL;
   params.focused = false;
   AppWindow* panel =
       CreateAppWindowFromParams(browser()->profile(), extension1, params);
   EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
   // Panels should not be active by default.
   EXPECT_FALSE(panel->GetBaseWindow()->IsActive());
   // Confirm that an item delegate was created and is in the correct state.
   const ash::ShelfItem& item1 = GetLastLauncherPanelItem();
   EXPECT_EQ(ash::TYPE_APP_PANEL, item1.type);
   EXPECT_EQ(ash::STATUS_RUNNING, item1.status);
-  EXPECT_EQ(nullptr, GetItemController(item1.id));
-  ash::mojom::ShelfItemDelegate* item1_delegate =
+  EXPECT_EQ(nullptr, GetShelfItemDelegate(item1.id));
+  ash::ShelfItemDelegate* item1_delegate =
       shelf_model()->GetShelfItemDelegate(item1.id);
   EXPECT_EQ(ash::TYPE_APP_PANEL,
             panel->GetNativeWindow()->GetProperty(ash::kShelfItemTypeKey));
   // Click the item and confirm that the panel is activated.
   SelectItem(item1_delegate, ui::ET_MOUSE_PRESSED);
   EXPECT_TRUE(panel->GetBaseWindow()->IsActive());
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
   // Click the item again and confirm that the panel is minimized.
   SelectItem(item1_delegate, ui::ET_MOUSE_PRESSED);
   EXPECT_TRUE(panel->GetBaseWindow()->IsMinimized());
@@ skipping 18 matching lines @@
   params.focused = false;
   AppWindow* panel =
       CreateAppWindowFromParams(browser()->profile(), extension1, params);
   EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
   // Panels should not be active by default.
   EXPECT_FALSE(panel->GetBaseWindow()->IsActive());
   // Confirm that an item delegate was created and is in the correct state.
   const ash::ShelfItem& item1 = GetLastLauncherPanelItem();
   EXPECT_EQ(ash::TYPE_APP_PANEL, item1.type);
   EXPECT_EQ(ash::STATUS_RUNNING, item1.status);
-  EXPECT_EQ(nullptr, GetItemController(item1.id));
-  ash::mojom::ShelfItemDelegate* item1_delegate =
+  EXPECT_EQ(nullptr, GetShelfItemDelegate(item1.id));
+  ash::ShelfItemDelegate* item1_delegate =
       shelf_model()->GetShelfItemDelegate(item1.id);
   EXPECT_EQ(ash::TYPE_APP_PANEL,
             panel->GetNativeWindow()->GetProperty(ash::kShelfItemTypeKey));
   // Click the item and confirm that the panel is activated.
   SelectItem(item1_delegate, ui::ET_MOUSE_PRESSED);
   EXPECT_TRUE(panel->GetBaseWindow()->IsActive());
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
   // Click the item again and confirm that the panel is minimized.
   SelectItem(item1_delegate, ui::ET_MOUSE_PRESSED);
   EXPECT_TRUE(panel->GetBaseWindow()->IsMinimized());
@@ skipping 46 matching lines @@
   // This test creates one app window and one panel window.
   int shelf_item_count = shelf_model()->item_count();
   ASSERT_EQ(base_shelf_item_count + 2, shelf_item_count);
   // The Panel will be the last item, the app second-to-last.
   const ash::ShelfItem& app_item =
       shelf_model()->items()[shelf_item_count - 2];
   const ash::ShelfItem& panel_item =
       shelf_model()->items()[shelf_item_count - 1];
   // Icons for Apps are set by the AppWindowLauncherController, so
   // image_set_by_controller() should be set.
-  const LauncherItemController* app_item_controller =
-      GetItemController(app_item.id);
-  EXPECT_TRUE(app_item_controller->image_set_by_controller());
+  const ash::ShelfItemDelegate* app_item_delegate =
+      GetShelfItemDelegate(app_item.id);
+  EXPECT_TRUE(app_item_delegate->image_set_by_controller());
   // Panels are handled by ShelfWindowWatcher, not ChromeLauncherController.
-  EXPECT_EQ(nullptr, GetItemController(panel_item.id));
+  EXPECT_EQ(nullptr, GetShelfItemDelegate(panel_item.id));
   // Ensure icon heights are correct (see test.js in app_icon/ test directory)
   EXPECT_EQ(ash::GetShelfConstant(ash::SHELF_SIZE), app_item.image.height());
   EXPECT_EQ(64, panel_item.image.height());
 }
 
 // Test that we can launch an app with a shortcut.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchPinned) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::ShelfID shortcut_id = CreateShortcut("app1");
@@ skipping 613 matching lines @@
   params.window_type = AppWindow::WINDOW_TYPE_PANEL;
   params.focused = false;
   AppWindow* panel =
       CreateAppWindowFromParams(browser()->profile(), extension, params);
   EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
   // Panels should not be active by default.
   EXPECT_FALSE(panel->GetBaseWindow()->IsActive());
   // Confirm that a shelf item was created and is the correct state.
   const ash::ShelfItem& item = GetLastLauncherPanelItem();
   // Panels are handled by ShelfWindowWatcher, not ChromeLauncherController.
-  EXPECT_EQ(nullptr, GetItemController(item.id));
-  ash::mojom::ShelfItemDelegate* shelf_item_delegate =
+  EXPECT_EQ(nullptr, GetShelfItemDelegate(item.id));
+  ash::ShelfItemDelegate* shelf_item_delegate =
       shelf_model()->GetShelfItemDelegate(item.id);
   EXPECT_NE(nullptr, shelf_item_delegate);
   EXPECT_EQ(ash::TYPE_APP_PANEL, item.type);
   EXPECT_EQ(ash::STATUS_RUNNING, item.status);
 
   // App windows should go to attention state.
   panel->GetNativeWindow()->SetProperty(aura::client::kDrawAttentionKey, true);
   EXPECT_EQ(ash::STATUS_ATTENTION, item.status);
 
   // Click the item and confirm that the panel is activated.
@@ skipping 204 matching lines @@
   EXPECT_EQ(chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow()),
             browser());
   // Check that the LRU browser list does only contain the original browser.
   BrowserList* browser_list = BrowserList::GetInstance();
   BrowserList::const_reverse_iterator it = browser_list->begin_last_active();
   EXPECT_EQ(*it, browser());
   ++it;
   EXPECT_EQ(it, browser_list->end_last_active());
 
   // Now request to either activate an existing app or create a new one.
-  LauncherItemController* item_controller =
-      controller_->GetLauncherItemController(shortcut_id);
-  SelectItem(item_controller, ui::ET_KEY_RELEASED);
+  ash::ShelfItemDelegate* item_delegate =
+      controller_->GetShelfItemDelegate(shortcut_id);
+  SelectItem(item_delegate, ui::ET_KEY_RELEASED);
 
   // 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());
   EXPECT_EQ(chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow()),
             browser2);
 }
 
@@ skipping 349 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::RunLoop().RunUntilIdle();
   EXPECT_EQ(tab_count + 1, tab_strip->count());
 }
 
-// Check LauncherItemController of Browser Shortcut functionality.
+// Check ash::ShelfItemDelegate of Browser Shortcut functionality.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
                        BrowserShortcutLauncherItemController) {
-  LauncherItemController* item_controller =
+  ash::ShelfItemDelegate* item_controller =
       controller_->GetBrowserShortcutLauncherItemController();
   const ash::ShelfID id = item_controller->shelf_id();
   EXPECT_NE(ash::kInvalidShelfID, id);
 
   // Get the number of browsers.
   size_t running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(0u, running_browser);
   EXPECT_FALSE(controller_->IsOpen(id));
 
   // Activate. This creates new browser
@@ skipping 257 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));
 }