ash: Rename LauncherModel to ShelfModel.

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/launcher/launcher_button.h"
-#include "ash/launcher/launcher_model.h"
+#include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_model_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_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"
@@ skipping 93 matching lines @@
   }
 
   virtual ~LauncherPlatformAppBrowserTest() {}
 
   virtual void RunTestOnMainThreadLoop() OVERRIDE {
     launcher_ = ash::Launcher::ForPrimaryDisplay();
     controller_ = ChromeLauncherController::instance();
     return extensions::PlatformAppBrowserTest::RunTestOnMainThreadLoop();
   }
 
-  ash::LauncherModel* launcher_model() {
-    return ash::test::ShellTestApi(ash::Shell::GetInstance()).launcher_model();
+  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 launcher_model()->items()[launcher_model()->item_count() - 1];
+    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
     // will be the last one.
-    return launcher_model()->items()[launcher_model()->item_count() - 1];
+    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::LauncherMenuModel> menu(
@@ skipping 33 matching lines @@
 
 class LauncherAppBrowserTest : public ExtensionBrowserTest {
  protected:
   LauncherAppBrowserTest() : launcher_(NULL), model_(NULL), controller_(NULL) {
   }
 
   virtual ~LauncherAppBrowserTest() {}
 
   virtual void RunTestOnMainThreadLoop() OVERRIDE {
     launcher_ = ash::Launcher::ForPrimaryDisplay();
-    model_ =
-        ash::test::ShellTestApi(ash::Shell::GetInstance()).launcher_model();
+    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();
     // If we have at least one item, we have also a title which we remove here.
@@ skipping 83 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();
       test->RunMessageLoopUntilAnimationsDone();
     }
   }
 
   ash::Launcher* launcher_;
-  ash::LauncherModel* model_;
+  ash::ShelfModel* model_;
   ChromeLauncherController* controller_;
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(LauncherAppBrowserTest);
 };
 
 class LauncherAppBrowserTestNoDefaultBrowser : public LauncherAppBrowserTest {
  protected:
   LauncherAppBrowserTestNoDefaultBrowser() {}
@@ skipping 25 matching lines @@
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(LauncherAppBrowserNoMinimizeOnClick);
 };
 
 typedef LauncherPlatformAppBrowserTest LauncherAppBrowserMinimizeOnClick;
 
 // Test that we can launch a platform app and get a running item.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchUnpinned) {
-  int item_count = launcher_model()->item_count();
+  int item_count = shelf_model()->item_count();
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window = CreateShellWindow(extension);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::LauncherItem& item = GetLastLauncherItem();
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
   CloseShellWindow(window);
   --item_count;
-  EXPECT_EQ(item_count, launcher_model()->item_count());
+  EXPECT_EQ(item_count, shelf_model()->item_count());
 }
 
 // Test that we can launch a platform app that already has a shortcut.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchPinned) {
