mash: Move LauncherItemController to ash, rename ShelfItemDelegate.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl_unittest.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 <algorithm>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/common/shelf/shelf_application_menu_model.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_controller.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/shelf_model_observer.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/public/cpp/app_launch_id.h"
 #include "ash/public/cpp/shelf_item.h"
+#include "ash/public/cpp/shelf_item_delegate.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_helper.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
@@ skipping 19 matching lines @@
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/app_list/arc/arc_default_app_list.h"
 #include "chrome/browser/ui/apps/chrome_app_delegate.h"
 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
 #include "chrome/browser/ui/ash/launcher/app_window_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_deferred_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/browser_status_monitor.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller_util.h"
 #include "chrome/browser/ui/ash/launcher/extension_app_window_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/launcher_controller_helper.h"
-#include "chrome/browser/ui/ash/launcher/launcher_item_controller.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager_chromeos.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_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_constants.h"
@@ skipping 76 matching lines @@
 
   void ShelfItemChanged(int index, const ash::ShelfItem& old_item) override {
     ++changed_;
     last_index_ = index;
   }
 
   void ShelfItemMoved(int start_index, int target_index) override {
     last_index_ = target_index;
   }
 
-  void OnSetShelfItemDelegate(
-      ash::ShelfID id,
-      ash::mojom::ShelfItemDelegate* item_delegate) override {}
+  void OnSetShelfItemDelegate(ash::ShelfID id,
+                              ash::ShelfItemDelegate* item_delegate) override {}
 
   void clear_counts() {
     added_ = 0;
     removed_ = 0;
     changed_ = 0;
     last_index_ = 0;
   }
 
   int added() const { return added_; }
   int removed() const { return removed_; }
@@ skipping 73 matching lines @@
 
  private:
   typedef std::map<content::WebContents*, std::string> TabToStringMap;
 
   TabToStringMap tab_id_map_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLauncherControllerHelper);
 };
 
 // Test implementation of a V2 app launcher item controller.
-class TestV2AppLauncherItemController : public LauncherItemController {
+class TestV2AppLauncherItemController : public ash::ShelfItemDelegate {
  public:
-  TestV2AppLauncherItemController(const std::string& app_id,
-                                  ChromeLauncherController* controller)
-      : LauncherItemController(ash::AppLaunchId(app_id), controller) {}
+  explicit TestV2AppLauncherItemController(const std::string& app_id)
+      : ash::ShelfItemDelegate(ash::AppLaunchId(app_id)) {}
 
   ~TestV2AppLauncherItemController() override {}
 
-  // Override for LauncherItemController:
+  // Override for ash::ShelfItemDelegate:
   void ItemSelected(std::unique_ptr<ui::Event> event,
                     int64_t display_id,
                     ash::ShelfLaunchSource source,
                     const ItemSelectedCallback& callback) override {
     callback.Run(ash::SHELF_ACTION_WINDOW_ACTIVATED, base::nullopt);
   }
   void ExecuteCommand(uint32_t command_id, int32_t event_flags) override {}
   void Close() override {}
 
  private:
@@ skipping 36 matching lines @@
     return controller_->UnpinAppWithID(app_id);
   }
 
  private:
   ChromeLauncherControllerImpl* const controller_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyShelfDelegate);
 };
 
 // A callback that does nothing after shelf item selection handling.
-void NoopCallback(ash::ShelfAction action, base::Optional<MenuItemList>) {}
+void NoopCallback(ash::ShelfAction action, base::Optional<ash::MenuItemList>) {}
 
 // Simulates selection of the shelf item.
