Rename Launcher to Shelf.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_browsertest.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 "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "apps/ui/native_app_window.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
-#include "ash/launcher/launcher.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shelf/shelf_view.h"
 #include "ash/shell.h"
 #include "ash/test/app_list_controller_test_api.h"
-#include "ash/test/launcher_test_api.h"
+#include "ash/test/shelf_test_api.h"
 #include "ash/test/shelf_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/automation/automation_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_apitest.h"
@@ skipping 77 matching lines @@
   int icon_updates_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShellWindowRegistryObserver);
 };
 
 }  // namespace
 
 class LauncherPlatformAppBrowserTest
     : public extensions::PlatformAppBrowserTest {
  protected:
-  LauncherPlatformAppBrowserTest() : launcher_(NULL), controller_(NULL) {
+  LauncherPlatformAppBrowserTest() : shelf_(NULL), controller_(NULL) {
   }
 
   virtual ~LauncherPlatformAppBrowserTest() {}
 
   virtual void RunTestOnMainThreadLoop() OVERRIDE {
-    launcher_ = ash::Launcher::ForPrimaryDisplay();
+    shelf_ = ash::Shelf::ForPrimaryDisplay();
     controller_ = ChromeLauncherController::instance();
     return extensions::PlatformAppBrowserTest::RunTestOnMainThreadLoop();
   }
 
   ash::ShelfModel* shelf_model() {
     return ash::test::ShellTestApi(ash::Shell::GetInstance()).shelf_model();
   }
 
   ash::LauncherID CreateAppShortcutLauncherItem(const std::string& name) {
     return controller_->CreateAppShortcutLauncherItem(
         name, controller_->model()->item_count());
   }
 
   const ash::LauncherItem& GetLastLauncherItem() {
     // Unless there are any panels, the item at index [count - 1] will be
     // the desired item.
     return shelf_model()->items()[shelf_model()->item_count() - 1];
   }
 
   const ash::LauncherItem& GetLastLauncherPanelItem() {
-    // Panels show up on the right side of the launcher, so the desired item
+    // Panels show up on the right side of the shelf, so the desired item
     // will be the last one.
     return shelf_model()->items()[shelf_model()->item_count() - 1];
   }
 
   LauncherItemController* GetItemController(ash::LauncherID id) {
     return controller_->id_to_item_controller_map_[id];
   }
 
   // Returns the number of menu items, ignoring separators.
   int GetNumApplicationMenuItems(const ash::LauncherItem& item) {
     const int event_flags = 0;
     scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
         controller_->GetApplicationList(item, event_flags)));
     int num_items = 0;
     for (int i = 0; i < menu->GetItemCount(); ++i) {
       if (menu->GetTypeAt(i) != ui::MenuModel::TYPE_SEPARATOR)
         ++num_items;
     }
     return num_items;
   }
 
-  // Activate the launcher item with the given |id|.
-  void ActivateLauncherItem(int id) {
-    launcher_->ActivateLauncherItem(id);
+  // Activate the shelf item with the given |id|.
+  void ActivateShelfItem(int id) {
+    shelf_->ActivateShelfItem(id);
   }
 
-  ash::Launcher* launcher_;
+  ash::Shelf* shelf_;
   ChromeLauncherController* controller_;
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(LauncherPlatformAppBrowserTest);
 };
 
 enum RipOffCommand {
   // Drag the item off the shelf and let the mouse go.
   RIP_OFF_ITEM,
   // Drag the item off the shelf, move the mouse back and then let go.
   RIP_OFF_ITEM_AND_RETURN,
   // Drag the item off the shelf and then issue a cancel command.
   RIP_OFF_ITEM_AND_CANCEL,
   // Drag the item off the shelf and do not release the mouse.
   RIP_OFF_ITEM_AND_DONT_RELEASE_MOUSE,
 };
 
-class LauncherAppBrowserTest : public ExtensionBrowserTest {
+class ShelfAppBrowserTest : public ExtensionBrowserTest {
  protected:
-  LauncherAppBrowserTest() : launcher_(NULL), model_(NULL), controller_(NULL) {
+  ShelfAppBrowserTest() : shelf_(NULL), model_(NULL), controller_(NULL) {
   }
 
-  virtual ~LauncherAppBrowserTest() {}
+  virtual ~ShelfAppBrowserTest() {}
 
   virtual void RunTestOnMainThreadLoop() OVERRIDE {
-    launcher_ = ash::Launcher::ForPrimaryDisplay();
+    shelf_ = ash::Shelf::ForPrimaryDisplay();
     model_ = ash::test::ShellTestApi(ash::Shell::GetInstance()).shelf_model();
     controller_ = ChromeLauncherController::instance();
     return ExtensionBrowserTest::RunTestOnMainThreadLoop();
   }
 
   size_t NumberOfDetectedLauncherBrowsers(bool show_all_tabs) {
     LauncherItemController* item_controller =
       controller_->GetBrowserShortcutLauncherItemController();
     int items = item_controller->GetApplicationList(
         show_all_tabs ? ui::EF_SHIFT_DOWN : 0).size();
@@ skipping 39 matching lines @@
     EXPECT_EQ(++item_count, model_->item_count());
     const ash::LauncherItem& item = *model_->ItemByID(shortcut_id);
     EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
     return item.id;
   }
 
   void RemoveShortcut(ash::LauncherID id) {
     controller_->Unpin(id);
   }
 
-  // Activate the launcher item with the given |id|.
-  void ActivateLauncherItem(int id) {
-    launcher_->ActivateLauncherItem(id);
+  // Activate the shelf item with the given |id|.
+  void ActivateShelfItem(int id) {
+    shelf_->ActivateShelfItem(id);
   }
 
   ash::LauncherID PinFakeApp(const std::string& name) {
     return controller_->CreateAppShortcutLauncherItem(
         name, model_->item_count());
   }
 
   // Get the index of an item which has the given type.
   int GetIndexOfShelfItemType(ash::LauncherItemType type) {
     return model_->GetItemIndexForType(type);
@@ skipping 22 matching lines @@
       // This triggers an internal cancel. Using VKEY_ESCAPE was too unreliable.
       button->OnMouseCaptureLost();
     }
     if (command != RIP_OFF_ITEM_AND_DONT_RELEASE_MOUSE) {
       generator->ReleaseLeftButton();
       base::MessageLoop::current()->RunUntilIdle();
       test->RunMessageLoopUntilAnimationsDone();
     }
   }
 
-  ash::Launcher* launcher_;
+  ash::Shelf* shelf_;
   ash::ShelfModel* model_;
   ChromeLauncherController* controller_;
 
  private:
 
-  DISALLOW_COPY_AND_ASSIGN(LauncherAppBrowserTest);
+  DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserTest);
 };
 
-class LauncherAppBrowserTestNoDefaultBrowser : public LauncherAppBrowserTest {
+class ShelfAppBrowserTestNoDefaultBrowser : public ShelfAppBrowserTest {
  protected:
-  LauncherAppBrowserTestNoDefaultBrowser() {}
-  virtual ~LauncherAppBrowserTestNoDefaultBrowser() {}
+  ShelfAppBrowserTestNoDefaultBrowser() {}
+  virtual ~ShelfAppBrowserTestNoDefaultBrowser() {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
-    LauncherAppBrowserTest::SetUpCommandLine(command_line);
+    ShelfAppBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kNoStartupWindow);
   }
 
  private:
 
-  DISALLOW_COPY_AND_ASSIGN(LauncherAppBrowserTestNoDefaultBrowser);
+  DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserTestNoDefaultBrowser);
 };
 
 // Since the default for minimizing on click might change, I added both classes
 // to either get the minimize on click or not.
