mash: Merge ChromeLauncherController and *Impl subclass.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 205 matching lines @@
     tab_id_map_[tab] = id;
   }
 
   // Returns true if there is an id registered for |tab|.
   bool HasAppID(content::WebContents* tab) const {
     return tab_id_map_.find(tab) != tab_id_map_.end();
   }
 
   // LauncherControllerHelper:
   std::string GetAppID(content::WebContents* tab) override {
-    return tab_id_map_.find(tab) != tab_id_map_.end() ? tab_id_map_[tab] :
-        std::string();
+    return tab_id_map_.find(tab) != tab_id_map_.end() ? tab_id_map_[tab]
+                                                      : std::string();
   }
 
   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;
   }
@@ skipping 90 matching lines @@
 void SelectItem(ash::ShelfItemDelegate* delegate) {
   std::unique_ptr<ui::Event> event = base::MakeUnique<ui::MouseEvent>(
       ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), ui::EventTimeForNow(),
       ui::EF_NONE, 0);
   delegate->ItemSelected(std::move(event), display::kInvalidDisplayId,
                          ash::LAUNCH_FROM_UNKNOWN, base::Bind(&NoopCallback));
 }
 
 }  // namespace
 
-// A test ChromeLauncherControllerImpl subclass that uses TestShelfController.
-class TestChromeLauncherControllerImpl : public ChromeLauncherControllerImpl {
+// A test ChromeLauncherController subclass that uses TestShelfController.
+class TestChromeLauncherController : public ChromeLauncherController {
  public:
-  TestChromeLauncherControllerImpl(Profile* profile, ash::ShelfModel* model)
-      : ChromeLauncherControllerImpl(profile, model) {}
+  TestChromeLauncherController(Profile* profile, ash::ShelfModel* model)
+      : ChromeLauncherController(profile, model) {}
 
-  // ChromeLauncherControllerImpl:
-  using ChromeLauncherControllerImpl::ReleaseProfile;
+  // ChromeLauncherController:
+  using ChromeLauncherController::AttachProfile;
+  using ChromeLauncherController::ReleaseProfile;
   bool ConnectToShelfController() override {
     // Set the shelf controller pointer to a test instance; this is run in init.
     if (!shelf_controller_.is_bound())
       shelf_controller_ = test_shelf_controller_.CreateInterfacePtrAndBind();
     return true;
   }
 
   TestShelfController* test_shelf_controller() {
     return &test_shelf_controller_;
   }
 
  private:
   TestShelfController test_shelf_controller_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestChromeLauncherControllerImpl);
+  DISALLOW_COPY_AND_ASSIGN(TestChromeLauncherController);
 };
 
 // A shell delegate that owns a ChromeLauncherController, like production.