-void SelectItem(ash::mojom::ShelfItemDelegate* delegate) {
+void SelectItem(ash::ShelfItemDelegate* delegate) {
   std::unique_ptr<ui::Event> event = base::MakeUnique<ui::MouseEvent>(
       ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), ui::EventTimeForNow(),
       ui::EF_NONE, 0);
   delegate->ItemSelected(std::move(event), display::kInvalidDisplayId,
                          ash::LAUNCH_FROM_UNKNOWN, base::Bind(&NoopCallback));
 }
 
 }  // namespace
 
 class ChromeLauncherControllerImplTest : public BrowserWithTestWindowTest {
@@ skipping 110 matching lines @@
     arc_support_host_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
                                           manifest, Extension::NO_FLAGS,
                                           ArcSupportHost::kHostAppId, &error);
     extension_service_->AddExtension(extension_chrome_.get());
   }
 
   // Creates a running platform V2 app (not pinned) of type |app_id|.
   virtual void CreateRunningV2App(const std::string& app_id) {
     DCHECK(!test_controller_);
     // Change the created launcher controller into a V2 app controller.
-    test_controller_ = new TestV2AppLauncherItemController(app_id,
-        launcher_controller_.get());
+    std::unique_ptr<TestV2AppLauncherItemController> controller =
+        base::MakeUnique<TestV2AppLauncherItemController>(app_id);
+    test_controller_ = controller.get();
     ash::ShelfID id = launcher_controller_->InsertAppLauncherItem(
-        test_controller_, ash::STATUS_RUNNING, model_->item_count(),
+        std::move(controller), ash::STATUS_RUNNING, model_->item_count(),
         ash::TYPE_APP);
     DCHECK(launcher_controller_->IsPlatformApp(id));
   }
 
   // Sets the stage for a multi user test.
   virtual void SetUpMultiUserScenario(syncer::SyncChangeList* user_a,
                                       syncer::SyncChangeList* user_b) {
     InitLauncherController();
     EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 
@@ skipping 498 matching lines @@
   scoped_refptr<Extension> arc_support_host_;
 
   ArcAppTest arc_test_;
   bool auto_start_arc_test_ = false;
   std::unique_ptr<ChromeLauncherControllerImpl> launcher_controller_;
   std::unique_ptr<TestShelfModelObserver> model_observer_;
   ash::ShelfModel* model_ = nullptr;
   std::unique_ptr<TestingProfileManager> profile_manager_;
 
   // |item_delegate_manager_| owns |test_controller_|.
-  LauncherItemController* test_controller_ = nullptr;
+  ash::ShelfItemDelegate* test_controller_ = nullptr;
 
   ExtensionService* extension_service_ = nullptr;
 
   app_list::AppListSyncableService* app_service_ = nullptr;
 
  private:
   TestBrowserWindow* CreateTestBrowserWindowAura() {
     std::unique_ptr<aura::Window> window(new aura::Window(nullptr));
     window->set_id(0);
     window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
@@ skipping 50 matching lines @@
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsDestroyedWatcher);
 };
 
 // A V1 windowed application.
 class V1App : public TestBrowserWindow {
  public:
   V1App(Profile* profile, const std::string& app_name) {
-    // Create a window.
-    native_window_.reset(new aura::Window(NULL));
-    native_window_->set_id(0);
-    native_window_->SetType(ui::wm::WINDOW_TYPE_POPUP);
-    native_window_->Init(ui::LAYER_TEXTURED);
-    native_window_->Show();
-    aura::client::ParentWindowWithContext(native_window_.get(),
-                                          ash::Shell::GetPrimaryRootWindow(),
-                                          gfx::Rect(10, 10, 20, 30));
     Browser::CreateParams params = Browser::CreateParams::CreateForApp(
         kCrxAppPrefix + app_name, true /* trusted_source */, gfx::Rect(),
         profile, true);
     params.window = this;
     browser_.reset(new Browser(params));
     chrome::AddTabAt(browser_.get(), GURL(), 0, true);
   }
 
   ~V1App() override {
     // close all tabs. Note that we do not need to destroy the browser itself.
     browser_->tab_strip_model()->CloseAllTabs();
   }
 
   Browser* browser() { return browser_.get(); }
 
-  // TestBrowserWindow override:
-  gfx::NativeWindow GetNativeWindow() const override {
-    return native_window_.get();
-  }
-
  private:
   // The associated browser with this app.
   std::unique_ptr<Browser> browser_;
 
-  // The native window we use.
-  std::unique_ptr<aura::Window> native_window_;
-
   DISALLOW_COPY_AND_ASSIGN(V1App);
 };
 
 // A V2 application window created with an |extension| and for a |profile|.
 // Upon destruction it will properly close the application; supports panels too.
 class V2App {
  public:
   V2App(Profile* profile,
         const extensions::Extension* extension,
         extensions::AppWindow::WindowType window_type =
@@ skipping 137 matching lines @@
     return browser;
   }
 
   // Creates a running V1 application.
   // Note that with the use of the launcher_controller_helper as done below,
   // this is only usable with a single v1 application.
   V1App* CreateRunningV1App(Profile* profile,
                             const std::string& app_name,
                             const std::string& url) {
     V1App* v1_app = new V1App(profile, app_name);
-    // Create a new launcher controller helper and assign it to the launcher so
-    // that this app gets properly detected.
-    // TODO(skuhne): Create a more intelligent launcher controller helper that
-    // is able to detect all running apps properly.
-    TestLauncherControllerHelper* helper = new TestLauncherControllerHelper;
-    helper->SetAppID(v1_app->browser()->tab_strip_model()->GetWebContentsAt(0),
-                     app_name);
-    SetLauncherControllerHelper(helper);
-
     NavigateAndCommitActiveTabWithTitle(v1_app->browser(), GURL(url),
                                         base::string16());
     return v1_app;
   }
 
   ash::test::TestShellDelegate* shell_delegate() { return shell_delegate_; }
 
   // Override BrowserWithTestWindowTest:
   TestingProfile* CreateProfile() override {
     return CreateMultiUserProfile("user1");
@@ skipping 646 matching lines @@
   const ash::ShelfID shelf_id_app_2 =
       launcher_controller_->GetShelfIDForAppID(arc_app_id2);
   const ash::ShelfID shelf_id_app_3 =
       launcher_controller_->GetShelfIDForAppID(arc_app_id3);
   EXPECT_NE(ash::kInvalidShelfID, shelf_id_app_1);
   EXPECT_NE(ash::kInvalidShelfID, shelf_id_app_2);
   EXPECT_NE(ash::kInvalidShelfID, shelf_id_app_3);
 
   // We activated arc_app_id1 twice but expect one close for item controller
   // stops launching request.
-  LauncherItemController* item_controller =
-      launcher_controller_->GetLauncherItemController(shelf_id_app_1);
-  ASSERT_NE(nullptr, item_controller);
-  item_controller->Close();
+  ash::ShelfItemDelegate* item_delegate =
+      launcher_controller_->GetShelfItemDelegate(shelf_id_app_1);
+  ASSERT_NE(nullptr, item_delegate);
+  item_delegate->Close();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(arc_app_id1));
   EXPECT_EQ(shelf_id_app_2,
             launcher_controller_->GetShelfIDForAppID(arc_app_id2));
   EXPECT_EQ(shelf_id_app_3,
             launcher_controller_->GetShelfIDForAppID(arc_app_id3));
 
   arc_test_.RestartArcInstance();
@@ skipping 36 matching lines @@
   EXPECT_NE(ash::kInvalidShelfID, shelf_id);
 
   int item_index = model_->ItemIndexByID(shelf_id);
   ASSERT_GE(item_index, 0);
 
   EXPECT_EQ(model_->items()[item_index].status, ash::STATUS_CLOSED);
   EXPECT_EQ(model_->items()[item_index].type, ash::TYPE_PINNED_APP);
 
   // Play Store app is ARC app that might be represented by native Chrome
   // platform app.
-  AppWindowLauncherItemController* app_controller =
-      new ExtensionAppWindowLauncherItemController(ash::AppLaunchId(app_id),
-                                                   launcher_controller_.get());
-  launcher_controller_->SetItemController(shelf_id, app_controller);
+  launcher_controller_->SetShelfItemDelegate(
+      shelf_id, base::MakeUnique<ExtensionAppWindowLauncherItemController>(
+                    ash::AppLaunchId(app_id)));
   launcher_controller_->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
 
   // This launch request should be ignored in case of active app.
   arc::LaunchApp(profile(), app_id, ui::EF_LEFT_MOUSE_BUTTON);
   EXPECT_FALSE(launcher_controller_->GetArcDeferredLauncher()->HasApp(app_id));
 
   // Close app but shortcut should exist.
   launcher_controller_->CloseLauncherItem(shelf_id);
   EXPECT_EQ(shelf_id, launcher_controller_->GetShelfIDForAppID(app_id));
 
@@ skipping 294 matching lines @@
   EXPECT_EQ("AppList, Chrome, App1, Fake App 1, App2, Fake App 0",
             GetPinnedAppStatus());
 }
 
 // Check that with multi profile V1 apps are properly added / removed from the
 // shelf.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V1AppUpdateOnUserSwitch) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