-class LauncherAppBrowserNoMinimizeOnClick
-    : public LauncherPlatformAppBrowserTest {
+class ShelfAppBrowserNoMinimizeOnClick : public LauncherPlatformAppBrowserTest {
  protected:
-  LauncherAppBrowserNoMinimizeOnClick() {}
-  virtual ~LauncherAppBrowserNoMinimizeOnClick() {}
+  ShelfAppBrowserNoMinimizeOnClick() {}
+  virtual ~ShelfAppBrowserNoMinimizeOnClick() {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     LauncherPlatformAppBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(
         switches::kDisableMinimizeOnSecondLauncherItemClick);
   }
 
  private:
 
-  DISALLOW_COPY_AND_ASSIGN(LauncherAppBrowserNoMinimizeOnClick);
+  DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserNoMinimizeOnClick);
 };
 
-typedef LauncherPlatformAppBrowserTest LauncherAppBrowserMinimizeOnClick;
+typedef LauncherPlatformAppBrowserTest ShelfAppBrowserMinimizeOnClick;
 
 // Test that we can launch a platform app and get a running item.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchUnpinned) {
   int item_count = shelf_model()->item_count();
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window = CreateShellWindow(extension);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::LauncherItem& item = GetLastLauncherItem();
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item.type);
@@ skipping 219 matching lines @@
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::LauncherItem& item2 = GetLastLauncherItem();
   ash::LauncherID item_id2 = item2.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item2.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
 
   EXPECT_NE(item_id1, item_id2);
   EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
 
   // Activate first one.
-  ActivateLauncherItem(shelf_model()->ItemIndexByID(item_id1));
+  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
   EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id1)->status);
   EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id2)->status);
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
 
   // Activate second one.
-  ActivateLauncherItem(shelf_model()->ItemIndexByID(item_id2));
+  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id2));
   EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
   EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id2)->status);
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
 
   // Add window for app1. This will activate it.
   ShellWindow* window1b = CreateShellWindow(extension1);
   ash::wm::ActivateWindow(window1b->GetNativeWindow());
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
 
   // Activate launcher item for app1, this will activate the first app window.
-  ActivateLauncherItem(shelf_model()->ItemIndexByID(item_id1));
+  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
-  ActivateLauncherItem(shelf_model()->ItemIndexByID(item_id1));
+  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
 
   // Activate the second app again
-  ActivateLauncherItem(shelf_model()->ItemIndexByID(item_id2));
+  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id2));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
 
   // Activate the first app again
-  ActivateLauncherItem(shelf_model()->ItemIndexByID(item_id1));
+  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
 
   // Close second app.
   CloseShellWindow(window2);
   --item_count;
   EXPECT_EQ(item_count, shelf_model()->item_count());
   // First app should be active again.
   EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id1)->status);
 
   // Close first app.
   CloseShellWindow(window1b);
   CloseShellWindow(window1);
   --item_count;
   EXPECT_EQ(item_count, shelf_model()->item_count());
 }
 
 // Confirm that Click behavior for app windows is correnct.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserNoMinimizeOnClick,
