Adding ChromeLauncherController interface.

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.h"
+#include "chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 258 matching lines @@
            AppListControllerDelegate::PIN_EDITABLE;
   }
   bool ShouldShowTooltip() override { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestV2AppLauncherItemController);
 };
 
 }  // namespace
 
-class ChromeLauncherControllerTest : public BrowserWithTestWindowTest {
+class ChromeLauncherControllerImplTest : public BrowserWithTestWindowTest {
  protected:
-  ChromeLauncherControllerTest()
+  ChromeLauncherControllerImplTest()
       : BrowserWithTestWindowTest(Browser::TYPE_TABBED, false),
         test_controller_(NULL),
         extension_service_(NULL) {}
 
-  ~ChromeLauncherControllerTest() override {}
+  ~ChromeLauncherControllerImplTest() override {}
 
   void SetUp() override {
     BrowserWithTestWindowTest::SetUp();
 
     model_.reset(new ash::ShelfModel);
     model_observer_.reset(new TestShelfModelObserver);
     model_->AddObserver(model_observer_.get());
 
     if (ash::Shell::HasInstance()) {
       item_delegate_manager_ =
@@ skipping 159 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 ChromeLauncherController(profile(), model_.get()));
+        new ChromeLauncherControllerImpl(profile(), model_.get()));
     if (!ash::Shell::HasInstance())
       SetShelfItemDelegateManager(item_delegate_manager_);
     launcher_controller_->Init();
   }
 
   void InitLauncherControllerWithBrowser() {
     InitLauncherController();
     chrome::NewTab(browser());
     browser()->window()->Show();
   }
@@ skipping 22 matching lines @@
 
   void InsertPrefValue(base::ListValue* pref_value,
                        int index,
                        const std::string& extension_id) {
     base::DictionaryValue* entry = new base::DictionaryValue();
     entry->SetString(ash::kPinnedAppsPrefAppIDPath, extension_id);
     pref_value->Insert(index, entry);
   }
 
   // Gets the currently configured app launchers from the controller.
-  void GetAppLaunchers(ChromeLauncherController* controller,
+  void GetAppLaunchers(ChromeLauncherControllerImpl* controller,
                        std::vector<std::string>* launchers) {
     launchers->clear();
     for (ash::ShelfItems::const_iterator iter(model_->items().begin());
          iter != model_->items().end(); ++iter) {
-      ChromeLauncherController::IDToItemControllerMap::const_iterator
-          entry(controller->id_to_item_controller_map_.find(iter->id));
+      ChromeLauncherControllerImpl::IDToItemControllerMap::const_iterator entry(
+          controller->id_to_item_controller_map_.find(iter->id));
       if (iter->type == ash::TYPE_APP_SHORTCUT &&
           entry != controller->id_to_item_controller_map_.end()) {
         launchers->push_back(entry->second->app_id());
       }
     }
   }
 
   // Get the setup of the currently shown launcher items in one string.
   // Each pinned element will start with a big letter, each running but not
   // pinned V1 app will start with a small letter and each running but not
@@ skipping 149 matching lines @@
   scoped_refptr<Extension> extension1_;
   scoped_refptr<Extension> extension2_;
   scoped_refptr<Extension> extension3_;
   scoped_refptr<Extension> extension4_;
   scoped_refptr<Extension> extension5_;
   scoped_refptr<Extension> extension6_;
   scoped_refptr<Extension> extension7_;
   scoped_refptr<Extension> extension8_;
 
   ArcAppTest arc_test_;
-  std::unique_ptr<ChromeLauncherController> launcher_controller_;
+  std::unique_ptr<ChromeLauncherControllerImpl> launcher_controller_;
   std::unique_ptr<TestShelfModelObserver> model_observer_;
   std::unique_ptr<ash::ShelfModel> model_;
 
   // |item_delegate_manager_| owns |test_controller_|.
   LauncherItemController* test_controller_;
 
   ExtensionService* extension_service_;
 
   ash::ShelfItemDelegateManager* item_delegate_manager_;
 
  private:
   TestBrowserWindow* CreateTestBrowserWindowAura() {
     std::unique_ptr<aura::Window> window(new aura::Window(nullptr));
     window->set_id(0);
     window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
     aura::client::ParentWindowWithContext(window.get(), GetContext(),
                                           gfx::Rect(200, 200));
 
     return new TestBrowserWindowAura(std::move(window));
   }
 
-  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerTest);
+  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerImplTest);
 };
 
 // Watches WebContents and blocks until it is destroyed. This is needed for
 // the destruction of a V2 application.
 class WebContentsDestroyedWatcher : public content::WebContentsObserver {
  public:
   explicit WebContentsDestroyedWatcher(content::WebContents* web_contents)
       : content::WebContentsObserver(web_contents),
         message_loop_runner_(new content::MessageLoopRunner) {
     EXPECT_TRUE(web_contents != NULL);
@@ skipping 91 matching lines @@
 
   // The app window which represents the application. Note that the window
   // deletes itself asynchronously after window_->GetBaseWindow()->Close() gets
   // called.
   extensions::AppWindow* window_;
 
   DISALLOW_COPY_AND_ASSIGN(V2App);
 };
 
 // The testing framework to test multi profile scenarios.
-class MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest
-    : public ChromeLauncherControllerTest {
+class MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest
+    : public ChromeLauncherControllerImplTest {
  protected:
-  MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() {
-  }
+  MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest() {}
 
-  ~MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() override {}
+  ~MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest()
+      override {}
 
   // Overwrite the Setup function to enable multi profile and needed objects.
   void SetUp() override {
     profile_manager_.reset(
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
 
     ASSERT_TRUE(profile_manager_->SetUp());
 
     // AvatarMenu and multiple profiles works after user logged in.
     profile_manager_->SetLoggedIn(true);
 
     // Initialize the UserManager singleton to a fresh FakeUserManager instance.
     user_manager_enabler_.reset(new chromeos::ScopedUserManagerEnabler(
         new chromeos::FakeChromeUserManager));
 
     // Initialize the WallpaperManager singleton.
     chromeos::WallpaperManager::Initialize();
 
     // Initialize the rest.
-    ChromeLauncherControllerTest::SetUp();
+    ChromeLauncherControllerImplTest::SetUp();
 
     // Get some base objects.
     session_delegate()->set_logged_in_users(2);
     shell_delegate_ = static_cast<ash::test::TestShellDelegate*>(
         ash::Shell::GetInstance()->delegate());
     shell_delegate_->set_multi_profiles_enabled(true);
   }
 
   void TearDown() override {
-    ChromeLauncherControllerTest::TearDown();
+    ChromeLauncherControllerImplTest::TearDown();
     user_manager_enabler_.reset();
     for (ProfileToNameMap::iterator it = created_profiles_.begin();
          it != created_profiles_.end(); ++it)
       profile_manager_->DeleteTestingProfile(it->second);
     chromeos::WallpaperManager::Shutdown();
 
     // A Task is leaked if we don't destroy everything, then run the message
     // loop.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
@@ skipping 107 matching lines @@
   }
 
   std::unique_ptr<TestingProfileManager> profile_manager_;
   std::unique_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
 
   ash::test::TestShellDelegate* shell_delegate_;
 
   ProfileToNameMap created_profiles_;
 
   DISALLOW_COPY_AND_ASSIGN(
-      MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest);
+      MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest);
 };
 
-TEST_F(ChromeLauncherControllerTest, DefaultApps) {
+TEST_F(ChromeLauncherControllerImplTest, DefaultApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon.
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
 }
 
 /*
- * Test ChromeLauncherController correctly merges policy pinned apps
+ * Test ChromeLauncherControllerImpl correctly merges policy pinned apps
  * and user pinned apps
  */
-TEST_F(ChromeLauncherControllerTest, MergePolicyAndUserPrefPinnedApps) {
+TEST_F(ChromeLauncherControllerImplTest, MergePolicyAndUserPrefPinnedApps) {
   InitLauncherController();
 
   base::ListValue user_pref_value;
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension3_.get());
   extension_service_->AddExtension(extension4_.get());
   extension_service_->AddExtension(extension5_.get());
   // extension 1, 3 are pinned by user
   InsertPrefValue(&user_pref_value, 0, extension1_->id());
   InsertPrefValue(&user_pref_value, 1, extension3_->id());
@@ skipping 28 matching lines @@
   EXPECT_EQ(AppListControllerDelegate::PIN_FIXED,
             launcher_controller_->GetPinnable(extension4_->id()));
 
   // Check the order of shelf pinned apps
   EXPECT_EQ("AppList, App2, App4, App1, Chrome, App3", GetPinnedAppStatus());
 }
 
 // Check that the restauration of launcher items is happening in the same order
 // as the user has pinned them (on another system) when they are synced reverse
 // order.
-TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsReverseOrder) {
+TEST_F(ChromeLauncherControllerImplTest, RestoreDefaultAppsReverseOrder) {
   InitLauncherController();
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   SetShelfChromeIconIndex(0);
   // Model should only contain the browser shortcut and app list items.
@@ skipping 18 matching lines @@
 
   // Installing |extension1_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension1_.get());
   EXPECT_EQ("AppList, Chrome, App1, App2, App3", GetPinnedAppStatus());
 }
 
 // Check that the restauration of launcher items is happening in the same order
 // as the user has pinned them (on another system) when they are synced random
 // order.
-TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsRandomOrder) {
+TEST_F(ChromeLauncherControllerImplTest, RestoreDefaultAppsRandomOrder) {
   InitLauncherController();
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
 
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   SetShelfChromeIconIndex(0);
@@ skipping 18 matching lines @@
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ("AppList, Chrome, App1, App2, App3", GetPinnedAppStatus());
 }
 
 // Check that the restauration of launcher items is happening in the same order
 // as the user has pinned / moved them (on another system) when they are synced
 // random order - including the chrome icon.
-TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsRandomOrderChromeMoved) {
+TEST_F(ChromeLauncherControllerImplTest,
+       RestoreDefaultAppsRandomOrderChromeMoved) {
   InitLauncherController();
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   SetShelfChromeIconIndex(1);
   // Model should only contain the browser shortcut and app list items.
@@ skipping 16 matching lines @@
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_EQ("AppList, App1, Chrome, App2", GetPinnedAppStatus());
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ("AppList, App1, Chrome, App2, App3", GetPinnedAppStatus());
 }
 
 // Check that syncing to a different state does the correct thing.
-TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsResyncOrder) {
+TEST_F(ChromeLauncherControllerImplTest, RestoreDefaultAppsResyncOrder) {
   InitLauncherController();
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   // The shelf layout has always one static item at the beginning (App List).
   SetShelfChromeIconIndex(0);
   extension_service_->AddExtension(extension2_.get());
@@ skipping 40 matching lines @@
                                       UnloadedExtensionInfo::REASON_UNINSTALL);
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 
   // Check that an update of an extension does not crash the system.
   extension_service_->UnloadExtension(extension3_->id(),
                                       UnloadedExtensionInfo::REASON_UPDATE);
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 }
 
 // Check that simple locking of an application will 'create' a launcher item.
-TEST_F(ChromeLauncherControllerTest, CheckLockApps) {
+TEST_F(ChromeLauncherControllerImplTest, CheckLockApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension2_->id()));
 
@@ skipping 12 matching lines @@
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension2_->id()));
 }
 
 // Check that multiple locks of an application will be properly handled.