-  // TODO(crbug.com/654622): This test breaks with a non-null static instance.
-  ChromeLauncherControllerImpl::set_instance_for_test(nullptr);
 
   EXPECT_EQ(2, model_->item_count());
   {
     // Create a "windowed gmail app".
     std::unique_ptr<V1App> v1_app(
         CreateRunningV1App(profile(), extension_misc::kGmailAppId, gmail_url));
     EXPECT_EQ(3, model_->item_count());
 
     // After switching to a second user the item should be gone.
     std::string user2 = "user2";
@@ skipping 11 matching lines @@
     // Note we destroy now the gmail app with the closure end.
   }
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check edge cases with multi profile V1 apps in the shelf.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V1AppUpdateOnUserSwitchEdgecases) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
-  // TODO(crbug.com/654622): This test breaks with a non-null static instance.
-  ChromeLauncherControllerImpl::set_instance_for_test(nullptr);
 
   // First test: Create an app when the user is not active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   {
     // Create a "windowed gmail app".
@@ skipping 16 matching lines @@
   EXPECT_EQ(2, model_->item_count());
   SwitchActiveUser(account_id);
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check edge case where a visiting V1 app gets closed (crbug.com/321374).
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V1CloseOnVisitingDesktop) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
-  // TODO(crbug.com/654622): This test breaks with a non-null static instance.
-  ChromeLauncherControllerImpl::set_instance_for_test(nullptr);
 
   chrome::MultiUserWindowManager* manager =
       chrome::MultiUserWindowManager::GetInstance();
 
   // First create an app when the user is active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