-                       AppClickBehavior) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserNoMinimizeOnClick, AppClickBehavior) {
   // Launch a platform app and create a window for it.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window1 = CreateShellWindow(extension1);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   // Confirm that a controller item was created and is the correct state.
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   LauncherItemController* item1_controller = GetItemController(item1.id);
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
@@ skipping 16 matching lines @@
   // Maximizing a window should preserve state after minimize + click.
   window1->GetBaseWindow()->Maximize();
   window1->GetBaseWindow()->Minimize();
   item1_controller->ItemSelected(click_event);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_TRUE(window1->GetBaseWindow()->IsMaximized());
 }
 
 // Confirm the minimizing click behavior for apps.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserMinimizeOnClick,
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserMinimizeOnClick,
                        PackagedAppClickBehaviorInMinimizeMode) {
   // Launch one platform app and create a window for it.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window1 = CreateShellWindow(extension1);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
 
   // Confirm that a controller item was created and is the correct state.
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   LauncherItemController* item1_controller = GetItemController(item1.id);
@@ skipping 97 matching lines @@
 }
 
 // Test that opening an app sets the correct icon
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, SetIcon) {
   TestShellWindowRegistryObserver test_observer(browser()->profile());
 
   // Enable experimental APIs to allow panel creation.
   CommandLine::ForCurrentProcess()->AppendSwitch(
       extensions::switches::kEnableExperimentalExtensionApis);
 
-  int base_launcher_item_count = shelf_model()->item_count();
+  int base_shelf_item_count = shelf_model()->item_count();
   ExtensionTestMessageListener launched_listener("Launched", false);
   ExtensionTestMessageListener completed_listener("Completed", false);
   LoadAndLaunchPlatformApp("app_icon");
   ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
   ASSERT_TRUE(completed_listener.WaitUntilSatisfied());
 
   // Now wait until the WebContent has decoded the icons and chrome has
   // processed it. This needs to be in a loop since the renderer runs in a
   // different process.
   while (test_observer.icon_updates() < 3) {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   // This test creates one shell window and one panel window.
-  int launcher_item_count = shelf_model()->item_count();
-  ASSERT_EQ(base_launcher_item_count + 2, launcher_item_count);
+  int shelf_item_count = shelf_model()->item_count();
+  ASSERT_EQ(base_shelf_item_count + 2, shelf_item_count);
   // The Panel will be the last item, the app second-to-last.
   const ash::LauncherItem& app_item =
-      shelf_model()->items()[launcher_item_count - 2];
+      shelf_model()->items()[shelf_item_count - 2];
   const ash::LauncherItem& panel_item =
-      shelf_model()->items()[launcher_item_count - 1];
+      shelf_model()->items()[shelf_item_count - 1];
   const LauncherItemController* app_item_controller =
       GetItemController(app_item.id);
   const LauncherItemController* panel_item_controller =
       GetItemController(panel_item.id);
   // Icons for Apps are set by the ShellWindowLauncherController, so
   // image_set_by_controller() should be set.
   EXPECT_TRUE(app_item_controller->image_set_by_controller());
   EXPECT_TRUE(panel_item_controller->image_set_by_controller());
   // Ensure icon heights are correct (see test.js in app_icon/ test directory)
   EXPECT_EQ(48, app_item.image.height());
   EXPECT_EQ(64, panel_item.image.height());
 }
 
 // Test that we can launch an app with a shortcut.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchPinned) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchPinned) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
   WebContents* tab = tab_strip->GetActiveWebContents();
   content::WebContentsDestroyedWatcher destroyed_watcher(tab);
   browser()->tab_strip_model()->CloseSelectedTabs();
   destroyed_watcher.Wait();
   EXPECT_EQ(--tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
 }
 
 // Launch the app first and then create the shortcut.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchUnpinned) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchUnpinned) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB,
                          NEW_FOREGROUND_TAB);
   EXPECT_EQ(++tab_count, tab_strip->count());
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
   WebContents* tab = tab_strip->GetActiveWebContents();
   content::WebContentsDestroyedWatcher destroyed_watcher(tab);
   browser()->tab_strip_model()->CloseSelectedTabs();
   destroyed_watcher.Wait();
   EXPECT_EQ(--tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
 }
 
 // Launches an app in the background and then tries to open it. This is test for
 // a crash we had.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchInBackground) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchInBackground) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB,
                          NEW_BACKGROUND_TAB);
   EXPECT_EQ(++tab_count, tab_strip->count());
   ChromeLauncherController::instance()->LaunchApp(last_loaded_extension_id(),
                                                   ash::LAUNCH_FROM_UNKNOWN,
                                                   0);
 }
 
 // Confirm that clicking a icon for an app running in one of 2 maxmized windows
 // activates the right window.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchMaximized) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchMaximized) {
   aura::Window* window1 = browser()->window()->GetNativeWindow();
   ash::wm::WindowState* window1_state = ash::wm::GetWindowState(window1);
   window1_state->Maximize();
   content::WindowedNotificationObserver open_observer(
       chrome::NOTIFICATION_BROWSER_WINDOW_READY,
       content::NotificationService::AllSources());
   chrome::NewEmptyWindow(browser()->profile(), chrome::HOST_DESKTOP_TYPE_ASH);
   open_observer.Wait();
   Browser* browser2 = content::Source<Browser>(open_observer.source()).ptr();
   aura::Window* window2 = browser2->window()->GetNativeWindow();
   TabStripModel* tab_strip = browser2->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::wm::GetWindowState(window2)->Maximize();
 
   ash::LauncherID shortcut_id = CreateShortcut("app1");
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 
   window1->Show();
   window1_state->Activate();
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut_id)).status);
 
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 }
 
 // Activating the same app multiple times should launch only a single copy.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, ActivateApp) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, ActivateApp) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("app1"));
 
   ChromeLauncherController::instance()->ActivateApp(extension->id(),
                                                     ash::LAUNCH_FROM_UNKNOWN,
                                                     0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   ChromeLauncherController::instance()->ActivateApp(extension->id(),
                                                     ash::LAUNCH_FROM_UNKNOWN,
                                                     0);
   EXPECT_EQ(tab_count, tab_strip->count());
 }
 
 // Launching the same app multiple times should launch a copy for each call.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchApp) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchApp) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("app1"));
 
   ChromeLauncherController::instance()->LaunchApp(extension->id(),
                                                   ash::LAUNCH_FROM_UNKNOWN,
                                                   0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   ChromeLauncherController::instance()->LaunchApp(extension->id(),
                                                   ash::LAUNCH_FROM_UNKNOWN,
                                                   0);
   EXPECT_EQ(++tab_count, tab_strip->count());
 }
 
 // Launch 2 apps and toggle which is active.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, MultipleApps) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, MultipleApps) {
   int item_count = model_->item_count();
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut1 = CreateShortcut("app1");
   EXPECT_EQ(++item_count, model_->item_count());
   ash::LauncherID shortcut2 = CreateShortcut("app2");
   EXPECT_EQ(++item_count, model_->item_count());
 
   // Launch first app.
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut1));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut1));
   EXPECT_EQ(++tab_count, tab_strip->count());
   WebContents* tab1 = tab_strip->GetActiveWebContents();
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut1)).status);
 
   // Launch second app.
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut2));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut2));
   EXPECT_EQ(++tab_count, tab_strip->count());
   WebContents* tab2 = tab_strip->GetActiveWebContents();
   ASSERT_NE(tab1, tab2);
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut1)).status);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut2)).status);
 
   // Reactivate first app.
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut1));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut1));
   EXPECT_EQ(tab_count, tab_strip->count());
   EXPECT_EQ(tab_strip->GetActiveWebContents(), tab1);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut1)).status);
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut2)).status);
 
   // Open second tab for second app. This should activate it.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path3/foo.html"),
       NEW_FOREGROUND_TAB,
       0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut1)).status);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut2)).status);
 
   // Reactivate first app.
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut1));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut1));
   EXPECT_EQ(tab_count, tab_strip->count());
   EXPECT_EQ(tab_strip->GetActiveWebContents(), tab1);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut1)).status);
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut2)).status);
 
   // And second again. This time the second tab should become active.
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut2));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut2));
   EXPECT_EQ(tab_count, tab_strip->count());
   EXPECT_EQ(tab_strip->GetActiveWebContents(), tab2);
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut1)).status);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut2)).status);
 }
 
 // Confirm that a page can be navigated from and to while maintaining the
 // correct running state.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, Navigation) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, Navigation) {
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 
   // Navigate away.
   ui_test_utils::NavigateToURL(
       browser(), GURL("http://www.example.com/path0/bar.html"));
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
 
   // Navigate back.
   ui_test_utils::NavigateToURL(
       browser(), GURL("http://www.example.com/path1/foo.html"));
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 }
 
 // Confirm that a tab can be moved between browsers while maintaining the
 // correct running state.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, TabDragAndDrop) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, TabDragAndDrop) {
   TabStripModel* tab_strip_model1 = browser()->tab_strip_model();
   EXPECT_EQ(1, tab_strip_model1->count());
   int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
   EXPECT_TRUE(browser_index >= 0);
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 
   // Create a shortcut for app1.
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
 
   // Activate app1 and check its item status.
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(2, tab_strip_model1->count());
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[browser_index].status);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 
   // Create a new browser with blank tab.
   Browser* browser2 = CreateBrowser(profile());
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   TabStripModel* tab_strip_model2 = browser2->tab_strip_model();
   EXPECT_EQ(1, tab_strip_model2->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut_id)).status);
 
   // Detach a tab at index 1 (app1) from |tab_strip_model1| and insert it as an
   // active tab at index 1 to |tab_strip_model2|.
   content::WebContents* detached_tab = tab_strip_model1->DetachWebContentsAt(1);
   tab_strip_model2->InsertWebContentsAt(1,
                                         detached_tab,
                                         TabStripModel::ADD_ACTIVE);
   EXPECT_EQ(1, tab_strip_model1->count());
   EXPECT_EQ(2, tab_strip_model2->count());
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[browser_index].status);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 
   tab_strip_model1->CloseAllTabs();
   tab_strip_model2->CloseAllTabs();
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, MultipleOwnedTabs) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, MultipleOwnedTabs) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   WebContents* first_tab = tab_strip->GetActiveWebContents();
 
   // Create new tab owned by app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path2/bar.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   EXPECT_EQ(++tab_count, tab_strip->count());
   // Confirm app is still active.
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
 
   // Create new tab not owned by app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path3/foo.html"),
       NEW_FOREGROUND_TAB,
       0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   // No longer active.
   EXPECT_EQ(ash::STATUS_RUNNING, model_->ItemByID(shortcut_id)->status);
 
   // Activating app makes first tab active again.
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(tab_strip->GetActiveWebContents(), first_tab);
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, RefocusFilter) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, RefocusFilter) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   WebContents* first_tab = tab_strip->GetActiveWebContents();
 
   controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
   // Create new tab owned by app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path2/bar.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   EXPECT_EQ(++tab_count, tab_strip->count());
   // Confirm app is still active.
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
 
   // Create new tab not owned by app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path3/foo.html"),
       NEW_FOREGROUND_TAB,
       0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   // No longer active.
   EXPECT_EQ(ash::STATUS_RUNNING, model_->ItemByID(shortcut_id)->status);
 
   // Activating app makes first tab active again, because second tab isn't
   // in its refocus url path.
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(tab_strip->GetActiveWebContents(), first_tab);
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, RefocusFilterLaunch) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, RefocusFilterLaunch) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
 
   // Create new tab.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example2.com/path2/bar.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   EXPECT_EQ(++tab_count, tab_strip->count());
   WebContents* first_tab = tab_strip->GetActiveWebContents();
   // Confirm app is not active.
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
 
   // Activating app should launch new tab, because second tab isn't
   // in its refocus url path.