-TEST_F(ChromeLauncherControllerTest, CheckMultiLockApps) {
+TEST_F(ChromeLauncherControllerImplTest, CheckMultiLockApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   for (int i = 0; i < 2; i++) {
     launcher_controller_->LockV1AppWithID(extension1_->id());
 
@@ skipping 16 matching lines @@
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 }
 
 // Check that already pinned items are not effected by locks.
-TEST_F(ChromeLauncherControllerTest, CheckAlreadyPinnedLockApps) {
+TEST_F(ChromeLauncherControllerImplTest, CheckAlreadyPinnedLockApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   launcher_controller_->PinAppWithID(extension1_->id());
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
@@ skipping 19 matching lines @@
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   launcher_controller_->UnpinAppWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check that already pinned items which get locked stay after unpinning.
-TEST_F(ChromeLauncherControllerTest, CheckPinnedAppsStayAfterUnlock) {
+TEST_F(ChromeLauncherControllerImplTest, CheckPinnedAppsStayAfterUnlock) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   launcher_controller_->PinAppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
@@ skipping 17 matching lines @@
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   launcher_controller_->UnlockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check that running applications wich are not pinned get properly restored
 // upon user change.
-TEST_F(ChromeLauncherControllerTest, CheckRunningAppOrder) {
+TEST_F(ChromeLauncherControllerImplTest, CheckRunningAppOrder) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
 
   // Add a few running applications.
   launcher_controller_->LockV1AppWithID(extension1_->id());
   launcher_controller_->LockV1AppWithID(extension2_->id());
   launcher_controller_->LockV1AppWithID(extension3_->id());
   EXPECT_EQ(5, model_->item_count());
   // Note that this not only checks the order of applications but also the
@@ skipping 28 matching lines @@
 
   // Check that removing more items does not crash and changes nothing.
   launcher_controller_->UnlockV1AppWithID(extension2_->id());
   RestoreUnpinnedRunningApplicationOrder(current_account_id);
   EXPECT_EQ("AppList, Chrome, app3", GetPinnedAppStatus());
   launcher_controller_->UnlockV1AppWithID(extension3_->id());
   RestoreUnpinnedRunningApplicationOrder(current_account_id);
   EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 }
 
-TEST_F(ChromeLauncherControllerTest, ArcDeferredLaunch) {
+TEST_F(ChromeLauncherControllerImplTest, ArcDeferredLaunch) {
   arc_test_.SetUp(profile());
 
   launcher_controller_.reset(
-      ChromeLauncherController::CreateInstance(profile(), model_.get()));
+      ChromeLauncherControllerImpl::CreateInstance(profile(), model_.get()));
   launcher_controller_->Init();
 
   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 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);
 
   SendListOfArcApps();
@@ skipping 47 matching lines @@
 
   const arc::FakeAppInstance::Request* request1 =
       arc_test_.app_instance()->launch_requests()[0];
   const arc::FakeAppInstance::Request* request2 =
       arc_test_.app_instance()->launch_requests()[1];
 
   EXPECT_TRUE((request1->IsForApp(app2) && request2->IsForApp(app3)) ||
               (request1->IsForApp(app3) && request2->IsForApp(app2)));
 }
 
-TEST_F(ChromeLauncherControllerTest, ArcRunningApp) {
+TEST_F(ChromeLauncherControllerImplTest, ArcRunningApp) {
   arc_test_.SetUp(profile());
   InitLauncherController();
 
   const std::string arc_app_id = ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   SendListOfArcApps();
   EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
 
   // Normal flow, create/destroy tasks.
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0]);
   EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
   arc_test_.app_instance()->SendTaskCreated(2, arc_test_.fake_apps()[0]);
   EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
   arc_test_.app_instance()->SendTaskDestroyed(1);
   EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
   arc_test_.app_instance()->SendTaskDestroyed(2);
   EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
 
   // Stopping bridge removes apps.
   arc_test_.app_instance()->SendTaskCreated(3, arc_test_.fake_apps()[0]);
   EXPECT_NE(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
   arc_test_.bridge_service()->SetStopped();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(arc_app_id));
 }
 
 // Validate that Arc app is pinned correctly and pin is removed automatically
 // once app is uninstalled.
-TEST_F(ChromeLauncherControllerTest, ArcAppPin) {
+TEST_F(ChromeLauncherControllerImplTest, ArcAppPin) {
   arc_test_.SetUp(profile());
   InitLauncherController();
 
   const std::string arc_app_id = ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
 
   SendListOfArcApps();
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension2_.get());
 
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
@@ skipping 26 matching lines @@
   EnableArc(false);
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
   EnableArc(true);
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
   SendListOfArcApps();
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
 }
 
 // Check that with multi profile V1 apps are properly added / removed from the
 // shelf.
-TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V1AppUpdateOnUserSwitch) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
   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";
     TestingProfile* profile2 = CreateMultiUserProfile(user2);
     const AccountId account_id2(
         multi_user_util::GetAccountIdFromProfile(profile2));
     const AccountId account_id(
         multi_user_util::GetAccountIdFromProfile(profile()));
     SwitchActiveUser(account_id2);
     EXPECT_EQ(2, model_->item_count());
 
     // After switching back the item should be back.
     SwitchActiveUser(account_id);
     EXPECT_EQ(3, model_->item_count());
     // 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(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V1AppUpdateOnUserSwitchEdgecases) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
 
   // 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(
@@ skipping 15 matching lines @@
     // Note: the closure ends and the browser will go away.
   }
   EXPECT_EQ(2, model_->item_count());
   SwitchActiveUser(account_id2);
   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(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V1CloseOnVisitingDesktop) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
 
   chrome::MultiUserWindowManager* manager =
       chrome::MultiUserWindowManager::GetInstance();
 
   // First create an app when the user is active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
@@ skipping 23 matching lines @@
     // Create a "windowed gmail app".
     std::unique_ptr<V1App> v1_app(CreateRunningV1App(
         profile(), extension_misc::kGmailAppId, kGmailLaunchURL));
     EXPECT_EQ(3, model_->item_count());
   }
   SwitchActiveUser(account_id2);
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check edge cases with multi profile V1 apps in the shelf.
-TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V1AppUpdateOnUserSwitchEdgecases2) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
   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()));
