mash: Test ChromeLauncherControllerImpl more like production use.

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>
@@ skipping 259 matching lines @@
                     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:
   DISALLOW_COPY_AND_ASSIGN(TestV2AppLauncherItemController);
 };
 
-// Proxies to ShelfDelegate invocation to the given
-// ChromeLauncherControllerImpl instance. Because of ownership management,
-// ChromeLauncherControllerImpl instance cannot be injected to WmShell.
-// This wraps the instance, so that it can be injected.
-class ProxyShelfDelegate : public ash::ShelfDelegate {
- public:
-  explicit ProxyShelfDelegate(ChromeLauncherControllerImpl* controller)
-      : controller_(controller) {}
-  ~ProxyShelfDelegate() override = default;
-
-  ash::ShelfID GetShelfIDForAppID(const std::string& app_id) override {
-    return controller_->GetShelfIDForAppID(app_id);
-  };
-
-  ash::ShelfID GetShelfIDForAppIDAndLaunchID(
-      const std::string& app_id,
-      const std::string& launch_id) override {
-    return controller_->GetShelfIDForAppIDAndLaunchID(app_id, launch_id);
-  }
-
-  const std::string& GetAppIDForShelfID(ash::ShelfID id) override {
-    return controller_->GetAppIDForShelfID(id);
-  }
-
-  void PinAppWithID(const std::string& app_id) override {
-    return controller_->PinAppWithID(app_id);
-  }
-
-  bool IsAppPinned(const std::string& app_id) override {
-    return controller_->IsAppPinned(app_id);
-  }
-
-  void UnpinAppWithID(const std::string& app_id) override {
-    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<ash::MenuItemList>) {}
 
 // Simulates selection of the shelf item.
 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));
@@ skipping 169 matching lines @@
     InsertAddPinChange(user_b, 0, extension6_->id());
     InsertAddPinChange(user_b, 1, extension7_->id());
     InsertAddPinChange(user_b, 2, extension8_->id());
     InsertAddPinChange(user_b, 3, extension_misc::kChromeAppId);
   }
 
   void TearDown() override {
     arc_test_.TearDown();
     model_->RemoveObserver(model_observer_.get());
     model_observer_.reset();
-    launcher_controller_.reset();
+    launcher_controller_ = nullptr;
     BrowserWithTestWindowTest::TearDown();
   }
 
   BrowserWindow* CreateBrowserWindow() override {
     return CreateTestBrowserWindowAura();
   }
 
   std::unique_ptr<Browser> CreateBrowserWithTestWindowForProfile(
       Profile* profile) {
     TestBrowserWindow* browser_window = CreateTestBrowserWindowAura();
     new TestBrowserWindowOwner(browser_window);
     return base::WrapUnique(
         CreateBrowser(profile, Browser::TYPE_TABBED, false, browser_window));
   }
 
   void AddAppListLauncherItem() {
     ash::ShelfItem app_list;
     app_list.type = ash::TYPE_APP_LIST;
     model_->Add(app_list);
   }
 