-  int item_count = launcher_model()->item_count();
+  int item_count = shelf_model()->item_count();
 
   // First get app_id.
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   const std::string app_id = extension->id();
 
   // Then create a shortcut.
   ash::LauncherID shortcut_id = CreateAppShortcutLauncherItem(app_id);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  ash::LauncherItem item = *launcher_model()->ItemByID(shortcut_id);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  ash::LauncherItem item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_CLOSED, item.status);
 
   // Open a window. Confirm the item is now running.
   ShellWindow* window = CreateShellWindow(extension);
   ash::wm::ActivateWindow(window->GetNativeWindow());
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  item = *launcher_model()->ItemByID(shortcut_id);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
 
   // Then close it, make sure there's still an item.
   CloseShellWindow(window);
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  item = *launcher_model()->ItemByID(shortcut_id);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_CLOSED, item.status);
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, PinRunning) {
   // Run.
-  int item_count = launcher_model()->item_count();
+  int item_count = shelf_model()->item_count();
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window = CreateShellWindow(extension);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID id = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   // Create a shortcut. The app item should be after it.
   ash::LauncherID foo_id = CreateAppShortcutLauncherItem("foo");
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  EXPECT_LT(launcher_model()->ItemIndexByID(foo_id),
-            launcher_model()->ItemIndexByID(id));
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  EXPECT_LT(shelf_model()->ItemIndexByID(foo_id),
+            shelf_model()->ItemIndexByID(id));
 
   // Pin the app. The item should remain.
   controller_->Pin(id);
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  const ash::LauncherItem& item2 = *launcher_model()->ItemByID(id);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::LauncherItem& item2 = *shelf_model()->ItemByID(id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item2.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
 
   // New shortcuts should come after the item.
   ash::LauncherID bar_id = CreateAppShortcutLauncherItem("bar");
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  EXPECT_LT(launcher_model()->ItemIndexByID(id),
-            launcher_model()->ItemIndexByID(bar_id));
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  EXPECT_LT(shelf_model()->ItemIndexByID(id),
+            shelf_model()->ItemIndexByID(bar_id));
 
   // Then close it, make sure the item remains.
   CloseShellWindow(window);
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, UnpinRunning) {
-  int item_count = launcher_model()->item_count();
+  int item_count = shelf_model()->item_count();
 
   // First get app_id.
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   const std::string app_id = extension->id();
 
   // Then create a shortcut.
   ash::LauncherID shortcut_id = CreateAppShortcutLauncherItem(app_id);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  ash::LauncherItem item = *launcher_model()->ItemByID(shortcut_id);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  ash::LauncherItem item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_CLOSED, item.status);
 
   // Create a second shortcut. This will be needed to force the first one to
   // move once it gets unpinned.
   ash::LauncherID foo_id = CreateAppShortcutLauncherItem("foo");
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  EXPECT_LT(launcher_model()->ItemIndexByID(shortcut_id),
-            launcher_model()->ItemIndexByID(foo_id));
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  EXPECT_LT(shelf_model()->ItemIndexByID(shortcut_id),
+            shelf_model()->ItemIndexByID(foo_id));
 
   // Open a window. Confirm the item is now running.
   ShellWindow* window = CreateShellWindow(extension);
   ash::wm::ActivateWindow(window->GetNativeWindow());
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  item = *launcher_model()->ItemByID(shortcut_id);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
 
   // Unpin the app. The item should remain.
   controller_->Unpin(shortcut_id);
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  item = *launcher_model()->ItemByID(shortcut_id);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
   // The item should have moved after the other shortcuts.
-  EXPECT_GT(launcher_model()->ItemIndexByID(shortcut_id),
-            launcher_model()->ItemIndexByID(foo_id));
+  EXPECT_GT(shelf_model()->ItemIndexByID(shortcut_id),
+            shelf_model()->ItemIndexByID(foo_id));
 
   // Then close it, make sure the item's gone.
   CloseShellWindow(window);
   --item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
 }
 
 // Test that we can launch a platform app with more than one window.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, MultipleWindows) {
-  int item_count = launcher_model()->item_count();
+  int item_count = shelf_model()->item_count();
 
   // First run app.
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window1 = CreateShellWindow(extension);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID item_id = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
   EXPECT_EQ(2, GetNumApplicationMenuItems(item1));  // Title + 1 window
 
   // Add second window.
   ShellWindow* window2 = CreateShellWindow(extension);
   // Confirm item stays.
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  const ash::LauncherItem& item2 = *launcher_model()->ItemByID(item_id);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::LauncherItem& item2 = *shelf_model()->ItemByID(item_id);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
   EXPECT_EQ(3, GetNumApplicationMenuItems(item2));  // Title + 2 windows
 
   // Close second window.
   CloseShellWindow(window2);
   // Confirm item stays.
-  ASSERT_EQ(item_count, launcher_model()->item_count());
-  const ash::LauncherItem& item3 = *launcher_model()->ItemByID(item_id);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::LauncherItem& item3 = *shelf_model()->ItemByID(item_id);
   EXPECT_EQ(ash::STATUS_ACTIVE, item3.status);
   EXPECT_EQ(2, GetNumApplicationMenuItems(item3));  // Title + 1 window
 
   // Close first window.
   CloseShellWindow(window1);
   // Confirm item is removed.
   --item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, MultipleApps) {
-  int item_count = launcher_model()->item_count();
+  int item_count = shelf_model()->item_count();
 
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window1 = CreateShellWindow(extension1);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID item_id1 = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   // Then run second app.
   const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2");
   ShellWindow* window2 = CreateShellWindow(extension2);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  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,
-            launcher_model()->ItemByID(item_id1)->status);
+  EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
 
   // Close second app.
   CloseShellWindow(window2);
   --item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
   // First app should be active again.
-  EXPECT_EQ(ash::STATUS_ACTIVE,
-            launcher_model()->ItemByID(item_id1)->status);
+  EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id1)->status);
 
   // Close first app.
   CloseShellWindow(window1);
   --item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
 }
 
 // Confirm that app windows can be reactivated by clicking their icons and that
 // the correct activation order is maintained.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, WindowActivation) {
-  int item_count = launcher_model()->item_count();
+  int item_count = shelf_model()->item_count();
 
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window1 = CreateShellWindow(extension1);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID item_id1 = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   // Then run second app.
   const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2");
   ShellWindow* window2 = CreateShellWindow(extension2);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  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,
-            launcher_model()->ItemByID(item_id1)->status);
+  EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
 
   // Activate first one.