@@ skipping 18 matching lines @@
   }
   EXPECT_EQ(2, model_->item_count());
   SwitchActiveUser(account_id);
   EXPECT_EQ(2, model_->item_count());
   SwitchActiveUser(account_id2);
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check that activating an item which is on another user's desktop, will bring
 // it back.
-TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        TestLauncherActivationPullsBackWindow) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
   chrome::MultiUserWindowManager* manager =
       chrome::MultiUserWindowManager::GetInstance();
 
   // Create a second test profile. The first is the one in profile() created in
   // BrowserWithTestWindowTest::SetUp().
   // No need to add the profiles to the MultiUserWindowManager here.
   // CreateMultiUserProfile() already does that.
@@ skipping 17 matching lines @@
   // Transfer the window to another user's desktop and check that activating it
   // does pull it back to that user.
   manager->ShowWindowForUser(
       window, multi_user_util::GetAccountIdFromProfile(profile2));
   EXPECT_FALSE(manager->IsWindowOnDesktopOfUser(window, current_user));
   launcher_controller_->ActivateWindowOrMinimizeIfActive(browser_window, false);
   EXPECT_TRUE(manager->IsWindowOnDesktopOfUser(window, current_user));
 }
 
 // Check that lock -> pin -> unlock -> unpin does properly transition.