-  void InitLauncherController() {
-    launcher_controller_.reset(
-        new ChromeLauncherControllerImpl(profile(), model_));
-    launcher_controller_->Init();
+  // Create a launcher controller instance and register it as the ShelfDelegate.
+  // Returns a pointer to the uninitialized controller, which is owned by Shell.
+  ChromeLauncherControllerImpl* CreateLauncherController() {
+    // Shell owns ChromeLauncherController as its ShelfDelegate. The lifetime
+    // of this instance should match production behavior as closely as possible.
+    DCHECK(!ChromeLauncherController::instance());
+    std::unique_ptr<ChromeLauncherControllerImpl> launcher_controller =
+        base::MakeUnique<ChromeLauncherControllerImpl>(profile(), model_);
+    launcher_controller_ = launcher_controller.get();
+    ash::test::ShellTestApi().SetShelfDelegate(std::move(launcher_controller));
+    return launcher_controller_;
   }
 
+  // Create and initialize the controller.
+  // Returns a pointer to the initialized controller, which is owned by Shell.
+  void InitLauncherController() { CreateLauncherController()->Init(); }
+
+  // Create and initialize the controller; create a tab and show the browser.
   void InitLauncherControllerWithBrowser() {
     InitLauncherController();
     chrome::NewTab(browser());
     browser()->window()->Show();
   }
 
-  void RecreateChromeLauncher() {
-    // Destroy controller first if it exists.
-    launcher_controller_.reset();
+  // Destroy Shell's controller instance and clear the local pointer.
+  void ResetLauncherController() {
+    launcher_controller_ = nullptr;
+    ash::test::ShellTestApi().SetShelfDelegate(nullptr);
+  }
+
+  // Destroy and recreate the controller; clear and reinitialize the ShelfModel.
+  // Returns a pointer to the uninitialized controller, which is owned by Shell.
+  // TODO(msw): This does not accurately represent ChromeLauncherControllerImpl
+  // lifetime or usage in production, and does not accurately simulate restarts.
+  ChromeLauncherControllerImpl* RecreateLauncherController() {
+    // Destroy any existing controller first; only one may exist at a time.
+    ResetLauncherController();
     while (model_->item_count() > 0)
       model_->RemoveItemAt(0);
     AddAppListLauncherItem();
-    launcher_controller_ =
-        base::MakeUnique<ChromeLauncherControllerImpl>(profile(), model_);
-    launcher_controller_->Init();
-  }
-
-  // This needs to be called after InitLaunchController(), or its family.
-  // It is not supported to recreate the instance.
-  void SetShelfDelegate() {
-    ash::test::ShellTestApi().SetShelfDelegate(
-        base::MakeUnique<ProxyShelfDelegate>(launcher_controller_.get()));
+    return CreateLauncherController();
   }
 
   void StartAppSyncService(const syncer::SyncDataList& init_sync_list) {
     app_service_->MergeDataAndStartSyncing(
         syncer::APP_LIST, init_sync_list,
         base::MakeUnique<syncer::FakeSyncChangeProcessor>(),
         base::MakeUnique<syncer::SyncErrorFactoryMock>());
     EXPECT_EQ(init_sync_list.size(), app_service_->sync_items().size());
   }
 
@@ skipping 397 matching lines @@
   scoped_refptr<Extension> extension4_;
   scoped_refptr<Extension> extension5_;
   scoped_refptr<Extension> extension6_;
   scoped_refptr<Extension> extension7_;
   scoped_refptr<Extension> extension8_;
   scoped_refptr<Extension> extension_platform_app_;
   scoped_refptr<Extension> arc_support_host_;
 
   ArcAppTest arc_test_;
   bool auto_start_arc_test_ = false;
-  std::unique_ptr<ChromeLauncherControllerImpl> launcher_controller_;
+  ChromeLauncherControllerImpl* launcher_controller_ = nullptr;
   std::unique_ptr<TestShelfModelObserver> model_observer_;
   ash::ShelfModel* model_ = nullptr;
   std::unique_ptr<TestingProfileManager> profile_manager_;
 
   // |item_delegate_manager_| owns |test_controller_|.
   ash::ShelfItemDelegate* test_controller_ = nullptr;
 
   ExtensionService* extension_service_ = nullptr;
 
   app_list::AppListSyncableService* app_service_ = nullptr;
@@ skipping 349 matching lines @@
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id2));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id3));
   EXPECT_EQ("AppList, App1, Chrome, App2, App3", GetPinnedAppStatus());
 
   // Persist pin state, we don't have active pin for ARC apps yet, but pin
   // model should have it.
   syncer::SyncDataList copy_sync_list =
       app_service_->GetAllSyncData(syncer::APP_LIST);
 
-  launcher_controller_.reset();
+  ResetLauncherController();
   SendPinChanges(syncer::SyncChangeList(), true);
   StopAppSyncService();
   EXPECT_EQ(0U, app_service_->sync_items().size());
 
   // Move to ARC enabled platform, restart syncing with stored data.
   StartAppSyncService(copy_sync_list);
-  RecreateChromeLauncher();
+  RecreateLauncherController()->Init();
 
   // Pins must be automatically updated.
   SendListOfArcApps();
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id1));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id2));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id3));
 
   EXPECT_EQ("AppList, App1, Chrome, Fake App 0, App2, Fake App 1, App3",
             GetPinnedAppStatus());
 
   // Now move pins on ARC enabled platform.
   model_->Move(1, 4);
   model_->Move(3, 1);
   model_->Move(3, 5);
   model_->Move(4, 2);
   EXPECT_EQ("AppList, App2, Fake App 1, Chrome, App1, Fake App 0, App3",
             GetPinnedAppStatus());
 
   copy_sync_list = app_service_->GetAllSyncData(syncer::APP_LIST);
 