@@ skipping 24 matching lines @@
   }
   SwitchActiveUser(account_id2);
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check edge cases with multi profile V1 apps in the shelf.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V1AppUpdateOnUserSwitchEdgecases2) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
-  // TODO(crbug.com/654622): This test breaks with a non-null static instance.
-  ChromeLauncherControllerImpl::set_instance_for_test(nullptr);
-
-  SetLauncherControllerHelper(new TestLauncherControllerHelper);
 
   // First test: Create an app when the user is not active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   SwitchActiveUser(account_id2);
   {
@@ skipping 443 matching lines @@
   expected_launchers.insert(expected_launchers.begin() + 1, extension2_->id());
   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 }
 
 // Ensure |controller| creates the expected menu items for the given shelf item.
 void CheckAppMenu(ChromeLauncherControllerImpl* controller,
                   const ash::ShelfItem& item,
                   size_t expected_item_count,
                   base::string16 expected_item_titles[]) {
-  MenuItemList items = controller->GetAppMenuItemsForTesting(item);
+  ash::MenuItemList items = controller->GetAppMenuItemsForTesting(item);
   ASSERT_EQ(expected_item_count, items.size());
   for (size_t i = 0; i < expected_item_count; i++)
     EXPECT_EQ(expected_item_titles[i], items[i]->label);
 }
 
 // Check that browsers get reflected correctly in the launcher menu.
 TEST_F(ChromeLauncherControllerImplTest, BrowserMenuGeneration) {
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   chrome::NewTab(browser());
 
@@ skipping 430 matching lines @@
   chrome::NewTab(browser());
   base::string16 title2 = ASCIIToUTF16("Test2");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title2);
 
   // Check that the menu is properly set.
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   base::string16 two_menu_items[] = {title1, title2};
   CheckAppMenu(launcher_controller_.get(), item_gmail, 2, two_menu_items);