-  ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
+  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   WebContents* second_tab = tab_strip->GetActiveWebContents();
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   EXPECT_NE(first_tab, second_tab);
   EXPECT_EQ(tab_strip->GetActiveWebContents(), second_tab);
 }
 
 // Check the launcher activation state for applications and browser.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, ActivationStateCheck) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, ActivationStateCheck) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   // Get the browser item index
   int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
   EXPECT_TRUE(browser_index >= 0);
 
   // Even though we are just comming up, the browser should be active.
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
 
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   controller_->SetRefocusURLPatternForTest(
@@ skipping 22 matching lines @@
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
 
   ash::wm::DeactivateWindow(browser()->window()->GetNativeWindow());
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[browser_index].status);
 }
 
 // Check that the launcher activation state for a V1 application stays closed
 // even after an asynchronous browser event comes in after the tab got
 // destroyed.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, AsyncActivationStateCheck) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, AsyncActivationStateCheck) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
 
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
 
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
 
   // Create new tab which would be the running app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path1/bar.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   // To address the issue of crbug.com/174050, the tab we are about to close
   // has to be active.
   tab_strip->ActivateTabAt(1, false);
   EXPECT_EQ(1, tab_strip->active_index());
 
   // Close the web contents.
   tab_strip->CloseWebContentsAt(1, TabStripModel::CLOSE_NONE);
   // The status should now be set to closed.
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
 }
 
 // Checks that a windowed application does not add an item to the browser list.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTestNoDefaultBrowser,
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
     WindowedAppDoesNotAddToBrowser) {
   // Get the number of items in the browser menu.
   size_t items = NumberOfDetectedLauncherBrowsers(false);
   size_t running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(0u, items);
   EXPECT_EQ(0u, running_browser);
 
   LoadAndLaunchExtension(
       "app1", extensions::LAUNCH_CONTAINER_WINDOW, NEW_WINDOW);
 
   // No new browser should get detected, even though one more is running.
   EXPECT_EQ(0u, NumberOfDetectedLauncherBrowsers(false));
   EXPECT_EQ(++running_browser, chrome::GetTotalBrowserCount());
 
   LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB, NEW_WINDOW);
 
   // A new browser should get detected and one more should be running.
   EXPECT_EQ(NumberOfDetectedLauncherBrowsers(false), 1u);
   EXPECT_EQ(++running_browser, chrome::GetTotalBrowserCount());
 }
 
 // Checks the functionality to enumerate all browsers vs. all tabs.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTestNoDefaultBrowser,