-  launcher_controller_.reset();
+  ResetLauncherController();
   ResetPinModel();
 
   SendPinChanges(syncer::SyncChangeList(), true);
   StopAppSyncService();
   EXPECT_EQ(0U, app_service_->sync_items().size());
 
   // Move back to ARC disabled platform.
   // TODO(victorhsieh): Implement opt-out.
   if (arc::ShouldArcAlwaysStart())
     return;
   EnablePlayStore(false);
   StartAppSyncService(copy_sync_list);
-  RecreateChromeLauncher();
+  RecreateLauncherController()->Init();
 
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id1));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id2));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id3));
   EXPECT_EQ("AppList, App2, Chrome, App1, App3", GetPinnedAppStatus());
 
   // Now move/remove pins on ARC disabled platform.
@@ skipping 446 matching lines @@
   // Check that removing more items does not crash and changes nothing.
   launcher_controller_->SetV1AppStatus(extension2_->id(), ash::STATUS_CLOSED);
   RestoreUnpinnedRunningApplicationOrder(current_account_id);
   EXPECT_EQ("AppList, Chrome, app3", GetPinnedAppStatus());
   launcher_controller_->SetV1AppStatus(extension3_->id(), ash::STATUS_CLOSED);
   RestoreUnpinnedRunningApplicationOrder(current_account_id);
   EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 }
 
 TEST_P(ChromeLauncherControllerImplWithArcTest, ArcDeferredLaunch) {
-  RecreateChromeLauncher();
+  InitLauncherController();
 
   const arc::mojom::AppInfo& app1 = arc_test_.fake_apps()[0];
   const arc::mojom::AppInfo& app2 = arc_test_.fake_apps()[1];
   const arc::mojom::AppInfo& app3 = arc_test_.fake_apps()[2];
   const arc::mojom::ShortcutInfo& shortcut = arc_test_.fake_shortcuts()[0];
   const std::string arc_app_id1 = ArcAppTest::GetAppId(app1);
   const std::string arc_app_id2 = ArcAppTest::GetAppId(app2);
   const std::string arc_app_id3 = ArcAppTest::GetAppId(app3);
   const std::string arc_shortcut_id = ArcAppTest::GetAppId(shortcut);
 
@@ skipping 69 matching lines @@
 
   EXPECT_TRUE((request1->IsForApp(app2) && request2->IsForApp(app3)) ||
               (request1->IsForApp(app3) && request2->IsForApp(app2)));
   EXPECT_EQ(arc_test_.app_instance()->launch_intents()[0].c_str(),
             shortcut.intent_uri);
 }
 
 // Ensure the deferred controller does not override the active app controller
 // (crbug.com/701152).
 TEST_P(ChromeLauncherControllerImplWithArcTest, ArcDeferredLaunchForActiveApp) {
-  RecreateChromeLauncher();
+  InitLauncherController();
   SendListOfArcApps();
   arc_test_.StopArcInstance();
 
   const arc::mojom::AppInfo& app = arc_test_.fake_apps()[0];
   const std::string app_id = ArcAppTest::GetAppId(app);
 
   launcher_controller_->PinAppWithID(app_id);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(app_id));
   const ash::ShelfID shelf_id =
       launcher_controller_->GetShelfIDForAppID(app_id);
@@ skipping 758 matching lines @@
   extension_service_->AddExtension(extension4_.get());
 
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 10, extension_misc::kChromeAppId);
   SendPinChanges(sync_list, true);
 
   std::vector<std::string> expected_launchers;
   std::vector<std::string> actual_launchers;
-  GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 
   // Unavailable extensions don't create launcher items.
   sync_list.clear();
   InsertAddPinChange(&sync_list, 0, extension1_->id());
   InsertAddPinChange(&sync_list, 1, extension2_->id());
   InsertAddPinChange(&sync_list, 3, extension4_->id());
   SendPinChanges(sync_list, false);
 
   expected_launchers.push_back(extension2_->id());
   expected_launchers.push_back(extension4_->id());