-TEST_F(ChromeLauncherControllerTest, CheckLockPinUnlockUnpin) {
+TEST_F(ChromeLauncherControllerImplTest, CheckLockPinUnlockUnpin) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   launcher_controller_->LockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
@@ skipping 18 matching lines @@
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   launcher_controller_->UnpinAppWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check that a locked (windowed V1 application) will be properly converted
 // between locked and pinned when the order gets changed through a profile /
 // policy change.
-TEST_F(ChromeLauncherControllerTest, RestoreDefaultAndLockedAppsResyncOrder) {
+TEST_F(ChromeLauncherControllerImplTest,
+       RestoreDefaultAndLockedAppsResyncOrder) {
   InitLauncherController();
   base::ListValue policy_value0;
   InsertPrefValue(&policy_value0, 0, extension1_->id());
   InsertPrefValue(&policy_value0, 1, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value0.DeepCopy());
   // The shelf layout has always one static item at the beginning (App List).
   SetShelfChromeIconIndex(0);
   extension_service_->AddExtension(extension1_.get());
   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
@@ skipping 32 matching lines @@
   base::ListValue policy_value3;
   InsertPrefValue(&policy_value3, 0, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value3.DeepCopy());
   EXPECT_EQ("AppList, Chrome, App3, app2", GetPinnedAppStatus());
 }
 
 // Check that a running and not pinned V2 application will be properly converted
 // between locked and pinned when the order gets changed through a profile /
 // policy change.
-TEST_F(ChromeLauncherControllerTest,
+TEST_F(ChromeLauncherControllerImplTest,
        RestoreDefaultAndRunningV2AppsResyncOrder) {
   InitLauncherController();
   base::ListValue policy_value0;
   InsertPrefValue(&policy_value0, 0, extension1_->id());
   InsertPrefValue(&policy_value0, 1, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value0.DeepCopy());
   // The shelf layout has always one static item at the beginning (app List).
   SetShelfChromeIconIndex(0);
   extension_service_->AddExtension(extension1_.get());
@@ skipping 30 matching lines @@
   // Removing an item should simply close it and everything should shift.
   base::ListValue policy_value3;
   InsertPrefValue(&policy_value3, 0, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value3.DeepCopy());
   EXPECT_EQ("AppList, Chrome, App3, *app2", GetPinnedAppStatus());
 }
 
 // Each user has a different set of applications pinned. Check that when
 // switching between the two users, the state gets properly set.
-TEST_F(ChromeLauncherControllerTest, UserSwitchIconRestore) {
+TEST_F(ChromeLauncherControllerImplTest, UserSwitchIconRestore) {
   base::ListValue user_a;
   base::ListValue user_b;
   SetUpMultiUserScenario(&user_a, &user_b);
   // Show user 1.
   SetShelfChromeIconIndex(6);
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   user_a.DeepCopy());
   EXPECT_EQ("AppList, App1, App2, App3, App4, App5, App6, Chrome",
             GetPinnedAppStatus());
 
@@ skipping 14 matching lines @@
   // Switch back to 2.
   SetShelfChromeIconIndex(4);
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   user_b.DeepCopy());
   EXPECT_EQ("AppList, App7, App8, Chrome", GetPinnedAppStatus());
 }
 
 // Each user has a different set of applications pinned, and one user has an
 // application running. Check that when switching between the two users, the
 // state gets properly set.
-TEST_F(ChromeLauncherControllerTest, UserSwitchIconRestoreWithRunningV2App) {
+TEST_F(ChromeLauncherControllerImplTest,
+       UserSwitchIconRestoreWithRunningV2App) {
   base::ListValue user_a;
   base::ListValue user_b;
   SetUpMultiUserScenario(&user_a, &user_b);
 
   // Run App1 and assume that it is a V2 app.
   CreateRunningV2App(extension1_->id());
 
   // Show user 1.
   SetShelfChromeIconIndex(6);
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
@@ skipping 19 matching lines @@
   SetShelfChromeIconIndex(4);
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   user_b.DeepCopy());
   EXPECT_EQ("AppList, App7, App8, Chrome, *app1", GetPinnedAppStatus());
 }
 
 // Each user has a different set of applications pinned, and one user has an
 // application running. The chrome icon is not the last item in the list.
 // Check that when switching between the two users, the state gets properly set.
 // There was once a bug associated with this.
-TEST_F(ChromeLauncherControllerTest,
+TEST_F(ChromeLauncherControllerImplTest,
        UserSwitchIconRestoreWithRunningV2AppChromeInMiddle) {
   base::ListValue user_a;
   base::ListValue user_b;
   SetUpMultiUserScenario(&user_a, &user_b);
 
   // Run App1 and assume that it is a V2 app.
   CreateRunningV2App(extension1_->id());
 
   // Show user 1.
   SetShelfChromeIconIndex(5);
@@ skipping 10 matching lines @@
   EXPECT_EQ("AppList, App7, App8, Chrome, *app1", GetPinnedAppStatus());
 
   // Switch back to 1.
   SetShelfChromeIconIndex(5);
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   user_a.DeepCopy());
   EXPECT_EQ("AppList, App1, App2, App3, App4, App5, Chrome, App6",
             GetPinnedAppStatus());
 }
 
-TEST_F(ChromeLauncherControllerTest, Policy) {
+TEST_F(ChromeLauncherControllerImplTest, Policy) {
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension3_.get());
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   profile()->GetTestingPrefService()->SetManagedPref(prefs::kPinnedLauncherApps,
                                                      policy_value.DeepCopy());
 
   // Only |extension1_| should get pinned. |extension2_| is specified but not
@@ skipping 19 matching lines @@
   policy_value.Remove(0, NULL);
   profile()->GetTestingPrefService()->SetManagedPref(prefs::kPinnedLauncherApps,
                                                      policy_value.DeepCopy());
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 }
 
-TEST_F(ChromeLauncherControllerTest, UnpinWithUninstall) {
+TEST_F(ChromeLauncherControllerImplTest, UnpinWithUninstall) {
   extension_service_->AddExtension(extension3_.get());
   extension_service_->AddExtension(extension4_.get());
 
   InitLauncherController();
 
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension4_->id()));
 
   extension_service_->UnloadExtension(extension3_->id(),
                                       UnloadedExtensionInfo::REASON_UNINSTALL);
 
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension4_->id()));
 }
 