-  LauncherItemController* item_controller =
-      launcher_controller_->GetLauncherItemController(gmail_id);
-  ASSERT_TRUE(item_controller);
+  ash::ShelfItemDelegate* item_delegate =
+      launcher_controller_->GetShelfItemDelegate(gmail_id);
+  ASSERT_TRUE(item_delegate);
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
   // Execute the second item in the menu, after the title and two separators,
   // this shouldn't do anything since that item is already the active tab.
   {
     ash::ShelfApplicationMenuModel menu(
         base::string16(),
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail),
-        item_controller);
+        item_delegate);
     menu.ActivatedAt(4);
   }
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 
   // Execute the first item in the menu, after the title and two separators,
   // this should activate the other tab.
   {
     ash::ShelfApplicationMenuModel menu(
         base::string16(),
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail),
-        item_controller);
+        item_delegate);
     menu.ActivatedAt(3);
   }
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
 }
 
 // Checks that the generated menu list properly deletes items.
 TEST_F(ChromeLauncherControllerImplTest, V1AppMenuDeletionExecution) {
   InitLauncherControllerWithBrowser();
 
   // Add |extension3_| to the launcher and add two items.
   GURL gmail = GURL("https://mail.google.com/mail/u");
   ash::ShelfID gmail_id = model_->next_id();
   extension_service_->AddExtension(extension3_.get());
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
   chrome::NewTab(browser());
   base::string16 title2 = ASCIIToUTF16("Test2");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title2);
 
   // Check that the menu is properly set.
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   base::string16 two_menu_items[] = {title1, title2};
   CheckAppMenu(launcher_controller_.get(), item_gmail, 2, two_menu_items);
 