-  GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 
   sync_list.clear();
   InsertAddPinChange(&sync_list, 2, extension3_->id());
   SendPinChanges(sync_list, false);
   expected_launchers.insert(expected_launchers.begin() + 1, extension3_->id());
-  GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 
   sync_list.clear();
   InsertUpdatePinChange(&sync_list, 0, extension4_->id());
   InsertUpdatePinChange(&sync_list, 1, extension3_->id());
   InsertUpdatePinChange(&sync_list, 2, extension2_->id());
   SendPinChanges(sync_list, false);
   std::reverse(expected_launchers.begin(), expected_launchers.end());
-  GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 
   // Sending legacy sync change without pin info should not affect pin model.
   sync_list.clear();
   InsertLegacyPinChange(&sync_list, extension4_->id());
   SendPinChanges(sync_list, false);
-  GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 
   sync_list.clear();
   InsertRemovePinChange(&sync_list, extension4_->id());
   SendPinChanges(sync_list, false);
   expected_launchers.erase(expected_launchers.begin());
-  GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 
   sync_list.clear();
   InsertRemovePinChange(&sync_list, extension3_->id());
   InsertRemovePinChange(&sync_list, extension2_->id());
   SendPinChanges(sync_list, false);
   expected_launchers.clear();
-  GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 }
 
 TEST_F(ChromeLauncherControllerImplTest, ImportLegacyPin) {
   // Note extension3_ is actually Gmail app which is default pinned.
   extension_service_->AddExtension(extension3_.get());
   InitLauncherController();
 
   // Default pins should contain Gmail. Pref is not syncing now.
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
@@ skipping 24 matching lines @@
   SendPinChanges(sync_list, false);
   EXPECT_EQ("AppList, Chrome, App4, App2, App5", GetPinnedAppStatus());
 
   // At this point changing old pref based model does not affect pin model.
   InsertPrefValue(&value, 3, extension5_->id());
   StopPrefSyncService();
   StartPrefSyncServiceForPins(value);
   EXPECT_EQ("AppList, Chrome, App4, App2, App5", GetPinnedAppStatus());
 
   // Next Chrome start should preserve pins.
-  RecreateChromeLauncher();
+  RecreateLauncherController()->Init();
   StopPrefSyncService();
   StartPrefSyncService(syncer::SyncDataList());
   EXPECT_EQ("AppList, Chrome, App4, App2, App5", GetPinnedAppStatus());
 }
 
 TEST_F(ChromeLauncherControllerImplTest, PendingInsertionOrder) {
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension3_.get());
 
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 0, extension1_->id());
   InsertAddPinChange(&sync_list, 1, extension2_->id());
   InsertAddPinChange(&sync_list, 2, extension3_->id());
   SendPinChanges(sync_list, true);
 
   std::vector<std::string> expected_launchers;
   expected_launchers.push_back(extension1_->id());
   expected_launchers.push_back(extension3_->id());
   std::vector<std::string> actual_launchers;
 
-  GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 
   // Install |extension2| and verify it shows up between the other two.
   extension_service_->AddExtension(extension2_.get());
   expected_launchers.insert(expected_launchers.begin() + 1, extension2_->id());
-  GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
+  GetAppLaunchers(launcher_controller_, &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[]) {
   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());
 
   InitLauncherController();
 
   // Check that the browser list is empty at this time.
   ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
   item_browser.id =
       launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
-  CheckAppMenu(launcher_controller_.get(), item_browser, 0, nullptr);
+  CheckAppMenu(launcher_controller_, item_browser, 0, nullptr);
 
   // Now make the created browser() visible by showing its browser window.
   browser()->window()->Show();
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL("http://test1"), title1);
   base::string16 one_menu_item[] = { title1 };
 
-  CheckAppMenu(launcher_controller_.get(), item_browser, 1, one_menu_item);
+  CheckAppMenu(launcher_controller_, item_browser, 1, one_menu_item);
 
   // Create one more browser/window and check that one more was added.
   std::unique_ptr<Browser> browser2(
       CreateBrowserWithTestWindowForProfile(profile()));
   chrome::NewTab(browser2.get());
   browser2->window()->Show();
   base::string16 title2 = ASCIIToUTF16("Test2");
   NavigateAndCommitActiveTabWithTitle(browser2.get(), GURL("http://test2"),
                                       title2);
 
   // Check that the list contains now two entries - make furthermore sure that
   // the active item is the first entry.
   base::string16 two_menu_items[] = {title1, title2};