-TEST_F(ChromeLauncherControllerTest, PrefUpdates) {
+TEST_F(ChromeLauncherControllerImplTest, PrefUpdates) {
   extension_service_->AddExtension(extension2_.get());
   extension_service_->AddExtension(extension3_.get());
   extension_service_->AddExtension(extension4_.get());
 
   InitLauncherController();
 
   std::vector<std::string> expected_launchers;
   std::vector<std::string> actual_launchers;
   base::ListValue pref_value;
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
@@ skipping 35 matching lines @@
 
   // Clearing works.
   pref_value.Clear();
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                  pref_value.DeepCopy());
   expected_launchers.clear();
   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 }
 
-TEST_F(ChromeLauncherControllerTest, PendingInsertionOrder) {
+TEST_F(ChromeLauncherControllerImplTest, PendingInsertionOrder) {
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension3_.get());
 
   InitLauncherController();
 
   base::ListValue pref_value;
   InsertPrefValue(&pref_value, 0, extension1_->id());
   InsertPrefValue(&pref_value, 1, extension2_->id());
   InsertPrefValue(&pref_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
@@ skipping 12 matching lines @@
   expected_launchers.insert(expected_launchers.begin() + 1, extension2_->id());
   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 }
 
 // Checks the created menus and menu lists for correctness. It uses the given
 // |controller| to create the objects for the given |item| and checks the
 // found item count against the |expected_items|. The |title| list contains the
 // menu titles in the order of their appearance in the menu (not including the
 // application name).
-bool CheckMenuCreation(ChromeLauncherController* controller,
+bool CheckMenuCreation(ChromeLauncherControllerImpl* controller,
                        const ash::ShelfItem& item,
                        size_t expected_items,
                        base::string16 title[],
                        bool is_browser) {
   ChromeLauncherAppMenuItems items = controller->GetApplicationList(item, 0);
   // A new behavior has been added: Only show menus if there is at least one
   // item available.
   if (expected_items < 1 && is_browser) {
     EXPECT_EQ(0u, items.size());
     return items.size() == 0;
@@ skipping 22 matching lines @@
   EXPECT_EQ(expected_menu_items, menu->GetItemCount());
   EXPECT_FALSE(menu->IsEnabledAt(first_item));
   if (expected_items) {
     EXPECT_EQ(ui::MenuModel::TYPE_SEPARATOR,
               menu->GetTypeAt(first_item + 1));
   }
   return items.size() == expected_items + 1;
 }
 
 // Check that browsers get reflected correctly in the launcher menu.
-TEST_F(ChromeLauncherControllerTest, BrowserMenuGeneration) {
+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);
@@ skipping 23 matching lines @@
   base::string16 two_menu_items[] = {title1, title2};
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 2, two_menu_items, true));
 
   // 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(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+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.
@@ skipping 33 matching lines @@
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 1, one_menu_item2, true));
 
   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(ChromeLauncherControllerTest, V1AppMenuGeneration) {
+TEST_F(ChromeLauncherControllerImplTest, V1AppMenuGeneration) {
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   EXPECT_EQ(0, browser()->tab_strip_model()->count());
 
   InitLauncherControllerWithBrowser();
 
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Installing |extension3_| adds it to the launcher.
@@ skipping 52 matching lines @@
   launcher_controller_->Close(item_gmail.id);
 
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_gmail, 0, NULL, false));
   base::string16 browser_menu_item2[] = { title2 };
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 1, browser_menu_item2, false));
 }
 
 // Check the multi profile case where only user related apps should show up.
-TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+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);
@@ skipping 39 matching lines @@
       browser()->window()->GetNativeWindow(), account_id2);
 
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 0, NULL, true));
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_gmail, 0, NULL, false));
 }
 
 // Check that V2 applications are creating items properly in the launcher when
 // instantiated by the current user.
-TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+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(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   // Check that there is a browser and a app launcher.
   EXPECT_EQ(2, model_->item_count());
 
   // Add a v2 app.
   V2App v2_app(profile(), extension1_.get());
   EXPECT_EQ(3, model_->item_count());
 
   // After switching users the item should go away.
   SwitchActiveUser(account_id2);
   EXPECT_EQ(2, model_->item_count());
 
   // And it should come back when switching back.
   SwitchActiveUser(account_id);
   EXPECT_EQ(3, model_->item_count());
 }
 
 // Check that V2 applications are creating items properly in edge cases:
 // a background user creates a V2 app, gets active and inactive again and then
 // deletes the app.
-TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V2AppHandlingTwoUsersEdgeCases) {
   InitLauncherController();
   // Create a profile for our second user (will be destroyed by the framework).
   TestingProfile* profile2 = CreateMultiUserProfile("user2");
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   // Check that there is a browser and a app launcher.
   EXPECT_EQ(2, model_->item_count());
@@ skipping 22 matching lines @@
   EXPECT_EQ(2, model_->item_count());
 
   // Switching then back to the default user should not show the additional item
   // anymore.
   SwitchActiveUser(account_id);
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check that V2 applications will be made visible on the target desktop if
 // another window of the same type got previously teleported there.
-TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V2AppFollowsTeleportedWindow) {
   InitLauncherController();
   chrome::MultiUserWindowManager* manager =
       chrome::MultiUserWindowManager::GetInstance();
 
   // Create and add three users / profiles, and go to #1's desktop.
   TestingProfile* profile1 = CreateMultiUserProfile("user-1");
   TestingProfile* profile2 = CreateMultiUserProfile("user-2");
   TestingProfile* profile3 = CreateMultiUserProfile("user-3");
   const AccountId account_id1(
@@ skipping 50 matching lines @@
   SwitchActiveUser(account_id2);
   v2_app_1.window()->Hide();
   V2App v2_app_6(profile1, extension1_.get());
   EXPECT_FALSE(v2_app_1.window()->GetNativeWindow()->IsVisible());
   EXPECT_FALSE(v2_app_2.window()->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(v2_app_6.window()->GetNativeWindow()->IsVisible());
 }
 
 // Check that V2 applications hide correctly on the shelf when the app window
 // is hidden.
-TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        V2AppHiddenWindows) {
   InitLauncherController();
 
   TestingProfile* profile2 = CreateMultiUserProfile("user-2");
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   SwitchActiveUser(account_id);
   EXPECT_EQ(2, model_->item_count());
@@ skipping 47 matching lines @@
     v2_app_2.window()->Show(extensions::AppWindow::SHOW_ACTIVE);
     EXPECT_EQ(3, model_->item_count());
 
     v2_app_1.window()->Hide();
     v2_app_2.window()->Hide();
     EXPECT_EQ(2, model_->item_count());
   }
 }
 
 // Checks that the generated menu list properly activates items.
