ash: Rename GetLauncherItemIndexForType to GetShelfItemIndexForType().

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/launcher/launcher_model_util.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"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 235 matching lines @@
   void ActivateLauncherItem(int id) {
     launcher_->ActivateLauncherItem(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 GetIndexOfLauncherItemType(ash::LauncherItemType type) {
-    return ash::GetLauncherItemIndexForType(type, *model_);
+  int GetIndexOfShelfItemType(ash::LauncherItemType type) {
+    return ash::GetShelfItemIndexForType(type, *model_);
   }
 
   // Try to rip off |item_index|.
   void RipOffItemIndex(int index,
                        aura::test::EventGenerator* generator,
                        ash::test::ShelfViewTestAPI* test,
                        RipOffCommand command) {
     ash::internal::LauncherButton* button = test->GetButton(index);
     gfx::Point start_point = button->GetBoundsInScreen().CenterPoint();
     gfx::Point rip_off_point(start_point.x(), 0);
@@ skipping 737 matching lines @@
   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) {
   TabStripModel* tab_strip_model1 = browser()->tab_strip_model();
   EXPECT_EQ(1, tab_strip_model1->count());
-  int browser_index = GetIndexOfLauncherItemType(ash::TYPE_BROWSER_SHORTCUT);
+  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));
@@ skipping 122 matching lines @@
   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) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   // Get the browser item index
-  int browser_index = GetIndexOfLauncherItemType(ash::TYPE_BROWSER_SHORTCUT);
+  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(
       shortcut_id, GURL("http://www.example.com/path1/*"));
 
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
@@ skipping 479 matching lines @@
   aura::test::EventGenerator generator(
       ash::Shell::GetPrimaryRootWindow(), gfx::Point());
   ash::test::ShelfViewTestAPI test(
       ash::test::LauncherTestAPI(launcher_).shelf_view());
 
   // Create a known application and check that we have 3 items in the launcher.
   CreateShortcut("app1");
   EXPECT_EQ(3, model_->item_count());
 
   // Test #1: Ripping out the browser item should not change anything.
-  int browser_index = GetIndexOfLauncherItemType(ash::TYPE_BROWSER_SHORTCUT);
+  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());
   EXPECT_EQ(browser_index,
-            GetIndexOfLauncherItemType(ash::TYPE_BROWSER_SHORTCUT));
+            GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT));
   // Make sure that the hide state has been unset after the snap back animation
   // finished.
   ash::internal::LauncherButton* button = test.GetButton(browser_index);
   EXPECT_FALSE(button->state() & ash::internal::LauncherButton::STATE_HIDDEN);
 
   // Test #2: Ripping out the application and canceling the operation should
   // not change anything.
-  int app_index = GetIndexOfLauncherItemType(ash::TYPE_APP_SHORTCUT);
+  int app_index = GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT);
   EXPECT_LE(0, app_index);
   RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM_AND_CANCEL);
   // => It should not have been removed and the location should be unchanged.
   ASSERT_EQ(3, model_->item_count());
-  EXPECT_EQ(app_index, GetIndexOfLauncherItemType(ash::TYPE_APP_SHORTCUT));
+  EXPECT_EQ(app_index, GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT));
 
   // Test #3: Ripping out the application and moving it back in should not
   // change anything.
   RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM_AND_RETURN);
   // => It should not have been removed and the location should be unchanged.
   ASSERT_EQ(3, model_->item_count());
   // Through the operation the index might have changed.
-  app_index = GetIndexOfLauncherItemType(ash::TYPE_APP_SHORTCUT);
+  app_index = GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT);
 
   // Test #4: Ripping out the application should remove the item.
   RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM);
   // => It should not have been removed and the location should be unchanged.
   EXPECT_EQ(2, model_->item_count());
-  EXPECT_EQ(-1, GetIndexOfLauncherItemType(ash::TYPE_APP_SHORTCUT));
+  EXPECT_EQ(-1, GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT));
 
   // Test #5: Uninstalling an application while it is being ripped off should
   // not crash.
   ash::LauncherID app_id = CreateShortcut("app2");
-  int app2_index = GetIndexOfLauncherItemType(ash::TYPE_APP_SHORTCUT);
+  int app2_index = GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT);
   EXPECT_EQ(3, model_->item_count());  // And it remains that way.
   RipOffItemIndex(app2_index,
                   &generator,
                   &test,
                   RIP_OFF_ITEM_AND_DONT_RELEASE_MOUSE);
   RemoveShortcut(app_id);
   EXPECT_EQ(2, model_->item_count());  // The item should now be gone.
   generator.ReleaseLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2, model_->item_count());  // And it remains that way.
-  EXPECT_EQ(-1, GetIndexOfLauncherItemType(ash::TYPE_APP_SHORTCUT));
+  EXPECT_EQ(-1, GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT));
 
   // Test #6: Ripping out the application when the overflow button exists.
   // After ripping out, overflow button should be removed.
   int items_added = 0;
   EXPECT_FALSE(test.IsOverflowButtonVisible());
 
   // Create fake app shortcuts until overflow button is created.
   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);
   }
   // 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);
 
   int total_count = model_->item_count();
-  app_index = GetIndexOfLauncherItemType(ash::TYPE_APP_SHORTCUT);
+  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
   // (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.
@@ skipping 74 matching lines @@
 
 // Check that GetIDByWindow() returns |LauncherID| of the active tab.
 IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, 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 = GetIndexOfLauncherItemType(ash::TYPE_BROWSER_SHORTCUT);
+  int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
   ash::LauncherID browser_id = model_->items()[browser_index].id;
   EXPECT_EQ(browser_id, controller_->GetIDByWindow(window));
 
   ash::LauncherID app_id = CreateShortcut("app1");
   EXPECT_EQ(3, model_->item_count());
 
   // Creates a new tab for "app1" and checks that GetIDByWindow() returns
   // |LauncherID| of "app1".
   ActivateLauncherItem(model_->ItemIndexByID(app_id));
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
@@ skipping 29 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());
 }