-  CheckAppMenu(launcher_controller_.get(), item_browser, 2, two_menu_items);
+  CheckAppMenu(launcher_controller_, item_browser, 2, two_menu_items);
 
   // Apparently we have to close all tabs we have.
   chrome::CloseTab(browser2.get());
 }
 
 // Check the multi profile case where only user related browsers should show up.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        BrowserMenuGenerationTwoUsers) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
 
   ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
   item_browser.id =
       launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
 
   // Check that the menu is empty.
   chrome::NewTab(browser());
-  CheckAppMenu(launcher_controller_.get(), item_browser, 0, nullptr);
+  CheckAppMenu(launcher_controller_, item_browser, 0, nullptr);
 
   // Show the created |browser()| by showing its window.
   browser()->window()->Show();
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL("http://test1"), title1);
   base::string16 one_menu_item1[] = { title1 };
-  CheckAppMenu(launcher_controller_.get(), item_browser, 1, one_menu_item1);
+  CheckAppMenu(launcher_controller_, item_browser, 1, one_menu_item1);
 
   // Create a browser for another user and check that it is not included in the
   // users running browser list.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   std::unique_ptr<Browser> browser2(
       CreateBrowserAndTabWithProfile(profile2, user2, "http://test2"));
   base::string16 one_menu_item2[] = { ASCIIToUTF16(user2) };
-  CheckAppMenu(launcher_controller_.get(), item_browser, 1, one_menu_item1);
+  CheckAppMenu(launcher_controller_, item_browser, 1, one_menu_item1);
 
   // Switch to the other user and make sure that only that browser window gets
   // shown.
   SwitchActiveUser(account_id2);
-  CheckAppMenu(launcher_controller_.get(), item_browser, 1, one_menu_item2);
+  CheckAppMenu(launcher_controller_, item_browser, 1, one_menu_item2);
 
   // Transferred browsers of other users should not show up in the list.
   chrome::MultiUserWindowManager::GetInstance()->ShowWindowForUser(
       browser()->window()->GetNativeWindow(), account_id2);
-  CheckAppMenu(launcher_controller_.get(), item_browser, 1, one_menu_item2);
+  CheckAppMenu(launcher_controller_, item_browser, 1, one_menu_item2);
 
   chrome::CloseTab(browser2.get());
 }
 
 // Check that V1 apps are correctly reflected in the launcher menu using the
 // refocus logic.
 // Note that the extension matching logic is tested by the extension system
 // and does not need a separate test here.
 TEST_F(ChromeLauncherControllerImplTest, V1AppMenuGeneration) {
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
@@ skipping 16 matching lines @@
 
   // Check the menu content.
   ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
   item_browser.id =
       launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
 
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
-  CheckAppMenu(launcher_controller_.get(), item_gmail, 0, nullptr);
+  CheckAppMenu(launcher_controller_, item_gmail, 0, nullptr);
 
   // Set the gmail URL to a new tab.
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
 
   base::string16 one_menu_item[] = { title1 };
-  CheckAppMenu(launcher_controller_.get(), item_gmail, 1, one_menu_item);
+  CheckAppMenu(launcher_controller_, item_gmail, 1, one_menu_item);
 
   // Create one empty tab.
   chrome::NewTab(browser());
   base::string16 title2 = ASCIIToUTF16("Test2");
   NavigateAndCommitActiveTabWithTitle(
       browser(),
       GURL("https://bla"),
       title2);
 
   // and another one with another gmail instance.
   chrome::NewTab(browser());
   base::string16 title3 = ASCIIToUTF16("Test3");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title3);
   base::string16 two_menu_items[] = {title1, title3};
-  CheckAppMenu(launcher_controller_.get(), item_gmail, 2, two_menu_items);
+  CheckAppMenu(launcher_controller_, item_gmail, 2, two_menu_items);
 
   // Even though the item is in the V1 app list, it should also be in the
   // browser list.
   base::string16 browser_menu_item[] = {title3};