-  LauncherItemController* item_controller =
-      launcher_controller_->GetLauncherItemController(gmail_id);
-  ASSERT_TRUE(item_controller);
+  ash::ShelfItemDelegate* item_delegate =
+      launcher_controller_->GetShelfItemDelegate(gmail_id);
+  ASSERT_TRUE(item_delegate);
   int tabs = browser()->tab_strip_model()->count();
   // Activate the proper tab through the menu item.
   {
-    MenuItemList items =
+    ash::MenuItemList items =
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail);
-    item_controller->ExecuteCommand(items[1]->command_id, ui::EF_NONE);
+    item_delegate->ExecuteCommand(items[1]->command_id, ui::EF_NONE);
     EXPECT_EQ(tabs, browser()->tab_strip_model()->count());
   }
 
   // Delete one tab through the menu item.
   {
-    MenuItemList items =
+    ash::MenuItemList items =
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail);
-    item_controller->ExecuteCommand(items[1]->command_id, ui::EF_SHIFT_DOWN);
+    item_delegate->ExecuteCommand(items[1]->command_id, ui::EF_SHIFT_DOWN);
     EXPECT_EQ(--tabs, browser()->tab_strip_model()->count());
   }
 }
 
 // Tests that panels create launcher items correctly
 TEST_F(ChromeLauncherControllerImplTest, AppPanels) {
   InitLauncherController();
   model_observer_->clear_counts();
   const std::string app_id = extension1_->id();
 
@@ skipping 209 matching lines @@
   const std::string app_id3 = extension3_->id();
   // app_icon_loader1 and app_icon_loader2 are owned by
   // ChromeLauncherControllerImpl.
   TestAppIconLoaderImpl* app_icon_loader1 = new TestAppIconLoaderImpl();
   TestAppIconLoaderImpl* app_icon_loader2 = new TestAppIconLoaderImpl();
   app_icon_loader1->AddSupportedApp(app_id1);
   app_icon_loader2->AddSupportedApp(app_id2);
   SetAppIconLoaders(std::unique_ptr<AppIconLoader>(app_icon_loader1),
                     std::unique_ptr<AppIconLoader>(app_icon_loader2));
 
-  AppWindowLauncherItemController* app_controller3 =
-      new ExtensionAppWindowLauncherItemController(ash::AppLaunchId(app_id3),
-                                                   launcher_controller_.get());
   const ash::ShelfID shelfId3 = launcher_controller_->CreateAppLauncherItem(
-      app_controller3, ash::STATUS_RUNNING);
+      base::MakeUnique<ExtensionAppWindowLauncherItemController>(
+          ash::AppLaunchId(app_id3)),
+      ash::STATUS_RUNNING);
   EXPECT_EQ(0, app_icon_loader1->fetch_count());
   EXPECT_EQ(0, app_icon_loader1->clear_count());
   EXPECT_EQ(0, app_icon_loader2->fetch_count());
   EXPECT_EQ(0, app_icon_loader2->clear_count());
 
-  AppWindowLauncherItemController* app_controller2 =
-      new ExtensionAppWindowLauncherItemController(ash::AppLaunchId(app_id2),
-                                                   launcher_controller_.get());
   const ash::ShelfID shelfId2 = launcher_controller_->CreateAppLauncherItem(
-      app_controller2, ash::STATUS_RUNNING);
+      base::MakeUnique<ExtensionAppWindowLauncherItemController>(
+          ash::AppLaunchId(app_id2)),
+      ash::STATUS_RUNNING);
   EXPECT_EQ(0, app_icon_loader1->fetch_count());
   EXPECT_EQ(0, app_icon_loader1->clear_count());
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(0, app_icon_loader2->clear_count());
 
-  AppWindowLauncherItemController* app_controller1 =
-      new ExtensionAppWindowLauncherItemController(ash::AppLaunchId(app_id1),
-                                                   launcher_controller_.get());
-
   const ash::ShelfID shelfId1 = launcher_controller_->CreateAppLauncherItem(
-      app_controller1, ash::STATUS_RUNNING);
+      base::MakeUnique<ExtensionAppWindowLauncherItemController>(
+          ash::AppLaunchId(app_id1)),
+      ash::STATUS_RUNNING);
   EXPECT_EQ(1, app_icon_loader1->fetch_count());
   EXPECT_EQ(0, app_icon_loader1->clear_count());
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(0, app_icon_loader2->clear_count());
 
   launcher_controller_->CloseLauncherItem(shelfId1);
   EXPECT_EQ(1, app_icon_loader1->fetch_count());
   EXPECT_EQ(1, app_icon_loader1->clear_count());
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(0, app_icon_loader2->clear_count());
@@ skipping 113 matching lines @@
   views::Widget* window2 = CreateArcWindow("org.chromium.arc.2");
   ASSERT_TRUE(window2);
 
   EXPECT_FALSE(window1->IsActive());
   EXPECT_TRUE(window2->IsActive());
 
   const std::string app_id = ArcAppTest::GetAppId(appinfo);
 
   const ash::ShelfID shelf_id =
       launcher_controller_->GetShelfIDForAppID(app_id);