-TEST_F(ChromeLauncherControllerTest, V1AppMenuExecution) {
+TEST_F(ChromeLauncherControllerImplTest, V1AppMenuExecution) {
   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());
@@ skipping 30 matching lines @@
             launcher_controller_->GetApplicationList(item_gmail, 0)));
     int first_item =
         (menu->GetTypeAt(0) == ui::MenuModel::TYPE_SEPARATOR) ? 1 : 0;
     menu->ActivatedAt(first_item + 2);
   }
   // Now the active tab should be the second item.
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
 }
 
 // Checks that the generated menu list properly deletes items.
-TEST_F(ChromeLauncherControllerTest, V1AppMenuDeletionExecution) {
+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());
@@ skipping 20 matching lines @@
   // Delete one tab through the menu item.
   {
     ChromeLauncherAppMenuItems items =
         launcher_controller_->GetApplicationList(item_gmail, 0);
     items[1]->Execute(ui::EF_SHIFT_DOWN);
     EXPECT_EQ(--tabs, browser()->tab_strip_model()->count());
   }
 }
 
 // Tests that panels create launcher items correctly
-TEST_F(ChromeLauncherControllerTest, AppPanels) {
+TEST_F(ChromeLauncherControllerImplTest, AppPanels) {
   InitLauncherControllerWithBrowser();
   // App list and Browser shortcut ShelfItems are added.
   EXPECT_EQ(2, model_observer_->added());
   EXPECT_EQ(1, model_observer_->changed());
 
   const std::string app_id = extension1_->id();
-  // app_icon_loader is owned by ChromeLauncherController.
+  // app_icon_loader is owned by ChromeLauncherControllerImpl.
   TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl();
   app_icon_loader->AddSupportedApp(app_id);
   SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
 
   // Test adding an app panel
   AppWindowLauncherItemController* app_panel_controller =
       new ExtensionAppWindowLauncherItemController(
           LauncherItemController::TYPE_APP_PANEL, "id", app_id,
           launcher_controller_.get());
   ash::ShelfID shelf_id1 = launcher_controller_->CreateAppLauncherItem(
@@ skipping 27 matching lines @@
   EXPECT_EQ(1, model_observer_->added());
   model_observer_->clear_counts();
 
   launcher_controller_->CloseLauncherItem(shelf_id2);
   launcher_controller_->CloseLauncherItem(shelf_id1);
   EXPECT_EQ(2, model_observer_->removed());
 }
 
 // Tests that the Gmail extension matches more then the app itself claims with
 // the manifest file.
-TEST_F(ChromeLauncherControllerTest, GmailMatching) {
+TEST_F(ChromeLauncherControllerImplTest, GmailMatching) {
   InitLauncherControllerWithBrowser();
 
   // Create a Gmail browser tab.
   chrome::NewTab(browser());
   base::string16 title = ASCIIToUTF16("Test");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title);
   content::WebContents* content =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   // Check that the launcher controller does not recognize the running app.
@@ skipping 11 matching lines @@
   EXPECT_TRUE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
 
   // Check also that the app has detected that properly.
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_APP_SHORTCUT;
   item_gmail.id = gmail_id;
   EXPECT_EQ(2U, launcher_controller_->GetApplicationList(item_gmail, 0).size());
 }
 
 // Tests that the Gmail extension does not match the offline verison.
-TEST_F(ChromeLauncherControllerTest, GmailOfflineMatching) {
+TEST_F(ChromeLauncherControllerImplTest, GmailOfflineMatching) {
   InitLauncherControllerWithBrowser();
 
   // Create a Gmail browser tab.
   chrome::NewTab(browser());
   base::string16 title = ASCIIToUTF16("Test");
   NavigateAndCommitActiveTabWithTitle(browser(),
                                       GURL(offline_gmail_url),
                                       title);
   content::WebContents* content =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   // 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_APP_SHORTCUT, model_->items()[gmail_index].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // The content should not be able to be handled by the app.
   EXPECT_FALSE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
 }
 
 // Verify that the launcher item positions are persisted and restored.
-TEST_F(ChromeLauncherControllerTest, PersistLauncherItemPositions) {
+TEST_F(ChromeLauncherControllerImplTest, PersistLauncherItemPositions) {
   InitLauncherController();
 
   TestLauncherControllerHelper* helper = new TestLauncherControllerHelper;
   SetLauncherControllerHelper(helper);
 
   EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[1].type);
 
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   EXPECT_EQ(0, tab_strip_model->count());
@@ skipping 26 matching lines @@
     delete item_delegate_manager_;
   } else {
     // Clear already registered ShelfItemDelegate.
     ash::test::ShelfItemDelegateManagerTestAPI test(item_delegate_manager_);
     test.RemoveAllShelfItemDelegateForTest();
   }
   model_.reset(new ash::ShelfModel);
 
   AddAppListLauncherItem();
   launcher_controller_.reset(
-      ChromeLauncherController::CreateInstance(profile(), model_.get()));
+      ChromeLauncherControllerImpl::CreateInstance(profile(), model_.get()));
   helper = new TestLauncherControllerHelper;
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   helper->SetAppID(tab_strip_model->GetWebContentsAt(1), "2");
   SetLauncherControllerHelper(helper);
   if (!ash::Shell::HasInstance()) {
     item_delegate_manager_ = new ash::ShelfItemDelegateManager(model_.get());
     SetShelfItemDelegateManager(item_delegate_manager_);
   }
   launcher_controller_->Init();
 
-  // Check ShelfItems are restored after resetting ChromeLauncherController.
+  // 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);
   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[3].type);
 }
 
 // Verifies pinned apps are persisted and restored.