-  CheckAppMenu(launcher_controller_.get(), item_browser, 1, browser_menu_item);
+  CheckAppMenu(launcher_controller_, item_browser, 1, browser_menu_item);
 
   // Test that closing of (all) the item(s) does work (and all menus get
   // updated properly).
   launcher_controller_->Close(item_gmail.id);
 
-  CheckAppMenu(launcher_controller_.get(), item_gmail, 0, nullptr);
+  CheckAppMenu(launcher_controller_, item_gmail, 0, nullptr);
   base::string16 browser_menu_item2[] = { title2 };
-  CheckAppMenu(launcher_controller_.get(), item_browser, 1, browser_menu_item2);
+  CheckAppMenu(launcher_controller_, item_browser, 1, browser_menu_item2);
 }
 
 // Check the multi profile case where only user related apps should show up.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V1AppMenuGenerationTwoUsers) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
   chrome::NewTab(browser());
 
   // Installing |extension3_| adds it to the launcher.
   ash::ShelfID gmail_id = model_->next_id();
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ(3, model_->item_count());
   int gmail_index = model_->ItemIndexByID(gmail_id);
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[gmail_index].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
 
   // Check the menu content.
   ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
   item_browser.id =
       launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
 
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
-  CheckAppMenu(launcher_controller_.get(), item_gmail, 0, nullptr);
+  CheckAppMenu(launcher_controller_, item_gmail, 0, nullptr);
 
   // Set the gmail URL to a new tab.
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
 
   base::string16 one_menu_item[] = { title1 };
-  CheckAppMenu(launcher_controller_.get(), item_gmail, 1, one_menu_item);
+  CheckAppMenu(launcher_controller_, item_gmail, 1, one_menu_item);
 
   // Create a second profile and switch to that user.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   SwitchActiveUser(account_id2);
 
   // No item should have content yet.
-  CheckAppMenu(launcher_controller_.get(), item_browser, 0, nullptr);
-  CheckAppMenu(launcher_controller_.get(), item_gmail, 0, nullptr);
+  CheckAppMenu(launcher_controller_, item_browser, 0, nullptr);
+  CheckAppMenu(launcher_controller_, item_gmail, 0, nullptr);
 
   // Transfer the browser of the first user - it should still not show up.
   chrome::MultiUserWindowManager::GetInstance()->ShowWindowForUser(
       browser()->window()->GetNativeWindow(), account_id2);
 
-  CheckAppMenu(launcher_controller_.get(), item_browser, 0, nullptr);
-  CheckAppMenu(launcher_controller_.get(), item_gmail, 0, nullptr);
+  CheckAppMenu(launcher_controller_, item_browser, 0, nullptr);
+  CheckAppMenu(launcher_controller_, item_gmail, 0, nullptr);
 }
 
 // Check that V2 applications are creating items properly in the launcher when
 // instantiated by the current user.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V2AppHandlingTwoUsers) {
   InitLauncherController();
   // Create a profile for our second user (will be destroyed by the framework).
   TestingProfile* profile2 = CreateMultiUserProfile("user2");
   const AccountId account_id(
@@ skipping 217 matching lines @@
   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);
+  CheckAppMenu(launcher_controller_, item_gmail, 2, two_menu_items);
   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),
@@ skipping 27 matching lines @@
   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);
+  CheckAppMenu(launcher_controller_, item_gmail, 2, two_menu_items);
 
   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.
   {
     ash::MenuItemList items =
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail);
     item_delegate->ExecuteCommand(items[1]->command_id, ui::EF_NONE);
@@ skipping 139 matching lines @@
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[3].type);
 
   // Move browser shortcut item from index 1 to index 3.
   model_->Move(1, 3);
   EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[1].type);
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[3].type);
 
-  launcher_controller_.reset();
-  while (!model_->items().empty())
-    model_->RemoveItemAt(0);
-
-  AddAppListLauncherItem();
-  launcher_controller_ =
-      base::MakeUnique<ChromeLauncherControllerImpl>(profile(), model_);
+  RecreateLauncherController();
   helper = new TestLauncherControllerHelper(profile());
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   helper->SetAppID(tab_strip_model->GetWebContentsAt(1), "2");
   SetLauncherControllerHelper(helper);
   launcher_controller_->Init();
 
   // Check ShelfItems are restored after resetting ChromeLauncherControllerImpl.
   EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[1].type);
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
@@ skipping 20 matching lines @@
 
   launcher_controller_->PinAppWithID("1");
   ash::ShelfID id = launcher_controller_->GetShelfIDForAppID("1");
   int app_index = model_->ItemIndexByID(id);
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[app_index].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
   EXPECT_EQ(initial_size + 1, model_->items().size());
 