-// TODO(msw): Refine ChromeLauncherControllerImpl lifetime management.
+// TODO(msw): Refine ChromeLauncherController lifetime management.
 // TODO(msw): Avoid relying on TestShellDelegate's ShelfInitializer.
 class ChromeLauncherTestShellDelegate : public ash::test::TestShellDelegate {
  public:
   ChromeLauncherTestShellDelegate() {}
 
-  // Create a ChromeLauncherControllerImpl instance.
-  ChromeLauncherControllerImpl* CreateLauncherController(Profile* profile) {
-    launcher_controller_ = base::MakeUnique<ChromeLauncherControllerImpl>(
+  // Create a ChromeLauncherController instance.
+  ChromeLauncherController* CreateLauncherController(Profile* profile) {
+    launcher_controller_ = base::MakeUnique<ChromeLauncherController>(
         profile, ash::Shell::Get()->shelf_model());
     return launcher_controller_.get();
   }
 
-  // Create a TestChromeLauncherControllerImpl instance.
-  TestChromeLauncherControllerImpl* CreateTestLauncherController(
-      Profile* profile) {
-    auto controller = base::MakeUnique<TestChromeLauncherControllerImpl>(
+  // Create a TestChromeLauncherController instance.
+  TestChromeLauncherController* CreateTestLauncherController(Profile* profile) {
+    auto controller = base::MakeUnique<TestChromeLauncherController>(
         profile, ash::Shell::Get()->shelf_model());
-    TestChromeLauncherControllerImpl* controller_weak = controller.get();
+    TestChromeLauncherController* controller_weak = controller.get();
     launcher_controller_ = std::move(controller);
     launcher_controller_->Init();
     return controller_weak;
   }
 
   // ash::test::TestShellDelegate:
   void ShelfShutdown() override { launcher_controller_.reset(); }
 
  private:
-  std::unique_ptr<ChromeLauncherControllerImpl> launcher_controller_;
+  std::unique_ptr<ChromeLauncherController> launcher_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherTestShellDelegate);
 };
 
-class ChromeLauncherControllerImplTest : public BrowserWithTestWindowTest {
+class ChromeLauncherControllerTest : public BrowserWithTestWindowTest {
  protected:
-  ChromeLauncherControllerImplTest()
+  ChromeLauncherControllerTest()
       : BrowserWithTestWindowTest(Browser::TYPE_TABBED, false) {}
 
-  ~ChromeLauncherControllerImplTest() override {}
+  ~ChromeLauncherControllerTest() override {}
 
   void SetUp() override {
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     command_line->AppendSwitch(switches::kUseFirstDisplayAsInternal);
 
     app_list::AppListSyncableServiceFactory::SetUseInTesting();
 
     shell_delegate_ = new ChromeLauncherTestShellDelegate();
     ash_test_helper()->set_test_shell_delegate(shell_delegate_);
 
@@ skipping 177 matching lines @@
   }
 
   void AddAppListLauncherItem() {
     ash::ShelfItem app_list;
     app_list.type = ash::TYPE_APP_LIST;
     model_->Add(app_list);
   }
 
   // Create a launcher controller instance, owned by the test shell delegate.
   // Returns a pointer to the uninitialized controller.
-  ChromeLauncherControllerImpl* CreateLauncherController() {
+  ChromeLauncherController* CreateLauncherController() {
     launcher_controller_ = shell_delegate_->CreateLauncherController(profile());
     return launcher_controller_;
   }
 
   // Create and initialize the controller, owned by the test shell delegate.
   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();
   }
 
   // Destroy the launcher controller instance and clear the local pointer.
   void ResetLauncherController() {
     launcher_controller_ = nullptr;
     shell_delegate_->ShelfShutdown();
   }
 
   // Destroy and recreate the controller; clear and reinitialize the ShelfModel.
   // Returns a pointer to the uninitialized controller, owned by shell delegate.
-  // TODO(msw): This does not accurately represent ChromeLauncherControllerImpl
+  // TODO(msw): This does not accurately represent ChromeLauncherController
   // lifetime or usage in production, and does not accurately simulate restarts.
-  ChromeLauncherControllerImpl* RecreateLauncherController() {
+  ChromeLauncherController* RecreateLauncherController() {
     // Destroy any existing controller first; only one may exist at a time.
     ResetLauncherController();
     while (model_->item_count() > 0)
       model_->RemoveItemAt(0);
     AddAppListLauncherItem();
     return CreateLauncherController();
   }
 
   void StartAppSyncService(const syncer::SyncDataList& init_sync_list) {
     app_service_->MergeDataAndStartSyncing(
@@ skipping 174 matching lines @@
     app_list_specifics->set_item_type(sync_pb::AppListSpecifics::TYPE_APP);
     app_list_specifics->set_item_pin_ordinal(chrome_position.ToInternalValue());
     syncer::SyncData sync_data = syncer::SyncData::CreateLocalData(
         extension_misc::kChromeAppId, "Test", specifics);
     sync_list.push_back(syncer::SyncChange(
         FROM_HERE, syncer::SyncChange::ACTION_UPDATE, sync_data));
     app_service_->ProcessSyncChanges(FROM_HERE, sync_list);
   }
 
   // Gets the IDs of the currently pinned app items.
-  void GetPinnedAppIds(ChromeLauncherControllerImpl* controller,
+  void GetPinnedAppIds(ChromeLauncherController* controller,
                        std::vector<std::string>* app_ids) {
     app_ids->clear();
     for (const auto& item : model_->items()) {
       if (item.type == ash::TYPE_PINNED_APP)
         app_ids->push_back(item.app_launch_id.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
@@ skipping 203 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;
-  ChromeLauncherControllerImpl* launcher_controller_ = nullptr;
+  ChromeLauncherController* launcher_controller_ = nullptr;
   ChromeLauncherTestShellDelegate* shell_delegate_ = 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;
 
  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(ChromeLauncherControllerImplTest);
+  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerTest);
 };
 
-class ChromeLauncherControllerImplWithArcTest
-    : public ChromeLauncherControllerImplTest,
+class ChromeLauncherControllerWithArcTest
+    : public ChromeLauncherControllerTest,
       public ::testing::WithParamInterface<bool> {
  protected:
-  ChromeLauncherControllerImplWithArcTest() { auto_start_arc_test_ = true; }
-  ~ChromeLauncherControllerImplWithArcTest() override {}
+  ChromeLauncherControllerWithArcTest() { auto_start_arc_test_ = true; }
+  ~ChromeLauncherControllerWithArcTest() override {}
 
   void SetUp() override {
     if (GetParam())
       arc::SetArcAlwaysStartForTesting();
-    ChromeLauncherControllerImplTest::SetUp();
+    ChromeLauncherControllerTest::SetUp();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerImplWithArcTest);
+  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerWithArcTest);
 };
 
 INSTANTIATE_TEST_CASE_P(,
-                        ChromeLauncherControllerImplWithArcTest,
+                        ChromeLauncherControllerWithArcTest,
                         ::testing::Bool());
 
 // 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);
   }
   ~WebContentsDestroyedWatcher() override {}
 
   // Waits until the WebContents is destroyed.
-  void Wait() {
-    message_loop_runner_->Run();
-  }
+  void Wait() { message_loop_runner_->Run(); }
 
  private:
   // Overridden WebContentsObserver methods.
   void WebContentsDestroyed() override { message_loop_runner_->Quit(); }
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsDestroyedWatcher);
 };
 
@@ skipping 60 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 MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest
-    : public ChromeLauncherControllerImplTest {
+class MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest
+    : public ChromeLauncherControllerTest {
  protected:
-  MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest() {}
+  MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() {}
 
-  ~MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest()
-      override {}
+  ~MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() 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.
-    ChromeLauncherControllerImplTest::SetUp();
+    ChromeLauncherControllerTest::SetUp();
     shell_delegate_->set_multi_profiles_enabled(true);
   }
 
   void TearDown() override {
-    ChromeLauncherControllerImplTest::TearDown();
+    ChromeLauncherControllerTest::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::RunLoop().RunUntilIdle();
   }
@@ skipping 85 matching lines @@
   chromeos::FakeChromeUserManager* GetFakeUserManager() {
     return static_cast<chromeos::FakeChromeUserManager*>(
         user_manager::UserManager::Get());
   }
 
   std::unique_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
 
   ProfileToNameMap created_profiles_;
 
   DISALLOW_COPY_AND_ASSIGN(
-      MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest);
+      MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest);
 };
 
-class ChromeLauncherControllerImplMultiProfileWithArcTest
-    : public MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,  // NOLINT(whitespace/line_length)
+class ChromeLauncherControllerMultiProfileWithArcTest
+    : public MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
       public ::testing::WithParamInterface<bool> {
  protected:
-  ChromeLauncherControllerImplMultiProfileWithArcTest() {
+  ChromeLauncherControllerMultiProfileWithArcTest() {
     auto_start_arc_test_ = true;
   }
-  ~ChromeLauncherControllerImplMultiProfileWithArcTest() override {}
+  ~ChromeLauncherControllerMultiProfileWithArcTest() override {}
 
   void SetUp() override {
     if (GetParam())
       arc::SetArcAlwaysStartForTesting();
-    MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest::
-        SetUp();
+    MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest::SetUp();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerImplMultiProfileWithArcTest);
+  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerMultiProfileWithArcTest);
 };
 
 INSTANTIATE_TEST_CASE_P(,
-                        ChromeLauncherControllerImplMultiProfileWithArcTest,
+                        ChromeLauncherControllerMultiProfileWithArcTest,
                         ::testing::Bool());
 
-TEST_F(ChromeLauncherControllerImplTest, DefaultApps) {
+TEST_F(ChromeLauncherControllerTest, DefaultApps) {
   InitLauncherController();
   // The 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_P(ChromeLauncherControllerImplWithArcTest,
-       ArcAppPinCrossPlatformWorkflow) {
+TEST_P(ChromeLauncherControllerWithArcTest, ArcAppPinCrossPlatformWorkflow) {
   // Work on ARC disabled platform first.
   const std::string arc_app_id1 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   const std::string arc_app_id2 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[1]);
   const std::string arc_app_id3 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[2]);
 
   InitLauncherController();
 
@@ skipping 89 matching lines @@
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id1));
   EXPECT_FALSE(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, Fake App 1, App3, Chrome, App1, Fake App 0",
             GetPinnedAppStatus());
 }
 
-/*
- * Test ChromeLauncherControllerImpl correctly merges policy pinned apps
- * and user pinned apps
- */
-TEST_F(ChromeLauncherControllerImplTest, MergePolicyAndUserPrefPinnedApps) {
+// Ensure correct merging of policy pinned apps and user pinned apps.
+TEST_F(ChromeLauncherControllerTest, MergePolicyAndUserPrefPinnedApps) {
   InitLauncherController();
 
   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
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 0, extension1_->id());
   InsertAddPinChange(&sync_list, 1, extension_misc::kChromeAppId);
@@ skipping 26 matching lines @@
   EXPECT_EQ(AppListControllerDelegate::PIN_FIXED,
             GetPinnableForAppID(extension4_->id(), profile()));
 
   // 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(ChromeLauncherControllerImplTest, RestoreDefaultAppsReverseOrder) {
+TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsReverseOrder) {
   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);
 
   // The model should only contain the browser shortcut and app list items.
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
@@ skipping 17 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(ChromeLauncherControllerImplTest, RestoreDefaultAppsRandomOrder) {
+TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsRandomOrder) {
   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);
 
   // The model should only contain the browser shortcut and app list items.
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
@@ skipping 16 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(ChromeLauncherControllerImplTest,
-       RestoreDefaultAppsRandomOrderChromeMoved) {
+TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsRandomOrderChromeMoved) {
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 0, extension1_->id());
   InsertAddPinChange(&sync_list, 1, extension_misc::kChromeAppId);
   InsertAddPinChange(&sync_list, 2, extension2_->id());
   InsertAddPinChange(&sync_list, 3, extension3_->id());
   SendPinChanges(sync_list, true);
 
   // The 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(ChromeLauncherControllerImplTest, RestoreDefaultAppsResyncOrder) {
+TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsResyncOrder) {
   InitLauncherController();
 
   syncer::SyncChangeList sync_list0;
   InsertAddPinChange(&sync_list0, 0, extension1_->id());
   InsertAddPinChange(&sync_list0, 1, extension2_->id());
   InsertAddPinChange(&sync_list0, 2, extension3_->id());
   SendPinChanges(sync_list0, true);
 
   // The shelf layout has always one static item at the beginning (App List).
   extension_service_->AddExtension(extension2_.get());
@@ skipping 37 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());
 }
 
 // Test the V1 app interaction flow: run it, activate it, close it.
