Use mojo Shelf interfaces for both mash and classic ash.

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 222 matching lines @@
 
   bool IsValidIDForCurrentUser(const std::string& id) const override {
     for (TabToStringMap::const_iterator i = tab_id_map_.begin();
          i != tab_id_map_.end(); ++i) {
       if (i->second == id)
         return true;
     }
     return false;
   }
 
-  void SetCurrentUser(Profile* profile) override {
-    // We can ignore this for now.
-  }
-
   ArcAppListPrefs* GetArcAppListPrefs() const override { return nullptr; }
 
  private:
   typedef std::map<content::WebContents*, std::string> TabToStringMap;
 
   TabToStringMap tab_id_map_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLauncherControllerHelper);
 };
 
@@ skipping 29 matching lines @@
         new ChromeLauncherAppMenuItem(base::string16(), NULL, false));
     items.push_back(
         new ChromeLauncherAppMenuItem(base::string16(), NULL, false));
     return items;
   }
   ash::ShelfMenuModel* CreateApplicationMenu(int event_flags) override {
     return NULL;
   }
   bool IsDraggable() override { return false; }
   bool CanPin() const override {
-    return GetPinnableForAppID(app_id(), launcher_controller()->GetProfile()) ==
+    return GetPinnableForAppID(app_id(), launcher_controller()->profile()) ==
            AppListControllerDelegate::PIN_EDITABLE;
   }
   bool ShouldShowTooltip() override { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestV2AppLauncherItemController);
 };
 
 }  // namespace
 
@@ skipping 189 matching lines @@
   void AddAppListLauncherItem() {
     ash::ShelfItem app_list;
     app_list.type = ash::TYPE_APP_LIST;
     model_->Add(app_list);
   }
 
   void InitLauncherController() {
     AddAppListLauncherItem();
     launcher_controller_.reset(
         new ChromeLauncherControllerImpl(profile(), model_.get()));
+    // TODO(crbug.com/654622): Some tests break with a non-null static instance.
+    ChromeLauncherControllerImpl::set_instance_for_test(nullptr);
     launcher_controller_->Init();
   }
 
   void InitLauncherControllerWithBrowser() {
     InitLauncherController();
     chrome::NewTab(browser());
     browser()->window()->Show();
   }
 
   void RecreateChromeLauncher() {
     // Destroy controller first if it exists.
     launcher_controller_.reset();
     model_.reset(new ash::ShelfModel);
     AddAppListLauncherItem();
-    launcher_controller_.reset(
-        ChromeLauncherControllerImpl::CreateInstance(profile(), model_.get()));
+    launcher_controller_ =
+        base::MakeUnique<ChromeLauncherControllerImpl>(profile(), model_.get());
     launcher_controller_->Init();
   }
 
   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());
   }
 
   void StopAppSyncService() { app_service_->StopSyncing(syncer::APP_LIST); }
 
   void SetAppIconLoader(std::unique_ptr<AppIconLoader> loader) {
     std::vector<std::unique_ptr<AppIconLoader>> loaders;
     loaders.push_back(std::move(loader));
     launcher_controller_->SetAppIconLoadersForTest(loaders);
   }
 
   void SetAppIconLoaders(std::unique_ptr<AppIconLoader> loader1,
                          std::unique_ptr<AppIconLoader> loader2) {
     std::vector<std::unique_ptr<AppIconLoader>> loaders;
     loaders.push_back(std::move(loader1));
     loaders.push_back(std::move(loader2));
     launcher_controller_->SetAppIconLoadersForTest(loaders);
   }
 
   void SetLauncherControllerHelper(LauncherControllerHelper* helper) {
-    launcher_controller_->SetLauncherControllerHelperForTest(helper);
+    launcher_controller_->SetLauncherControllerHelperForTest(
+        base::WrapUnique<LauncherControllerHelper>(helper));
   }
 
   void InsertPrefValue(base::ListValue* pref_value,
                        int index,
                        const std::string& extension_id) {
     auto entry = base::MakeUnique<base::DictionaryValue>();
     entry->SetString(ash::launcher::kPinnedAppsPrefAppIDPath, extension_id);
     pref_value->Insert(index, std::move(entry));
   }
 
@@ skipping 2852 matching lines @@
   model_->Move(1, 3);
   EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[1].type);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[3].type);
 
   launcher_controller_.reset();
   model_.reset(new ash::ShelfModel);
 
   AddAppListLauncherItem();
-  launcher_controller_.reset(
-      ChromeLauncherControllerImpl::CreateInstance(profile(), model_.get()));
+  launcher_controller_ =
+      base::MakeUnique<ChromeLauncherControllerImpl>(profile(), model_.get());
   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_APP_SHORTCUT, model_->items()[1].type);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
@@ skipping 24 matching lines @@
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, 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();
   model_.reset(new ash::ShelfModel);
 
   AddAppListLauncherItem();
-  launcher_controller_.reset(
-      ChromeLauncherControllerImpl::CreateInstance(profile(), model_.get()));
+  launcher_controller_ =
+      base::MakeUnique<ChromeLauncherControllerImpl>(profile(), model_.get());
   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 445 matching lines @@
   NotifyOnTaskOrientationLockRequested(task_id_current_,
                                        OrientationLock::CURRENT);
   EXPECT_TRUE(controller->rotation_locked());
   EXPECT_EQ(display::Display::ROTATE_0,
             display::Screen::GetScreen()->GetPrimaryDisplay().rotation());
 }
 
 TEST_F(ChromeLauncherControllerArcDefaultAppsTest, DefaultApps) {
   arc_test_.SetUp(profile());
   InitLauncherController();
-  ChromeLauncherController::set_instance(launcher_controller_.get());
+  ChromeLauncherController::set_instance_for_test(launcher_controller_.get());
   arc::ArcAuthService::SetShelfDelegateForTesting(launcher_controller_.get());
 
   ArcAppListPrefs* const prefs = arc_test_.arc_app_list_prefs();
   EnableArc(false);
   EXPECT_FALSE(arc_test_.arc_auth_service()->IsArcEnabled());
   ASSERT_TRUE(prefs->GetAppIds().size());
 
   const std::string app_id =
       ArcAppTest::GetAppId(arc_test_.fake_default_apps()[0]);
   EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(app_id));
@@ skipping 62 matching lines @@
       app_service_->GetPinPosition(extension_misc::kChromeAppId)));
   EXPECT_TRUE(
       position_1.Equals(app_service_->GetPinPosition(extension1_->id())));
   EXPECT_TRUE(
       position_1.Equals(app_service_->GetPinPosition(extension1_->id())));
   EXPECT_TRUE(
       position_2.Equals(app_service_->GetPinPosition(extension2_->id())));
   EXPECT_TRUE(
       position_3.Equals(app_service_->GetPinPosition(extension3_->id())));
 }