-  launcher_controller_.reset();
-  while (!model_->items().empty())
-    model_->RemoveItemAt(0);
-
-  AddAppListLauncherItem();
-  launcher_controller_ =
-      base::MakeUnique<ChromeLauncherControllerImpl>(profile(), model_);
+  RecreateLauncherController();
   helper = new TestLauncherControllerHelper(profile());
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   SetLauncherControllerHelper(helper);
   // app_icon_loader is owned by ChromeLauncherControllerImpl.
   app_icon_loader = new TestAppIconLoaderImpl;
   app_icon_loader->AddSupportedApp("1");
   SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
   launcher_controller_->Init();
 
   EXPECT_EQ(1, app_icon_loader->fetch_count());
@@ skipping 94 matching lines @@
   extension_service_->AddExtension(arc_support_host_.get());
   // Test enables ARC, so turn it off for initial values.
   EnablePlayStore(false);
 
   InitLauncherController();
 
   // To prevent import legacy pins each time.
   // Initially pins are imported from legacy pref based model.
   StartPrefSyncService(syncer::SyncDataList());
 
-  // Inject |launcher_controller_| as ShelfDelegate to verify the behavior
-  // of removing pinned icon in ArcSessionManager::OnOptInPreferenceChanged().
-  SetShelfDelegate();
-
   // Initial run, ARC is not managed and disabled, Play Store pin should be
   // available.
   ValidateArcState(false, false, arc::ArcSessionManager::State::STOPPED,
                    "AppList, Chrome, Play Store");
 
   // ARC is managed and enabled, Play Store pin should be available.
   // Note: NEGOTIATING_TERMS_OF_SERVICE here means that opt-in flow starts.
   profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kArcEnabled, base::MakeUnique<base::Value>(true));
   base::RunLoop().RunUntilIdle();
@@ skipping 340 matching lines @@
             display::Screen::GetScreen()->GetPrimaryDisplay().rotation());
 
   // Manually unlock first.
   NotifyOnTaskOrientationLockRequested(task_id_none_, OrientationLock::NONE);
   EXPECT_FALSE(controller->rotation_locked());
 }
 
 TEST_P(ChromeLauncherControllerArcDefaultAppsTest, DefaultApps) {
   arc_test_.SetUp(profile());
   InitLauncherController();
-  ChromeLauncherController::set_instance_for_test(launcher_controller_.get());
+  // TODO(crbug.com/709297): Fix this workaround to prevent a TearDown crash.
+  std::vector<std::unique_ptr<AppIconLoader>> no_loaders;
+  launcher_controller_->SetAppIconLoadersForTest(no_loaders);
 
   ArcAppListPrefs* const prefs = arc_test_.arc_app_list_prefs();
   EnablePlayStore(false);
   EXPECT_FALSE(arc::IsArcPlayStoreEnabledForProfile(profile()));
   ASSERT_TRUE(prefs->GetAppIds().size());
 
   const std::string app_id =
       ArcAppTest::GetAppId(arc_test_.fake_default_apps()[0]);
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(app_id));
@@ skipping 115 matching lines @@
   InsertAddPinChange(&sync_list, 1, extension1_->id());
   InsertAddPinChange(&sync_list, 1, extension2_->id());
   SendPinChanges(sync_list, true);
 
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
 
   syncer::SyncDataList copy_sync_list =
       app_service_->GetAllSyncData(syncer::APP_LIST);
 
   app_service_->StopSyncing(syncer::APP_LIST);
-  RecreateChromeLauncher();
+  RecreateLauncherController()->Init();
 
   // Pinned state should not change.
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
   launcher_controller_->UnpinAppWithID(extension2_->id());
   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
 
   // Resume syncing and sync information overrides local copy.
   StartAppSyncService(copy_sync_list);
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
 }
@@ skipping 140 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));
 }