-TEST_F(ChromeLauncherControllerImplTest, V1AppRunActivateClose) {
+TEST_F(ChromeLauncherControllerTest, V1AppRunActivateClose) {
   InitLauncherController();
   // The 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_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   // Reporting that the app is running should create a new shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
   EXPECT_EQ(3, model_->item_count());
@@ skipping 14 matching lines @@
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   // Reporting that the app is closed again should have no effect.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Test the V1 app interaction flow: pin it, run it, close it, unpin it.
-TEST_F(ChromeLauncherControllerImplTest, V1AppPinRunCloseUnpin) {
+TEST_F(ChromeLauncherControllerTest, V1AppPinRunCloseUnpin) {
   InitLauncherController();
   // The 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_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   // Pinning the app should create a new shelf item.
   launcher_controller_->PinAppWithID(extension1_->id());
   EXPECT_EQ(3, model_->item_count());
@@ skipping 23 matching lines @@
 
   // Unpinning the app should remove its shelf item.
   launcher_controller_->UnpinAppWithID(extension1_->id());
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 }
 
 // Test the V1 app interaction flow: run it, pin it, close it, unpin it.
-TEST_F(ChromeLauncherControllerImplTest, V1AppRunPinCloseUnpin) {
+TEST_F(ChromeLauncherControllerTest, V1AppRunPinCloseUnpin) {
   InitLauncherController();
   // The 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_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   // Reporting that the app is running should create a new shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
   EXPECT_EQ(3, model_->item_count());
@@ skipping 23 matching lines @@
 
   // Unpinning the app should remove its shelf item.
   launcher_controller_->UnpinAppWithID(extension1_->id());
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 }
 
 // Test the V1 app interaction flow: pin it, run it, unpin it, close it.
-TEST_F(ChromeLauncherControllerImplTest, V1AppPinRunUnpinClose) {
+TEST_F(ChromeLauncherControllerTest, V1AppPinRunUnpinClose) {
   InitLauncherController();
   // The 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_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 
   // Pinning the app should create a new shelf item.
   launcher_controller_->PinAppWithID(extension1_->id());
   EXPECT_EQ(3, model_->item_count());
@@ skipping 23 matching lines @@
 
   // Reporting that the app is closed should remove its shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(extension1_->id()));
 }
 
 // Ensure unpinned V1 app ordering is properly restored after user changes.
-TEST_F(ChromeLauncherControllerImplTest, CheckRunningV1AppOrder) {
+TEST_F(ChromeLauncherControllerTest, CheckRunningV1AppOrder) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
 
   // Add a few running applications.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
   launcher_controller_->SetV1AppStatus(extension2_->id(), ash::STATUS_RUNNING);
   launcher_controller_->SetV1AppStatus(extension3_->id(), ash::STATUS_RUNNING);
   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_->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) {
+TEST_P(ChromeLauncherControllerWithArcTest, ArcDeferredLaunch) {
   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 @@
       arc_test_.app_instance()->launch_requests()[1].get();
 
   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) {
+TEST_P(ChromeLauncherControllerWithArcTest, ArcDeferredLaunchForActiveApp) {
   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 =
@@ skipping 25 matching lines @@
   item_index = model_->ItemIndexByID(shelf_id);
   ASSERT_GE(item_index, 0);
   EXPECT_EQ(model_->items()[item_index].status, ash::STATUS_CLOSED);
   EXPECT_EQ(model_->items()[item_index].type, ash::TYPE_PINNED_APP);
 
   // Now launch request should not be ignored.
   arc::LaunchApp(profile(), app_id, ui::EF_LEFT_MOUSE_BUTTON);
   EXPECT_TRUE(launcher_controller_->GetArcDeferredLauncher()->HasApp(app_id));
 }
 
-TEST_P(ChromeLauncherControllerImplMultiProfileWithArcTest, ArcMultiUser) {
+TEST_P(ChromeLauncherControllerMultiProfileWithArcTest, ArcMultiUser) {
   SendListOfArcApps();
 
   InitLauncherController();
   // TODO(crbug.com/654622): This test breaks with a non-null static instance.
-  ChromeLauncherControllerImpl::set_instance_for_test(nullptr);
+  ChromeLauncherController::set_instance_for_test(nullptr);
 
   SetLauncherControllerHelper(new TestLauncherControllerHelper);
 
   // App1 exists all the time.
   // App2 is created when primary user is active and destroyed when secondary
   // user is active.
   // App3 created when secondary user is active.
 
   const std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
@@ skipping 49 matching lines @@
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(arc_app_id2));
   EXPECT_NE(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(arc_app_id3));
 
   // Close active window to let test passes.
   arc_window1->CloseNow();
   arc_window3->CloseNow();
 }
 
-TEST_P(ChromeLauncherControllerImplWithArcTest, ArcRunningApp) {
+TEST_P(ChromeLauncherControllerWithArcTest, ArcRunningApp) {
   InitLauncherController();
 
   const std::string arc_app_id = ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   SendListOfArcApps();
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(arc_app_id));
 
   // Normal flow, create/destroy tasks.
   std::string window_app_id1("org.chromium.arc.1");
   std::string window_app_id2("org.chromium.arc.2");
@@ skipping 22 matching lines @@
   EXPECT_NE(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(arc_app_id));
   arc_test_.StopArcInstance();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(arc_app_id));
 }
 
 // Test race creation/deletion of ARC app.
 // TODO(khmel): Remove after moving everything to wayland protocol.
-TEST_P(ChromeLauncherControllerImplWithArcTest, ArcRaceCreateClose) {
+TEST_P(ChromeLauncherControllerWithArcTest, ArcRaceCreateClose) {
   InitLauncherController();
 
   const std::string arc_app_id1 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   const std::string arc_app_id2 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[1]);
   SendListOfArcApps();
 
   // ARC window created before and closed after mojom notification.
   std::string window_app_id1("org.chromium.arc.1");
@@ skipping 26 matching lines @@
   arc_window->Close();
   base::RunLoop().RunUntilIdle();
   // Closing window does not close shelf item. It is closed on task destroy.
   EXPECT_NE(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(arc_app_id2));
   arc_test_.app_instance()->SendTaskDestroyed(2);
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(arc_app_id2));
 }
 
-TEST_P(ChromeLauncherControllerImplWithArcTest, ArcWindowRecreation) {
+TEST_P(ChromeLauncherControllerWithArcTest, ArcWindowRecreation) {
   InitLauncherController();
 
   const std::string arc_app_id = ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   SendListOfArcApps();
 
   std::string window_app_id("org.chromium.arc.1");
   views::Widget* arc_window = CreateArcWindow(window_app_id);
   ASSERT_TRUE(arc_window);
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0],
                                             std::string());
   const ash::ShelfID shelf_id =
       launcher_controller_->GetShelfIDForAppID(arc_app_id);
   EXPECT_NE(ash::kInvalidShelfID, shelf_id);
 
   for (int i = 0; i < 3; ++i) {
     arc_window->Close();
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(shelf_id, launcher_controller_->GetShelfIDForAppID(arc_app_id));
 
     arc_window = CreateArcWindow(window_app_id);
     ASSERT_TRUE(arc_window);
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(shelf_id, launcher_controller_->GetShelfIDForAppID(arc_app_id));
   }
 }
 
 // Validate that ARC app is pinned correctly and pin is removed automatically
 // once app is uninstalled.
-TEST_P(ChromeLauncherControllerImplWithArcTest, ArcAppPin) {
+TEST_P(ChromeLauncherControllerWithArcTest, ArcAppPin) {
   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()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(arc_app_id));
@@ skipping 24 matching lines @@
   EXPECT_EQ("AppList, Chrome, App1, App2, Fake App 0", GetPinnedAppStatus());
   EnablePlayStore(false);
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
   EnablePlayStore(true);
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
   SendListOfArcApps();
   EXPECT_EQ("AppList, Chrome, App1, App2, Fake App 0", GetPinnedAppStatus());
 }
 
 // Validates that ARC app pins persist across OptOut/OptIn.
-TEST_P(ChromeLauncherControllerImplWithArcTest, ArcAppPinOptOutOptIn) {
+TEST_P(ChromeLauncherControllerWithArcTest, ArcAppPinOptOutOptIn) {
   InitLauncherController();
 
   const std::string arc_app_id1 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   const std::string arc_app_id2 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[1]);
 
   SendListOfArcApps();
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension2_.get());
@@ skipping 29 matching lines @@
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id1));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc_app_id2));
 
   EXPECT_EQ("AppList, Chrome, App1, Fake App 1, App2, Fake App 0",
             GetPinnedAppStatus());
 }
 
 // Check that with multi profile V1 apps are properly added / removed from the
 // shelf.
-TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        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());
@@ skipping 10 matching lines @@
 
     // 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(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        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(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        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(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V1AppUpdateOnUserSwitchEdgecases2) {
   // 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_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
@@ skipping 17 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(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        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 @@
   // 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 a running windowed V1 application will be properly pinned and
 // unpinned when the order gets changed through a profile / policy change.
-TEST_F(ChromeLauncherControllerImplTest,
+TEST_F(ChromeLauncherControllerTest,
        RestoreDefaultAndRunningV1AppsResyncOrder) {
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 0, extension1_->id());
   InsertAddPinChange(&sync_list, 1, extension3_->id());
   SendPinChanges(sync_list, true);
 
   // The shelf layout has always one static item at the beginning (App List).
   extension_service_->AddExtension(extension1_.get());
@@ skipping 25 matching lines @@
   SendPinChanges(sync_list2, true);
   EXPECT_EQ("AppList, Chrome, App3, App1, app2", GetPinnedAppStatus());
 
   // Removing an item should simply close it and everything should shift.
   SendPinChanges(syncer::SyncChangeList(), true);
   EXPECT_EQ("AppList, Chrome, App3, app2", GetPinnedAppStatus());
 }
 
 // Check that a running unpinned V2 application will be properly pinned and
 // unpinned when the order gets changed through a profile / policy change.
-TEST_F(ChromeLauncherControllerImplTest,
+TEST_F(ChromeLauncherControllerTest,
        RestoreDefaultAndRunningV2AppsResyncOrder) {
   InitLauncherController();
   syncer::SyncChangeList sync_list0;
   InsertAddPinChange(&sync_list0, 0, extension1_->id());
   InsertAddPinChange(&sync_list0, 1, extension3_->id());
   SendPinChanges(sync_list0, true);
   // The shelf layout has always one static item at the beginning (app List).
   extension_service_->AddExtension(extension1_.get());
   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
   extension_service_->AddExtension(extension_platform_app_.get());
@@ skipping 24 matching lines @@
 
   // Removing an item should simply close it and everything should shift.
   syncer::SyncChangeList sync_list3;
   InsertAddPinChange(&sync_list3, 0, extension3_->id());
   SendPinChanges(sync_list3, true);
   EXPECT_EQ("AppList, Chrome, App3, *platform_app", 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(ChromeLauncherControllerImplTest, UserSwitchIconRestore) {
+TEST_F(ChromeLauncherControllerTest, UserSwitchIconRestore) {
   syncer::SyncChangeList user_a;
   syncer::SyncChangeList user_b;
 
   SetUpMultiUserScenario(&user_a, &user_b);
 
   // Show user 1.
   SendPinChanges(user_a, true);
   EXPECT_EQ("AppList, App1, App2, App3, *Platform_App, App4, App5, Chrome",
             GetPinnedAppStatus());
 
   // Show user 2.
   SendPinChanges(user_b, true);
   EXPECT_EQ("AppList, App6, App7, App8, Chrome", GetPinnedAppStatus());
 
   // Switch back to 1.
   SendPinChanges(user_a, true);
   EXPECT_EQ("AppList, App1, App2, App3, *Platform_App, App4, App5, Chrome",
             GetPinnedAppStatus());
 
   // Switch back to 2.
   SendPinChanges(user_b, true);
   EXPECT_EQ("AppList, App6, 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(ChromeLauncherControllerImplTest,
-       UserSwitchIconRestoreWithRunningV2App) {
+TEST_F(ChromeLauncherControllerTest, UserSwitchIconRestoreWithRunningV2App) {
   syncer::SyncChangeList user_a;
   syncer::SyncChangeList user_b;
 
   SetUpMultiUserScenario(&user_a, &user_b);
 
   // Run the platform (V2) app.
   CreateRunningV2App(extension_platform_app_->id());
 
   // Show user 1.
   SendPinChanges(user_a, true);
@@ skipping 13 matching lines @@
   // Switch back to 2.
   SendPinChanges(user_b, true);
   EXPECT_EQ("AppList, App6, App7, App8, Chrome, *platform_app",
             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(ChromeLauncherControllerImplTest,
+TEST_F(ChromeLauncherControllerTest,
        UserSwitchIconRestoreWithRunningV2AppChromeInMiddle) {
   syncer::SyncChangeList user_a;
   syncer::SyncChangeList user_b;
   SetUpMultiUserScenario(&user_a, &user_b);
 
   // Run the platform (V2) app.
   CreateRunningV2App(extension_platform_app_->id());
 
   // Show user 1.
   SendPinChanges(user_a, true);
   SetShelfChromeIconIndex(5);
   EXPECT_EQ("AppList, App1, App2, App3, *Platform_App, App4, Chrome, App5",
             GetPinnedAppStatus());
 
   // Show user 2.
   SendPinChanges(user_b, true);
   SetShelfChromeIconIndex(4);
   EXPECT_EQ("AppList, App6, App7, App8, Chrome, *platform_app",
             GetPinnedAppStatus());
 
   // Switch back to 1.
   SendPinChanges(user_a, true);
   SetShelfChromeIconIndex(5);
   EXPECT_EQ("AppList, App1, App2, App3, *Platform_App, App4, Chrome, App5",
             GetPinnedAppStatus());
 }
 
-TEST_F(ChromeLauncherControllerImplTest, Policy) {
+TEST_F(ChromeLauncherControllerTest, Policy) {
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension3_.get());
 
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 0, extension_misc::kChromeAppId);
   SendPinChanges(sync_list, true);
 
   base::ListValue policy_value;
@@ skipping 25 matching lines @@
   policy_value.Remove(0, NULL);
   profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kPolicyPinnedLauncherApps, policy_value.CreateDeepCopy());
   EXPECT_EQ(4, model_->item_count());
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 }
 
-TEST_F(ChromeLauncherControllerImplTest, UnpinWithUninstall) {
+TEST_F(ChromeLauncherControllerTest, 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(ChromeLauncherControllerImplTest, SyncUpdates) {
+TEST_F(ChromeLauncherControllerTest, SyncUpdates) {
   extension_service_->AddExtension(extension2_.get());
   extension_service_->AddExtension(extension3_.get());
   extension_service_->AddExtension(extension4_.get());
 
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 10, extension_misc::kChromeAppId);
   SendPinChanges(sync_list, true);
 
@@ skipping 47 matching lines @@
 
   sync_list.clear();
   InsertRemovePinChange(&sync_list, extension3_->id());
   InsertRemovePinChange(&sync_list, extension2_->id());
   SendPinChanges(sync_list, false);
   expected_pinned_apps.clear();
   GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
   EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
 }
 
-TEST_F(ChromeLauncherControllerImplTest, ImportLegacyPin) {
+TEST_F(ChromeLauncherControllerTest, 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());
 
   extension_service_->AddExtension(extension2_.get());
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 
@@ skipping 26 matching lines @@
   StartPrefSyncServiceForPins(value);
   EXPECT_EQ("AppList, Chrome, App4, App2, App5", GetPinnedAppStatus());
 
   // Next Chrome start should preserve pins.
   RecreateLauncherController()->Init();
   StopPrefSyncService();
   StartPrefSyncService(syncer::SyncDataList());
   EXPECT_EQ("AppList, Chrome, App4, App2, App5", GetPinnedAppStatus());
 }
 
-TEST_F(ChromeLauncherControllerImplTest, PendingInsertionOrder) {
+TEST_F(ChromeLauncherControllerTest, 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_pinned_apps;
   expected_pinned_apps.push_back(extension1_->id());
   expected_pinned_apps.push_back(extension3_->id());
   std::vector<std::string> actual_pinned_apps;
 
   GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
   EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
 
   // Install |extension2| and verify it shows up between the other two.
   extension_service_->AddExtension(extension2_.get());
   expected_pinned_apps.insert(expected_pinned_apps.begin() + 1,
                               extension2_->id());
   GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
   EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
 }
 
 // Ensure |controller| creates the expected menu items for the given shelf item.
-void CheckAppMenu(ChromeLauncherControllerImpl* controller,
+void CheckAppMenu(ChromeLauncherController* 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) {
+TEST_F(ChromeLauncherControllerTest, 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_, 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 };
+  base::string16 one_menu_item[] = {title1};
 
   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_, 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,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        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_, 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 };
+  base::string16 one_menu_item1[] = {title1};
   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) };
+  base::string16 one_menu_item2[] = {ASCIIToUTF16(user2)};
   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_, 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_, 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) {
+TEST_F(ChromeLauncherControllerTest, V1AppMenuGeneration) {
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   EXPECT_EQ(0, browser()->tab_strip_model()->count());
 
   InitLauncherControllerWithBrowser();
 
   // The 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 13 matching lines @@
 
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   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 };
+  base::string16 one_menu_item[] = {title1};
   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);
+  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_, 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_, 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_, item_gmail, 0, nullptr);
-  base::string16 browser_menu_item2[] = { title2 };
+  base::string16 browser_menu_item2[] = {title2};
   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,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        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_, 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 };
+  base::string16 one_menu_item[] = {title1};
   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_, 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_, 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,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        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(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        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(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        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(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
+TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        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 51 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(ChromeLauncherControllerImplTest, V1AppMenuExecution) {
+TEST_F(ChromeLauncherControllerTest, 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 27 matching lines @@
     ash::ShelfApplicationMenuModel menu(
         base::string16(),
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail),
         item_delegate);
     menu.ActivatedAt(3);
   }
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
 }
 
 // Checks that the generated menu list properly deletes items.
-TEST_F(ChromeLauncherControllerImplTest, V1AppMenuDeletionExecution) {
+TEST_F(ChromeLauncherControllerTest, 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 22 matching lines @@
   // Delete one tab through the menu item.
   {
     ash::MenuItemList items =
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail);
     item_delegate->ExecuteCommand(items[1]->command_id, ui::EF_SHIFT_DOWN);
     EXPECT_EQ(--tabs, browser()->tab_strip_model()->count());
   }
 }
 
 // Tests that panels create launcher items correctly
-TEST_F(ChromeLauncherControllerImplTest, AppPanels) {
+TEST_F(ChromeLauncherControllerTest, AppPanels) {
   InitLauncherController();
   model_observer_->clear_counts();
   const std::string app_id = extension1_->id();
 
-  // app_icon_loader is owned by ChromeLauncherControllerImpl.
+  // app_icon_loader is owned by ChromeLauncherController.
   TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl();
   app_icon_loader->AddSupportedApp(app_id);
   SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
 
   // Make an app panel; the ShelfItem is added by ash::ShelfWindowWatcher.
   std::unique_ptr<V2App> app_panel1 = base::MakeUnique<V2App>(
       profile(), extension1_.get(), extensions::AppWindow::WINDOW_TYPE_PANEL);
   EXPECT_TRUE(app_panel1->window()->GetNativeWindow()->IsVisible());
   int panel_index = model_observer_->last_index();
   EXPECT_EQ(1, model_observer_->added());
@@ skipping 18 matching lines @@
   EXPECT_EQ(1, model_observer_->added());
   model_observer_->clear_counts();
 
   app_panel1.reset();
   app_panel2.reset();
   EXPECT_EQ(2, model_observer_->removed());
 }
 
 // Tests that the Gmail extension matches more than the app itself claims with
 // the manifest file.
-TEST_F(ChromeLauncherControllerImplTest, GmailMatching) {
+TEST_F(ChromeLauncherControllerTest, 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 12 matching lines @@
 
   // Check also that the app has detected that properly.
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   EXPECT_EQ(1U,
             launcher_controller_->GetAppMenuItemsForTesting(item_gmail).size());
 }
 
 // Tests that the Gmail extension does not match the offline verison.
-TEST_F(ChromeLauncherControllerImplTest, GmailOfflineMatching) {
+TEST_F(ChromeLauncherControllerTest, GmailOfflineMatching) {
   InitLauncherControllerWithBrowser();
 
   // Create a Gmail browser tab.
   chrome::NewTab(browser());
   base::string16 title = ASCIIToUTF16("Test");
-  NavigateAndCommitActiveTabWithTitle(browser(),
-                                      GURL(offline_gmail_url),
+  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_PINNED_APP, 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(ChromeLauncherControllerImplTest, PersistLauncherItemPositions) {
+TEST_F(ChromeLauncherControllerTest, 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 20 matching lines @@
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[3].type);
 
   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.
+  // Check ShelfItems are restored after resetting ChromeLauncherController.
   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);
 }
 
 // Verifies pinned apps are persisted and restored.
-TEST_F(ChromeLauncherControllerImplTest, PersistPinned) {
+TEST_F(ChromeLauncherControllerTest, 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 ChromeLauncherControllerImpl.
+  // app_icon_loader is owned by ChromeLauncherController.
   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_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());
 
   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 is owned by ChromeLauncherController.
   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());
   ASSERT_EQ(initial_size + 1, model_->items().size());
   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[app_index].type);
 
   launcher_controller_->UnpinAppWithID("1");
   ASSERT_EQ(initial_size, model_->items().size());
 }
 
-TEST_F(ChromeLauncherControllerImplTest, MultipleAppIconLoaders) {
+TEST_F(ChromeLauncherControllerTest, 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
-  // ChromeLauncherControllerImpl.
+  // ChromeLauncherController.
   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));
 
   const ash::ShelfID shelfId3 = launcher_controller_->CreateAppLauncherItem(
       base::MakeUnique<ExtensionAppWindowLauncherItemController>(
           ash::AppLaunchId(app_id3)),
@@ skipping 33 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_P(ChromeLauncherControllerImplWithArcTest, ArcAppPinPolicy) {
+TEST_P(ChromeLauncherControllerWithArcTest, ArcAppPinPolicy) {
   InitLauncherControllerWithBrowser();
   arc::mojom::AppInfo appinfo = CreateAppInfo(
       "Some App", "SomeActivity", "com.example.app", OrientationLock::NONE);
   const std::string app_id = AddArcAppAndShortcut(appinfo);
 
   // 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.CreateDeepCopy());
 
   EXPECT_TRUE(launcher_controller_->IsAppPinned(app_id));
   EXPECT_EQ(AppListControllerDelegate::PIN_FIXED,
             GetPinnableForAppID(app_id, profile()));
 }
 
-TEST_P(ChromeLauncherControllerImplWithArcTest, ArcManaged) {
+TEST_P(ChromeLauncherControllerWithArcTest, ArcManaged) {
   // TODO(victorhsieh): Implement opt-in and opt-out.
   if (arc::ShouldArcAlwaysStart())
     return;
 
   extension_service_->AddExtension(arc_support_host_.get());
   // Test enables ARC, so turn it off for initial values.
   EnablePlayStore(false);
 
   InitLauncherController();
 
@@ skipping 41 matching lines @@
                    "AppList, Chrome");
 
   // Even if re-enable it again, Play Store pin does not appear automatically.
   EnablePlayStore(true);
   ValidateArcState(true, false,
                    arc::ArcSessionManager::State::NEGOTIATING_TERMS_OF_SERVICE,
                    "AppList, Chrome");
 }
 
 // Test the application menu of a shelf item with multiple ARC windows.
-TEST_P(ChromeLauncherControllerImplWithArcTest, ShelfItemWithMultipleWindows) {
+TEST_P(ChromeLauncherControllerWithArcTest, ShelfItemWithMultipleWindows) {
   InitLauncherControllerWithBrowser();
 
   arc::mojom::AppInfo appinfo =
       CreateAppInfo("Test1", "test", "com.example.app", OrientationLock::NONE);
   AddArcAppAndShortcut(appinfo);
 
   // Widgets will be deleted by the system.
   NotifyOnTaskCreated(appinfo, 1 /* task_id */);
   views::Widget* window1 = CreateArcWindow("org.chromium.arc.1");
   ASSERT_TRUE(window1);
@@ skipping 40 matching lines @@
 
   // Execute command to activate second window.
   item_delegate->ExecuteCommand(items[0]->command_id, 0);
   EXPECT_FALSE(window1->IsActive());
   EXPECT_TRUE(window2->IsActive());
 }
 
 namespace {
 
 class ChromeLauncherControllerOrientationTest
-    : public ChromeLauncherControllerImplWithArcTest {
+    : public ChromeLauncherControllerWithArcTest {
  public:
   ChromeLauncherControllerOrientationTest() {}
   ~ChromeLauncherControllerOrientationTest() override {}
 
  protected:
   void InitApps() {
     appinfo_none_ =
         CreateAppInfo("None", "None", "com.example.app", OrientationLock::NONE);
     appinfo_landscape_ =
         CreateAppInfo("Landscape", "Landscape", "com.example.app",
@@ skipping 57 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerOrientationTest);
 };
 
 INSTANTIATE_TEST_CASE_P(,
                         ChromeLauncherControllerOrientationTest,
                         ::testing::Bool());
 
 class ChromeLauncherControllerArcDefaultAppsTest
-    : public ChromeLauncherControllerImplTest,
+    : public ChromeLauncherControllerTest,
       public ::testing::WithParamInterface<bool> {
  public:
   ChromeLauncherControllerArcDefaultAppsTest() {}
   ~ChromeLauncherControllerArcDefaultAppsTest() override {}
 
  protected:
   void SetUp() override {
     if (GetParam())
       arc::SetArcAlwaysStartForTesting();
     ArcDefaultAppList::UseTestAppsDirectory();
-    ChromeLauncherControllerImplTest::SetUp();
+    ChromeLauncherControllerTest::SetUp();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerArcDefaultAppsTest);
 };
 
 INSTANTIATE_TEST_CASE_P(,
                         ChromeLauncherControllerArcDefaultAppsTest,
                         ::testing::Bool());
 
@@ skipping 211 matching lines @@
       launcher_controller_->GetShelfIDForAppID(arc::kPlayStoreAppId));
   EXPECT_TRUE(item_delegate);
   SelectItem(item_delegate);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc::kPlayStoreAppId));
   EXPECT_TRUE(launcher_controller_->GetArcDeferredLauncher()->HasApp(
       arc::kPlayStoreAppId));
 }
 
 // Checks the case when several app items have the same ordinal position (which
 // is valid case).
-TEST_F(ChromeLauncherControllerImplTest, CheckPositionConflict) {
+TEST_F(ChromeLauncherControllerTest, CheckPositionConflict) {
   InitLauncherController();
 
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension2_.get());
   extension_service_->AddExtension(extension3_.get());
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 0, extension_misc::kChromeAppId);
   InsertAddPinChange(&sync_list, 1, extension1_->id());
   InsertAddPinChange(&sync_list, 1, extension2_->id());
@@ skipping 29 matching lines @@
   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())));
 }
 
 // Test the case when sync app is turned off and we need to use local copy to
 // support user's pins.
-TEST_F(ChromeLauncherControllerImplTest, SyncOffLocalUpdate) {
+TEST_F(ChromeLauncherControllerTest, SyncOffLocalUpdate) {
   InitLauncherController();
 
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension2_.get());
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 0, extension_misc::kChromeAppId);
   InsertAddPinChange(&sync_list, 1, extension1_->id());
   InsertAddPinChange(&sync_list, 1, extension2_->id());
   SendPinChanges(sync_list, true);
@@ skipping 10 matching lines @@
   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());
 }
 
 // Tests that shelf profile preferences are loaded on login.
-TEST_F(ChromeLauncherControllerImplTest, PrefsLoadedOnLogin) {
+TEST_F(ChromeLauncherControllerTest, PrefsLoadedOnLogin) {
   PrefService* prefs = profile()->GetTestingPrefService();
   prefs->SetString(prefs::kShelfAlignmentLocal, "Left");
   prefs->SetString(prefs::kShelfAlignment, "Left");
   prefs->SetString(prefs::kShelfAutoHideBehaviorLocal, "Always");
   prefs->SetString(prefs::kShelfAutoHideBehavior, "Always");
 
-  TestChromeLauncherControllerImpl* test_launcher_controller =
+  TestChromeLauncherController* test_launcher_controller =
       shell_delegate_->CreateTestLauncherController(profile());
 
   // Simulate login for the test controller.
   test_launcher_controller->ReleaseProfile();
   test_launcher_controller->AttachProfile(profile());
   base::RunLoop().RunUntilIdle();
 
   TestShelfController* shelf_controller =
       test_launcher_controller->test_shelf_controller();
   ASSERT_TRUE(shelf_controller);
   EXPECT_EQ(ash::SHELF_ALIGNMENT_LEFT, shelf_controller->alignment());
   EXPECT_EQ(1u, shelf_controller->alignment_change_count());
   EXPECT_EQ(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS,
             shelf_controller->auto_hide());
   EXPECT_EQ(1u, shelf_controller->auto_hide_change_count());
 }
 
 // Tests that the shelf controller's changes are not wastefully echoed back.
-TEST_F(ChromeLauncherControllerImplTest, DoNotEchoShelfControllerChanges) {
-  TestChromeLauncherControllerImpl* test_launcher_controller =
+TEST_F(ChromeLauncherControllerTest, DoNotEchoShelfControllerChanges) {
+  TestChromeLauncherController* test_launcher_controller =
       shell_delegate_->CreateTestLauncherController(profile());
 
   // Simulate login for the test controller.
   test_launcher_controller->ReleaseProfile();
   test_launcher_controller->AttachProfile(profile());
   base::RunLoop().RunUntilIdle();
 
   TestShelfController* shelf_controller =
       test_launcher_controller->test_shelf_controller();
   ASSERT_TRUE(shelf_controller);
@@ skipping 18 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));
 }