-    EnumerateALlBrowsersAndTabs) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
+                       EnumerateALlBrowsersAndTabs) {
   // Create at least one browser.
   LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB, NEW_WINDOW);
   size_t browsers = NumberOfDetectedLauncherBrowsers(false);
   size_t tabs = NumberOfDetectedLauncherBrowsers(true);
 
   // Create a second browser.
   LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB, NEW_WINDOW);
 
   EXPECT_EQ(++browsers, NumberOfDetectedLauncherBrowsers(false));
   EXPECT_EQ(++tabs, NumberOfDetectedLauncherBrowsers(true));
 
   // Create only a tab.
   LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB,
                          NEW_FOREGROUND_TAB);
 
   EXPECT_EQ(browsers, NumberOfDetectedLauncherBrowsers(false));
   EXPECT_EQ(++tabs, NumberOfDetectedLauncherBrowsers(true));
 }
 
 // Check that the keyboard activation of a launcher item tabs properly through
 // the items at hand.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, AltNumberTabsTabbing) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, AltNumberTabsTabbing) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
 
   ash::LauncherID shortcut_id = CreateShortcut("app");
   controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path/*"));
   std::string url = "http://www.example.com/path/bla";
 
   int shortcut_index = model_->ItemIndexByID(shortcut_id);
 
   // Create an application handled browser tab.
@@ skipping 12 matching lines @@
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   content::WebContents* content1a = tab_strip->GetActiveWebContents();
 
   // Make sure that the active tab is now our handled tab.
   EXPECT_NE(content1a, content1);
 
   // The active tab should still be the unnamed tab. Then we switch and reach
   // the first app and stay there.
   EXPECT_EQ(content1a, tab_strip->GetActiveWebContents());
-  ActivateLauncherItem(shortcut_index);
+  ActivateShelfItem(shortcut_index);
   EXPECT_EQ(content1, tab_strip->GetActiveWebContents());
-  ActivateLauncherItem(shortcut_index);
+  ActivateShelfItem(shortcut_index);
   EXPECT_EQ(content1, tab_strip->GetActiveWebContents());
 
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL(url),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   content::WebContents* content2 = tab_strip->GetActiveWebContents();
 
   EXPECT_EQ(content2, browser()->tab_strip_model()->GetActiveWebContents());
-  ActivateLauncherItem(shortcut_index);
+  ActivateShelfItem(shortcut_index);
   EXPECT_EQ(content1, browser()->tab_strip_model()->GetActiveWebContents());
-  ActivateLauncherItem(shortcut_index);
+  ActivateShelfItem(shortcut_index);
   EXPECT_EQ(content2, browser()->tab_strip_model()->GetActiveWebContents());
 }
 
 // Check that the keyboard activation of a launcher item tabs properly through
 // the items at hand.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest,
                        AltNumberAppsTabbing) {
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   ui::BaseWindow* window1 = CreateShellWindow(extension1)->GetBaseWindow();
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID app_id = item1.id;
   int app_index = shelf_model()->ItemIndexByID(app_id);
 
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2");
   ui::BaseWindow* window2 = CreateShellWindow(extension2)->GetBaseWindow();
 
   // By now the browser should be active. Issue Alt keystrokes several times to
   // see that we stay on that application.
   EXPECT_TRUE(window2->IsActive());
-  ActivateLauncherItem(app_index);
+  ActivateShelfItem(app_index);
   EXPECT_TRUE(window1->IsActive());
-  ActivateLauncherItem(app_index);
+  ActivateShelfItem(app_index);
   EXPECT_TRUE(window1->IsActive());
 
   ui::BaseWindow* window1a = CreateShellWindow(extension1)->GetBaseWindow();
 
   EXPECT_TRUE(window1a->IsActive());
   EXPECT_FALSE(window1->IsActive());
-  ActivateLauncherItem(app_index);
+  ActivateShelfItem(app_index);
   EXPECT_TRUE(window1->IsActive());
-  ActivateLauncherItem(app_index);
+  ActivateShelfItem(app_index);
   EXPECT_TRUE(window1a->IsActive());
 }
 
 // Test that we can launch a platform app panel and get a running item.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchPanelWindow) {
   int item_count = shelf_model()->item_count();
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   ShellWindow::CreateParams params;
   params.window_type = ShellWindow::WINDOW_TYPE_PANEL;
   params.focused = false;
@@ skipping 35 matching lines @@
   item_controller->ItemSelected(click_event);
   EXPECT_TRUE(panel->GetBaseWindow()->IsActive());
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
 
   // Active windows don't show attention.
   panel->GetNativeWindow()->SetProperty(aura::client::kDrawAttentionKey, true);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
 }
 
 // Checks that the browser Alt "tabbing" is properly done.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTestNoDefaultBrowser,
-    AltNumberBrowserTabbing) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
+                       AltNumberBrowserTabbing) {
   // Get the number of items in the browser menu.
   EXPECT_EQ(0u, chrome::GetTotalBrowserCount());
   // The first activation should create a browser at index 1 (App List @ 0).
-  launcher_->ActivateLauncherItem(1);
+  shelf_->ActivateShelfItem(1);
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   // A second activation should not create a new instance.
-  launcher_->ActivateLauncherItem(1);
+  shelf_->ActivateShelfItem(1);
   Browser* browser1 = chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow());
   EXPECT_TRUE(browser1);
   aura::Window* window1 = browser1->window()->GetNativeWindow();
   Browser* browser2 = CreateBrowser(profile());
   aura::Window* window2 = browser2->window()->GetNativeWindow();
 
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_NE(window1, window2);
   EXPECT_EQ(window2, ash::wm::GetActiveWindow());
 
   // Activate multiple times the switcher to see that the windows get activated.
-  launcher_->ActivateLauncherItem(1);
+  shelf_->ActivateShelfItem(1);
   EXPECT_EQ(window1, ash::wm::GetActiveWindow());
-  launcher_->ActivateLauncherItem(1);
+  shelf_->ActivateShelfItem(1);
   EXPECT_EQ(window2, ash::wm::GetActiveWindow());
 
   // Create a third browser - make sure that we do not toggle simply between
   // two windows.
   Browser* browser3 = CreateBrowser(profile());
   aura::Window* window3 = browser3->window()->GetNativeWindow();
 
   EXPECT_EQ(3u, chrome::GetTotalBrowserCount());
   EXPECT_NE(window1, window3);
   EXPECT_NE(window2, window3);
   EXPECT_EQ(window3, ash::wm::GetActiveWindow());
 
-  launcher_->ActivateLauncherItem(1);
+  shelf_->ActivateShelfItem(1);
   EXPECT_EQ(window1, ash::wm::GetActiveWindow());
-  launcher_->ActivateLauncherItem(1);
+  shelf_->ActivateShelfItem(1);
   EXPECT_EQ(window2, ash::wm::GetActiveWindow());
-  launcher_->ActivateLauncherItem(1);
+  shelf_->ActivateShelfItem(1);
   EXPECT_EQ(window3, ash::wm::GetActiveWindow());
-  launcher_->ActivateLauncherItem(1);
+  shelf_->ActivateShelfItem(1);
   EXPECT_EQ(window1, ash::wm::GetActiveWindow());
 
   // Create anther app and make sure that none of our browsers is active.
   LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB, NEW_WINDOW);
   EXPECT_NE(window1, ash::wm::GetActiveWindow());
   EXPECT_NE(window2, ash::wm::GetActiveWindow());
 
   // After activation our browser should be active again.
-  launcher_->ActivateLauncherItem(1);
+  shelf_->ActivateShelfItem(1);
   EXPECT_EQ(window1, ash::wm::GetActiveWindow());
 }
 
 // Checks that after a session restore, we do not start applications on an
 // activation.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, ActivateAfterSessionRestore) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, ActivateAfterSessionRestore) {
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 
   // Create a known application.
   ash::LauncherID shortcut_id = CreateShortcut("app1");
 
   // Create a new browser - without activating it - and load an "app" into it.
   Browser::CreateParams params =
       Browser::CreateParams(profile(), chrome::GetActiveDesktop());
   params.initial_show_state = ui::SHOW_STATE_INACTIVE;
   Browser* browser2 = new Browser(params);
@@ skipping 37 matching lines @@
   // was created.
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(tab_count1, tab_strip->count());
   EXPECT_EQ(tab_count2, tab_strip2->count());
   EXPECT_EQ(chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow()),
             browser2);
 }
 
 // Do various drag and drop interaction tests between the application list and
 // the launcher.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, DragAndDrop) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, DragAndDrop) {
   // Get a number of interfaces we need.
   aura::test::EventGenerator generator(
       ash::Shell::GetPrimaryRootWindow(), gfx::Point());
   ash::test::ShelfViewTestAPI test(
-      ash::test::LauncherTestAPI(launcher_).shelf_view());
+      ash::test::ShelfTestAPI(shelf_).shelf_view());
   AppListService* service = AppListService::Get(chrome::GetActiveDesktop());
 
   // There should be two items in our launcher by this time.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(service->IsAppListVisible());
 
   // Open the app list menu and check that the drag and drop host was set.
   gfx::Rect app_list_bounds =
       test.shelf_view()->GetAppListButtonView()->GetBoundsInScreen();
   generator.MoveMouseTo(app_list_bounds.CenterPoint().x(),
@@ skipping 19 matching lines @@
   // Get over item #1 of the application list and press the mouse button.
   views::View* item1 = vm_grid->view_at(1);
   gfx::Rect bounds_grid_1 = item1->GetBoundsInScreen();
   generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
                         bounds_grid_1.CenterPoint().y());
   base::MessageLoop::current()->RunUntilIdle();
   generator.PressLeftButton();
 
   EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
 
-  // Drag the item into the launcher and check that a new item gets created.
-  const views::ViewModel* vm_launcher =
-      test.shelf_view()->view_model_for_test();
-  views::View* launcher1 = vm_launcher->view_at(1);
-  gfx::Rect bounds_launcher_1 = launcher1->GetBoundsInScreen();
-  generator.MoveMouseTo(bounds_launcher_1.CenterPoint().x(),
-                        bounds_launcher_1.CenterPoint().y());
+  // Drag the item into the shelf and check that a new item gets created.
+  const views::ViewModel* vm_shelf = test.shelf_view()->view_model_for_test();
+  views::View* shelf1 = vm_shelf->view_at(1);
+  gfx::Rect bounds_shelf_1 = shelf1->GetBoundsInScreen();
+  generator.MoveMouseTo(bounds_shelf_1.CenterPoint().x(),
+                        bounds_shelf_1.CenterPoint().y());
   base::MessageLoop::current()->RunUntilIdle();
 
   // Check that a new item got created.
   EXPECT_EQ(3, model_->item_count());
   EXPECT_TRUE(grid_view->forward_events_to_drag_and_drop_host_for_test());
 
   // Move it where the item originally was and check that it disappears again.
   generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
                         bounds_grid_1.CenterPoint().y());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
 
   // Dropping it should keep the launcher as it originally was.
   generator.ReleaseLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2, model_->item_count());
   // There are a few animations which need finishing before we can continue.
   test.RunMessageLoopUntilAnimationsDone();
   // Move the mouse outside of the launcher.
   generator.MoveMouseTo(0, 0);
 
   // Test #2: Check that the unknown item dropped into the launcher will
   // create a new item.
   generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
                         bounds_grid_1.CenterPoint().y());
   generator.PressLeftButton();
-  generator.MoveMouseTo(bounds_launcher_1.CenterPoint().x(),
-                        bounds_launcher_1.CenterPoint().y());
+  generator.MoveMouseTo(bounds_shelf_1.CenterPoint().x(),
+                        bounds_shelf_1.CenterPoint().y());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3, model_->item_count());
   EXPECT_TRUE(grid_view->forward_events_to_drag_and_drop_host_for_test());
   generator.ReleaseLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
   EXPECT_EQ(3, model_->item_count());  // It should be still there.
   test.RunMessageLoopUntilAnimationsDone();
 
   // Test #3: Check that the now known item dropped into the launcher will
   // not create a new item.
   generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
                         bounds_grid_1.CenterPoint().y());
   generator.PressLeftButton();
-  generator.MoveMouseTo(bounds_launcher_1.CenterPoint().x(),
-                        bounds_launcher_1.CenterPoint().y());
+  generator.MoveMouseTo(bounds_shelf_1.CenterPoint().x(),
+                        bounds_shelf_1.CenterPoint().y());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3, model_->item_count());  // No new item got added.
   EXPECT_TRUE(grid_view->forward_events_to_drag_and_drop_host_for_test());
   generator.ReleaseLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
   EXPECT_EQ(3, model_->item_count());  // And it remains that way.
 
   // Test #4: Check that by pressing ESC the operation gets cancelled.
   generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
                         bounds_grid_1.CenterPoint().y());
   generator.PressLeftButton();
-  generator.MoveMouseTo(bounds_launcher_1.CenterPoint().x(),
-                        bounds_launcher_1.CenterPoint().y());
+  generator.MoveMouseTo(bounds_shelf_1.CenterPoint().x(),
+                        bounds_shelf_1.CenterPoint().y());
   base::MessageLoop::current()->RunUntilIdle();
   // Issue an ESC and see that the operation gets cancelled.
   generator.PressKey(ui::VKEY_ESCAPE, 0);
   generator.ReleaseKey(ui::VKEY_ESCAPE, 0);
   EXPECT_FALSE(grid_view->dragging());
   EXPECT_FALSE(grid_view->has_dragged_view());
   generator.ReleaseLeftButton();
 }
 
 #if !defined(OS_WIN)
 // Used to test drag & drop an item between app list and shelf with multi
 // display environment.
-class LauncherAppBrowserTestWithMultiMonitor
-    : public LauncherAppBrowserTestNoDefaultBrowser {
+class ShelfAppBrowserTestWithMultiMonitor
+    : public ShelfAppBrowserTestNoDefaultBrowser {
  protected:
-  LauncherAppBrowserTestWithMultiMonitor() {}
-  virtual ~LauncherAppBrowserTestWithMultiMonitor() {}
+  ShelfAppBrowserTestWithMultiMonitor() {}
+  virtual ~ShelfAppBrowserTestWithMultiMonitor() {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
-    LauncherAppBrowserTestNoDefaultBrowser::SetUpCommandLine(command_line);
+    ShelfAppBrowserTestNoDefaultBrowser::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII("ash-host-window-bounds",
                                     "800x600,801+0-800x600");
   }
 
  private:
 
-  DISALLOW_COPY_AND_ASSIGN(LauncherAppBrowserTestWithMultiMonitor);
+  DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserTestWithMultiMonitor);
 };
 
 // Do basic drag and drop interaction tests between the application list and
 // the launcher in the secondary monitor.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTestWithMultiMonitor,
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestWithMultiMonitor,
     BasicDragAndDrop) {
   // Get a number of interfaces we need.
   DCHECK_EQ(ash::Shell::GetAllRootWindows().size(), 2U);
   aura::Window* secondary_root_window = ash::Shell::GetAllRootWindows()[1];
-  ash::Launcher* secondary_launcher =
-      ash::Launcher::ForWindow(secondary_root_window);
+  ash::Shelf* secondary_shelf = ash::Shelf::ForWindow(secondary_root_window);
 
   aura::test::EventGenerator generator(secondary_root_window, gfx::Point());
   ash::test::ShelfViewTestAPI test(
-      ash::test::LauncherTestAPI(secondary_launcher).shelf_view());
+      ash::test::ShelfTestAPI(secondary_shelf).shelf_view());
   AppListService* service = AppListService::Get(chrome::GetActiveDesktop());
 
-  // There should be two items in our launcher by this time.
+  // There should be two items in our shelf by this time.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(service->IsAppListVisible());
 
   // Open the app list menu and check that the drag and drop host was set.
   gfx::Rect app_list_bounds =
       test.shelf_view()->GetAppListButtonView()->GetBoundsInScreen();
   gfx::Display display =
       ash::Shell::GetScreen()->GetDisplayNearestWindow(secondary_root_window);
   const gfx::Point& origin = display.bounds().origin();
   app_list_bounds.Offset(-origin.x(), -origin.y());
 
   generator.MoveMouseTo(app_list_bounds.CenterPoint().x(),
                         app_list_bounds.CenterPoint().y());
   base::MessageLoop::current()->RunUntilIdle();
   generator.ClickLeftButton();
 
   EXPECT_TRUE(service->IsAppListVisible());
   app_list::AppsGridView* grid_view =
       ash::test::AppListControllerTestApi(ash::Shell::GetInstance()).
           GetRootGridView();
   ASSERT_TRUE(grid_view);
   ASSERT_TRUE(grid_view->has_drag_and_drop_host_for_test());
 
   // There should be 2 items in our application list.
   const views::ViewModel* vm_grid = grid_view->view_model_for_test();
   EXPECT_EQ(2, vm_grid->view_size());
 
-  // Drag an app list item which does not exist yet in the launcher.
+  // Drag an app list item which does not exist yet in the shelf.
   // Keeping it dragged, see that a new item gets created.
   // Continuing to drag it out should remove it again.
 
   // Get over item #1 of the application list and press the mouse button.
   views::View* item1 = vm_grid->view_at(1);
   gfx::Rect bounds_grid_1 = item1->GetBoundsInScreen();
   bounds_grid_1.Offset(-origin.x(), -origin.y());
   generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
                         bounds_grid_1.CenterPoint().y());
   base::MessageLoop::current()->RunUntilIdle();
   generator.PressLeftButton();
 
   EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
 
-  // Drag the item into the launcher and check that a new item gets created.
-  const views::ViewModel* vm_launcher =
-      test.shelf_view()->view_model_for_test();
-  views::View* launcher1 = vm_launcher->view_at(1);
-  gfx::Rect bounds_launcher_1 = launcher1->GetBoundsInScreen();
-  bounds_launcher_1.Offset(-origin.x(), -origin.y());
-  generator.MoveMouseTo(bounds_launcher_1.CenterPoint().x(),
-                        bounds_launcher_1.CenterPoint().y());
+  // Drag the item into the shelf and check that a new item gets created.
+  const views::ViewModel* vm_shelf = test.shelf_view()->view_model_for_test();
+  views::View* shelf1 = vm_shelf->view_at(1);
+  gfx::Rect bounds_shelf_1 = shelf1->GetBoundsInScreen();
+  bounds_shelf_1.Offset(-origin.x(), -origin.y());
+  generator.MoveMouseTo(bounds_shelf_1.CenterPoint().x(),
+                        bounds_shelf_1.CenterPoint().y());
   base::MessageLoop::current()->RunUntilIdle();
 
   // Check that a new item got created.
   EXPECT_EQ(3, model_->item_count());
   EXPECT_TRUE(grid_view->forward_events_to_drag_and_drop_host_for_test());
 
   // Move it where the item originally was and check that it disappears again.
   generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
                         bounds_grid_1.CenterPoint().y());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
 
-  // Dropping it should keep the launcher as it originally was.
+  // Dropping it should keep the shelf as it originally was.
   generator.ReleaseLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2, model_->item_count());
 }
 #endif
 
 // Do tests for removal of items from the shelf by dragging.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, DragOffShelf) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, DragOffShelf) {
   aura::test::EventGenerator generator(
       ash::Shell::GetPrimaryRootWindow(), gfx::Point());
   ash::test::ShelfViewTestAPI test(
-      ash::test::LauncherTestAPI(launcher_).shelf_view());
+      ash::test::ShelfTestAPI(shelf_).shelf_view());
   test.SetAnimationDuration(1);  // Speed up animations for test.
-  // Create a known application and check that we have 3 items in the launcher.
+  // Create a known application and check that we have 3 items in the shelf.
   CreateShortcut("app1");
   test.RunMessageLoopUntilAnimationsDone();
   EXPECT_EQ(3, model_->item_count());
 
   // Test #1: Ripping out the browser item should not change anything.
   int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
   EXPECT_LE(0, browser_index);
   RipOffItemIndex(browser_index, &generator, &test, RIP_OFF_ITEM);
   // => It should not have been removed and the location should be unchanged.
   EXPECT_EQ(3, model_->item_count());
@@ skipping 60 matching lines @@
     ASSERT_LT(items_added, 10000);
   }
   // Make one more item after creating a overflow button.
   std::string fake_app_id = base::StringPrintf("fake_app_%d", items_added);
   PinFakeApp(fake_app_id);
   test.RunMessageLoopUntilAnimationsDone();
 
   int total_count = model_->item_count();
   app_index = GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT);
   RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM);
-  // When an item is ripped off from the launcher that has overflow button
+  // When an item is ripped off from the shelf that has overflow button
   // (see crbug.com/3050787), it was hidden accidentally and was then
   // suppressing any further events. If handled correctly the operation will
   // however correctly done and the item will get removed (as well as the
   // overflow button).
   EXPECT_EQ(total_count - 1, model_->item_count());
   EXPECT_TRUE(test.IsOverflowButtonVisible());
 
   // Rip off again and the overflow button should has disappeared.
   RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM);
   EXPECT_EQ(total_count - 2, model_->item_count());
   EXPECT_FALSE(test.IsOverflowButtonVisible());
 }
 
-// Check that clicking on an app launcher item launches a new browser.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, ClickItem) {
+// Check that clicking on an app shelf item launches a new browser.
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, ClickItem) {
   // Get a number of interfaces we need.
   aura::test::EventGenerator generator(
       ash::Shell::GetPrimaryRootWindow(), gfx::Point());
   ash::test::ShelfViewTestAPI test(
-      ash::test::LauncherTestAPI(launcher_).shelf_view());
+      ash::test::ShelfTestAPI(shelf_).shelf_view());
   AppListService* service = AppListService::Get(chrome::GetActiveDesktop());
-  // There should be two items in our launcher by this time.
+  // There should be two items in our shelf by this time.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(service->IsAppListVisible());
 
   // Open the app list menu and check that the drag and drop host was set.
   gfx::Rect app_list_bounds =
       test.shelf_view()->GetAppListButtonView()->GetBoundsInScreen();
   generator.MoveMouseTo(app_list_bounds.CenterPoint().x(),
                         app_list_bounds.CenterPoint().y());
   generator.ClickLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
@@ skipping 10 matching lines @@
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
                         bounds_grid_1.CenterPoint().y());
   generator.ClickLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(tab_count + 1, tab_strip->count());
 }
 
 // Check LauncherItemController of Browser Shortcut functionality.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTestNoDefaultBrowser,
-    BrowserShortcutLauncherItemController) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
+                       BrowserShortcutLauncherItemController) {
   LauncherItemController* item_controller =
       controller_->GetBrowserShortcutLauncherItemController();
 
   // Get the number of browsers.
   size_t running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(0u, running_browser);
   EXPECT_FALSE(item_controller->IsOpen());
 
   // Activate. This creates new browser
   item_controller->Activate(ash::LAUNCH_FROM_UNKNOWN);
@@ skipping 10 matching lines @@
   // Activate again. This doesn't create new browser.
   // It activates window.
   item_controller->Activate(ash::LAUNCH_FROM_UNKNOWN);
   running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(1u, running_browser);
   EXPECT_TRUE(item_controller->IsOpen());
   EXPECT_FALSE(window_state->IsMinimized());
 }
 
 // Check that GetLauncherIDForWindow() returns |LauncherID| of the active tab.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, MatchingLauncherIDandActiveTab) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, MatchingLauncherIDandActiveTab) {
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
   EXPECT_EQ(2, model_->item_count());
 
   aura::Window* window = browser()->window()->GetNativeWindow();
 
   int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
   ash::LauncherID browser_id = model_->items()[browser_index].id;
   EXPECT_EQ(browser_id, ash::GetLauncherIDForWindow(window));
 
   ash::LauncherID app_id = CreateShortcut("app1");
   EXPECT_EQ(3, model_->item_count());
 
   // Creates a new tab for "app1" and checks that GetLauncherIDForWindow()
   // returns |LauncherID| of "app1".
-  ActivateLauncherItem(model_->ItemIndexByID(app_id));
+  ActivateShelfItem(model_->ItemIndexByID(app_id));
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
   EXPECT_EQ(app_id, ash::GetLauncherIDForWindow(window));
 
   // Makes tab at index 0(NTP) as an active tab and checks that
   // GetLauncherIDForWindow() returns |LauncherID| of browser shortcut.
   browser()->tab_strip_model()->ActivateTabAt(0, false);
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
   EXPECT_EQ(browser_id, ash::GetLauncherIDForWindow(window));
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, OverflowBubble) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, OverflowBubble) {
   // Make sure to have a browser window
   chrome::NewTab(browser());
 
   // No overflow yet.
-  EXPECT_FALSE(launcher_->IsShowingOverflowBubble());
+  EXPECT_FALSE(shelf_->IsShowingOverflowBubble());
 
   ash::test::ShelfViewTestAPI test(
-      ash::test::LauncherTestAPI(launcher_).shelf_view());
+      ash::test::ShelfTestAPI(shelf_).shelf_view());
 
   int items_added = 0;
   while (!test.IsOverflowButtonVisible()) {
     std::string fake_app_id = base::StringPrintf("fake_app_%d", items_added);
     PinFakeApp(fake_app_id);
 
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   // Now show overflow bubble.
   test.ShowOverflowBubble();
-  EXPECT_TRUE(launcher_->IsShowingOverflowBubble());
+  EXPECT_TRUE(shelf_->IsShowingOverflowBubble());
 
   // Unpin first pinned app and there should be no crash.
   controller_->UnpinAppWithID(std::string("fake_app_0"));
 
   test.RunMessageLoopUntilAnimationsDone();
-  EXPECT_FALSE(launcher_->IsShowingOverflowBubble());
+  EXPECT_FALSE(shelf_->IsShowingOverflowBubble());
 }
 
 // Check that a windowed V1 application can navigate away from its domain, but
 // still gets detected properly.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, V1AppNavigation) {
+IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, V1AppNavigation) {
   // We assume that the web store is always there (which it apparently is).
   controller_->PinAppWithID(extension_misc::kWebStoreAppId);
   ash::LauncherID id = controller_->GetLauncherIDForAppID(
       extension_misc::kWebStoreAppId);
   ASSERT_NE(0, id);
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(id)->status);
 
   // Create a windowed application.
   AppLaunchParams params(
       profile(),
@@ skipping 23 matching lines @@
                                GURL("http://www.foo.com/bar.html"));
   // Make sure the navigation was entirely performed.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(id)->status);
   app_browser->tab_strip_model()->CloseWebContentsAt(0,
                                                      TabStripModel::CLOSE_NONE);
   // Make sure that the app is really gone.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(id)->status);
 }