-  ActivateLauncherItem(launcher_model()->ItemIndexByID(item_id1));
-  EXPECT_EQ(ash::STATUS_ACTIVE, launcher_model()->ItemByID(item_id1)->status);
-  EXPECT_EQ(ash::STATUS_RUNNING,
-            launcher_model()->ItemByID(item_id2)->status);
+  ActivateLauncherItem(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(launcher_model()->ItemIndexByID(item_id2));
-  EXPECT_EQ(ash::STATUS_RUNNING,
-            launcher_model()->ItemByID(item_id1)->status);
-  EXPECT_EQ(ash::STATUS_ACTIVE, launcher_model()->ItemByID(item_id2)->status);
+  ActivateLauncherItem(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(launcher_model()->ItemIndexByID(item_id1));
+  ActivateLauncherItem(shelf_model()->ItemIndexByID(item_id1));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
-  ActivateLauncherItem(launcher_model()->ItemIndexByID(item_id1));
+  ActivateLauncherItem(shelf_model()->ItemIndexByID(item_id1));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
 
   // Activate the second app again
-  ActivateLauncherItem(launcher_model()->ItemIndexByID(item_id2));
+  ActivateLauncherItem(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(launcher_model()->ItemIndexByID(item_id1));
+  ActivateLauncherItem(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, launcher_model()->item_count());
+  EXPECT_EQ(item_count, shelf_model()->item_count());
   // First app should be active again.
-  EXPECT_EQ(ash::STATUS_ACTIVE, launcher_model()->ItemByID(item_id1)->status);
+  EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id1)->status);
 
   // Close first app.
   CloseShellWindow(window1b);
   CloseShellWindow(window1);
   --item_count;
-  EXPECT_EQ(item_count, launcher_model()->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) {
   // 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());
@@ skipping 115 matching lines @@
   EXPECT_TRUE(panel->GetBaseWindow()->IsMinimized());
   EXPECT_EQ(ash::STATUS_RUNNING, item1.status);
   // Click the item again and confirm that the panel is activated.
   item1_controller->ItemSelected(click_event);
   EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(panel->GetBaseWindow()->IsActive());
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, BrowserActivation) {
-  int item_count = launcher_model()->item_count();
+  int item_count = shelf_model()->item_count();
 
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   CreateShellWindow(extension1);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID item_id1 = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   ash::wm::ActivateWindow(browser()->window()->GetNativeWindow());
-  EXPECT_EQ(ash::STATUS_RUNNING,
-            launcher_model()->ItemByID(item_id1)->status);
+  EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
 }
 
 // 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 = launcher_model()->item_count();
+  int base_launcher_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 = launcher_model()->item_count();
+  int launcher_item_count = shelf_model()->item_count();
   ASSERT_EQ(base_launcher_item_count + 2, launcher_item_count);
   // The Panel will be the last item, the app second-to-last.
   const ash::LauncherItem& app_item =
-      launcher_model()->items()[launcher_item_count - 2];
+      shelf_model()->items()[launcher_item_count - 2];
   const ash::LauncherItem& panel_item =
-      launcher_model()->items()[launcher_item_count - 1];
+      shelf_model()->items()[launcher_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());
@@ skipping 499 matching lines @@
 
 // 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 = launcher_model()->ItemIndexByID(app_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);
   EXPECT_TRUE(window1->IsActive());
   ActivateLauncherItem(app_index);
   EXPECT_TRUE(window1->IsActive());
 
   ui::BaseWindow* window1a = CreateShellWindow(extension1)->GetBaseWindow();
 
   EXPECT_TRUE(window1a->IsActive());
   EXPECT_FALSE(window1->IsActive());
   ActivateLauncherItem(app_index);
   EXPECT_TRUE(window1->IsActive());
   ActivateLauncherItem(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 = launcher_model()->item_count();
+  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;
   ShellWindow* window = CreateShellWindowFromParams(extension, params);
   ++item_count;
-  ASSERT_EQ(item_count, launcher_model()->item_count());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::LauncherItem& item = GetLastLauncherPanelItem();
   EXPECT_EQ(ash::TYPE_APP_PANEL, item.type);
   // Opening a panel does not activate it.
   EXPECT_EQ(ash::STATUS_RUNNING, item.status);
   CloseShellWindow(window);
   --item_count;
-  EXPECT_EQ(item_count, launcher_model()->item_count());
+  EXPECT_EQ(item_count, shelf_model()->item_count());
 }
 
 // Test attention states of windows.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, WindowAttentionStatus) {
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   ShellWindow::CreateParams params;
   params.window_type = ShellWindow::WINDOW_TYPE_PANEL;
   params.focused = false;
   ShellWindow* panel = CreateShellWindowFromParams(extension, params);
   EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
@@ skipping 475 matching lines @@
   // Now show overflow bubble.
   test.ShowOverflowBubble();
   EXPECT_TRUE(launcher_->IsShowingOverflowBubble());
 
   // Unpin first pinned app and there should be no crash.
   controller_->UnpinAppWithID(std::string("fake_app_0"));
 
   test.RunMessageLoopUntilAnimationsDone();
   EXPECT_FALSE(launcher_->IsShowingOverflowBubble());
 }