-TEST_F(ChromeLauncherControllerTest, PersistPinned) {
+TEST_F(ChromeLauncherControllerImplTest, PersistPinned) {
   InitLauncherControllerWithBrowser();
   size_t initial_size = model_->items().size();
 
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   EXPECT_EQ(1, tab_strip_model->count());
 
   TestLauncherControllerHelper* helper = new TestLauncherControllerHelper;
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   SetLauncherControllerHelper(helper);
 
-  // app_icon_loader is owned by ChromeLauncherController.
+  // app_icon_loader is owned by ChromeLauncherControllerImpl.
   TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl;
   app_icon_loader->AddSupportedApp("1");
   SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
   EXPECT_EQ(0, app_icon_loader->fetch_count());
 
   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_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());
 
   SetShelfItemDelegateManager(nullptr);
   launcher_controller_.reset();
   if (!ash::Shell::HasInstance()) {
     delete item_delegate_manager_;
   } else {
     // Clear already registered ShelfItemDelegate.
     ash::test::ShelfItemDelegateManagerTestAPI test(item_delegate_manager_);
     test.RemoveAllShelfItemDelegateForTest();
   }
   model_.reset(new ash::ShelfModel);
 
   AddAppListLauncherItem();
   launcher_controller_.reset(
-      ChromeLauncherController::CreateInstance(profile(), model_.get()));
+      ChromeLauncherControllerImpl::CreateInstance(profile(), model_.get()));
   helper = new TestLauncherControllerHelper;
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   SetLauncherControllerHelper(helper);
-  // app_icon_loader is owned by ChromeLauncherController.
+  // 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));
   if (!ash::Shell::HasInstance()) {
     item_delegate_manager_ = new ash::ShelfItemDelegateManager(model_.get());
     SetShelfItemDelegateManager(item_delegate_manager_);
   }
   launcher_controller_->Init();
 
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   ASSERT_EQ(initial_size + 1, model_->items().size());
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[app_index].type);
 
   launcher_controller_->UnpinAppWithID("1");
   ASSERT_EQ(initial_size, model_->items().size());
 }
 
-TEST_F(ChromeLauncherControllerTest, MultipleAppIconLoaders) {
+TEST_F(ChromeLauncherControllerImplTest, MultipleAppIconLoaders) {
   InitLauncherControllerWithBrowser();
 
   const std::string app_id1 = extension1_->id();
   const std::string app_id2 = extension2_->id();
   const std::string app_id3 = extension3_->id();
   // app_icon_loader1 and app_icon_loader2 are owned by
-  // ChromeLauncherController.
+  // 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_panel_controller3 =
       new ExtensionAppWindowLauncherItemController(
           LauncherItemController::TYPE_APP_PANEL, "id", app_id3,
@@ skipping 41 matching lines @@
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(1, app_icon_loader2->clear_count());
 
   launcher_controller_->CloseLauncherItem(shelfId3);
   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(1, app_icon_loader2->clear_count());
 }
 
-TEST_F(ChromeLauncherControllerTest, ArcAppPinPolicy) {
+TEST_F(ChromeLauncherControllerImplTest, ArcAppPinPolicy) {
   arc_test_.SetUp(profile());
   InitLauncherControllerWithBrowser();
 
   arc::mojom::AppInfo appinfo;
   appinfo.name = "Some App";
   appinfo.activity = "SomeActivity";
   appinfo.package_name = "com.example.app";
 
   ArcAppListPrefs* const prefs = arc_test_.arc_app_list_prefs();
   ASSERT_TRUE(prefs);
 
   // Adding app to the prefs, and check that the app is accessible by id.
   prefs->AddApp(appinfo);
   const std::string app_id =
       ArcAppListPrefs::GetAppId(appinfo.package_name, appinfo.activity);
   EXPECT_TRUE(prefs->GetApp(app_id));
 
   // Set policy, that makes pins ARC app. Unlike native extension, for ARC app
   // package_name (not hash) specified as id. In this test we check that
   // by hash we can determine that appropriate package was set by policy.
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, appinfo.package_name);
   profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kPolicyPinnedLauncherApps, policy_value.DeepCopy());
 
   EXPECT_TRUE(launcher_controller_->IsAppPinned(app_id));
   EXPECT_EQ(AppListControllerDelegate::PIN_FIXED,
             launcher_controller_->GetPinnable(app_id));
 }