-  LauncherItemController* item_controller =
-      launcher_controller_->GetLauncherItemController(shelf_id);
-  ASSERT_TRUE(item_controller);
+  ash::ShelfItemDelegate* item_delegate =
+      launcher_controller_->GetShelfItemDelegate(shelf_id);
+  ASSERT_TRUE(item_delegate);
 
   // Selecting the item will show its application menu. It does not change the
   // active window.
-  SelectItem(item_controller);
+  SelectItem(item_delegate);
   EXPECT_FALSE(window1->IsActive());
   EXPECT_TRUE(window2->IsActive());
 
   // Command ids are just app window indices. Note, apps are registered in
   // opposite order. Last created goes in front.
-  MenuItemList items = item_controller->GetAppMenuItems(0);
+  ash::MenuItemList items = item_delegate->GetAppMenuItems(0);
   ASSERT_EQ(items.size(), 2U);
   EXPECT_EQ(items[0]->command_id, 0U);
   EXPECT_EQ(items[1]->command_id, 1U);
 
   // Execute command to activate first window.
-  item_controller->ExecuteCommand(items[1]->command_id, 0);
+  item_delegate->ExecuteCommand(items[1]->command_id, 0);
   EXPECT_TRUE(window1->IsActive());
   EXPECT_FALSE(window2->IsActive());
 
   // Selecting the item will show its application menu. It does not change the
   // active window.
-  SelectItem(item_controller);
+  SelectItem(item_delegate);
   EXPECT_TRUE(window1->IsActive());
   EXPECT_FALSE(window2->IsActive());
 
   // Execute command to activate second window.
-  item_controller->ExecuteCommand(items[0]->command_id, 0);
+  item_delegate->ExecuteCommand(items[0]->command_id, 0);
   EXPECT_FALSE(window1->IsActive());
   EXPECT_TRUE(window2->IsActive());
 }
 
 namespace {
 
 class ChromeLauncherControllerOrientationTest
     : public ChromeLauncherControllerImplWithArcTest {
  public:
   ChromeLauncherControllerOrientationTest() {}
@@ skipping 356 matching lines @@
 
   EnablePlayStore(true);
 
   // Pin Play Store. It should be pinned but not scheduled for deferred launch.
   launcher_controller_->PinAppWithID(arc::kPlayStoreAppId);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc::kPlayStoreAppId));
   EXPECT_FALSE(launcher_controller_->GetArcDeferredLauncher()->HasApp(
       arc::kPlayStoreAppId));
 
   // Simulate click. This should schedule Play Store for deferred launch.
-  LauncherItemController* item_controller =
-      launcher_controller_->GetLauncherItemController(
+  ash::ShelfItemDelegate* item_delegate =
+      launcher_controller_->GetShelfItemDelegate(
           launcher_controller_->GetShelfIDForAppID(arc::kPlayStoreAppId));
-  EXPECT_TRUE(item_controller);
-  SelectItem(item_controller);
+  EXPECT_TRUE(item_delegate);
+  SelectItem(item_delegate);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc::kPlayStoreAppId));
   EXPECT_TRUE(launcher_controller_->GetArcDeferredLauncher()->HasApp(
       arc::kPlayStoreAppId));
 }
 
 // Checks the case when several app items have the same ordinal position (which
 // is valid case).
 TEST_F(ChromeLauncherControllerImplTest, CheckPositionConflict) {
   InitLauncherController();
 
@@ skipping 216 matching lines @@
   EXPECT_EQ(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS,
             shelf_controller->auto_hide());
   EXPECT_EQ(2u, shelf_controller->auto_hide_change_count());
 
   PrefService* prefs = profile()->GetTestingPrefService();
   EXPECT_EQ("Left", prefs->GetString(prefs::kShelfAlignmentLocal));
   EXPECT_EQ("Left", prefs->GetString(prefs::kShelfAlignment));
   EXPECT_EQ("Always", prefs->GetString(prefs::kShelfAutoHideBehaviorLocal));
   EXPECT_EQ("Always", prefs->GetString(prefs::kShelfAutoHideBehavior));
 }