Rename Launcher to Shelf.

ash/shelf/shelf_view_unittest.cc

 // Copyright (c) 2012 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 "ash/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/ash_switches.h"
-#include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_types.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/overflow_bubble.h"
 #include "ash/shelf/overflow_bubble_view.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_icon_observer.h"
 #include "ash/shelf/shelf_item_delegate_manager.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_tooltip_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
-#include "ash/test/launcher_test_api.h"
 #include "ash/test/overflow_bubble_view_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/test/test_shelf_delegate.h"
 #include "ash/test/test_shelf_item_delegate.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 11 matching lines @@
 #include "ui/views/widget/widget_delegate.h"
 
 namespace ash {
 namespace test {
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfIconObserver tests.
 
 class TestShelfIconObserver : public ShelfIconObserver {
  public:
-  explicit TestShelfIconObserver(Launcher* launcher)
-      : launcher_(launcher),
+  explicit TestShelfIconObserver(Shelf* shelf)
+      : shelf_(shelf),
         change_notified_(false) {
-    if (launcher_)
-      launcher_->AddIconObserver(this);
+    if (shelf_)
+      shelf_->AddIconObserver(this);
   }
 
   virtual ~TestShelfIconObserver() {
-    if (launcher_)
-      launcher_->RemoveIconObserver(this);
+    if (shelf_)
+      shelf_->RemoveIconObserver(this);
   }
 
   // ShelfIconObserver implementation.
   virtual void OnShelfIconPositionsChanged() OVERRIDE {
     change_notified_ = true;
   }
 
   int change_notified() const { return change_notified_; }
   void Reset() { change_notified_ = false; }
 
  private:
-  Launcher* launcher_;
+  Shelf* shelf_;
   bool change_notified_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShelfIconObserver);
 };
 
 class ShelfViewIconObserverTest : public AshTestBase {
  public:
   ShelfViewIconObserverTest() {}
   virtual ~ShelfViewIconObserverTest() {}
 
   virtual void SetUp() OVERRIDE {
     AshTestBase::SetUp();
-    Launcher* launcher = Launcher::ForPrimaryDisplay();
-    observer_.reset(new TestShelfIconObserver(launcher));
+    Shelf* shelf = Shelf::ForPrimaryDisplay();
+    observer_.reset(new TestShelfIconObserver(shelf));
 
-    shelf_view_test_.reset(new ShelfViewTestAPI(
-        LauncherTestAPI(launcher).shelf_view()));
+    shelf_view_test_.reset(
+        new ShelfViewTestAPI(ShelfTestAPI(shelf).shelf_view()));
     shelf_view_test_->SetAnimationDuration(1);
   }
 
   virtual void TearDown() OVERRIDE {
     observer_.reset();
     AshTestBase::TearDown();
   }
 
   TestShelfIconObserver* observer() { return observer_.get(); }
 
   ShelfViewTestAPI* shelf_view_test() {
     return shelf_view_test_.get();
   }
 
-  Launcher* LauncherForSecondaryDisplay() {
-    return Launcher::ForWindow(Shell::GetAllRootWindows()[1]);
+  Shelf* ShelfForSecondaryDisplay() {
+    return Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
   }
 
  private:
   scoped_ptr<TestShelfIconObserver> observer_;
   scoped_ptr<ShelfViewTestAPI> shelf_view_test_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfViewIconObserverTest);
 };
 
 TEST_F(ShelfViewIconObserverTest, AddRemove) {
@@ skipping 21 matching lines @@
 
 // Sometimes fails on trybots on win7_aura. http://crbug.com/177135
 #if defined(OS_WIN)
 #define MAYBE_AddRemoveWithMultipleDisplays \
     DISABLED_AddRemoveWithMultipleDisplays
 #else
 #define MAYBE_AddRemoveWithMultipleDisplays \
     AddRemoveWithMultipleDisplays
 #endif
 // Make sure creating/deleting an window on one displays notifies a
-// launcher on external display as well as one on primary.
+// shelf on external display as well as one on primary.
 TEST_F(ShelfViewIconObserverTest, MAYBE_AddRemoveWithMultipleDisplays) {
   UpdateDisplay("400x400,400x400");
-  TestShelfIconObserver second_observer(LauncherForSecondaryDisplay());
+  TestShelfIconObserver second_observer(ShelfForSecondaryDisplay());
 
   TestShelfDelegate* shelf_delegate = TestShelfDelegate::instance();
   ASSERT_TRUE(shelf_delegate);
 
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(0, 0, 200, 200);
   params.context = CurrentContext();
 
   scoped_ptr<views::Widget> widget(new views::Widget());
   widget->Init(params);
   shelf_delegate->AddLauncherItem(widget->GetNativeWindow());
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->change_notified());
   EXPECT_TRUE(second_observer.change_notified());
   observer()->Reset();
   second_observer.Reset();
 
   widget->GetNativeWindow()->parent()->RemoveChild(widget->GetNativeWindow());
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->change_notified());
   EXPECT_TRUE(second_observer.change_notified());
 
   observer()->Reset();
   second_observer.Reset();
 }
 
 TEST_F(ShelfViewIconObserverTest, BoundsChanged) {
-  ShelfWidget* shelf = Shell::GetPrimaryRootWindowController()->shelf();
-  Launcher* launcher = Launcher::ForPrimaryDisplay();
-  gfx::Size shelf_size =
-      shelf->GetWindowBoundsInScreen().size();
+  ShelfWidget* widget = Shell::GetPrimaryRootWindowController()->shelf();
+  Shelf* shelf = Shelf::ForPrimaryDisplay();
+  gfx::Size shelf_size = widget->GetWindowBoundsInScreen().size();
   shelf_size.set_width(shelf_size.width() / 2);
   ASSERT_GT(shelf_size.width(), 0);
-  launcher->SetShelfViewBounds(gfx::Rect(shelf_size));
+  shelf->SetShelfViewBounds(gfx::Rect(shelf_size));
   // No animation happens for ShelfView bounds change.
   EXPECT_TRUE(observer()->change_notified());
   observer()->Reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfView tests.
 
 // Simple ShelfDelegate implmentation for ShelfViewTest.OverflowBubbleSize
 // and CheckDragAndDropFromOverflowBubbleToShelf
 class TestShelfDelegateForShelfView : public ShelfDelegate {
  public:
   explicit TestShelfDelegateForShelfView(ShelfModel* model)
       : model_(model) {}
   virtual ~TestShelfDelegateForShelfView() {}
 
   // ShelfDelegate overrides:
-  virtual void OnLauncherCreated(Launcher* launcher) OVERRIDE {}
+  virtual void OnShelfCreated(Shelf* shelf) OVERRIDE {}
 
-  virtual void OnLauncherDestroyed(Launcher* launcher) OVERRIDE {}
+  virtual void OnShelfDestroyed(Shelf* shelf) OVERRIDE {}
 
   virtual LauncherID GetLauncherIDForAppID(const std::string& app_id) OVERRIDE {
     LauncherID id = 0;
     EXPECT_TRUE(base::StringToInt(app_id, &id));
     return id;
   }
 
   virtual const std::string& GetAppIDForLauncherID(LauncherID id) OVERRIDE {
     // Use |app_id_| member variable because returning a reference to local
     // variable is not allowed.
@@ skipping 36 matching lines @@
 
 class ShelfViewTest : public AshTestBase {
  public:
   ShelfViewTest() : model_(NULL), shelf_view_(NULL), browser_index_(1) {}
   virtual ~ShelfViewTest() {}
 
   virtual void SetUp() OVERRIDE {
     AshTestBase::SetUp();
     test::ShellTestApi test_api(Shell::GetInstance());
     model_ = test_api.shelf_model();
-    Launcher* launcher = Launcher::ForPrimaryDisplay();
-    shelf_view_ = test::LauncherTestAPI(launcher).shelf_view();
+    Shelf* shelf = Shelf::ForPrimaryDisplay();
+    shelf_view_ = ShelfTestAPI(shelf).shelf_view();
 
     // The bounds should be big enough for 4 buttons + overflow chevron.
     shelf_view_->SetBounds(0, 0, 500,
         internal::ShelfLayoutManager::GetPreferredShelfSize());
 
     test_api_.reset(new ShelfViewTestAPI(shelf_view_));
     test_api_->SetAnimationDuration(1);  // Speeds up animation for test.
 
     item_manager_ = Shell::GetInstance()->shelf_item_delegate_manager();
     DCHECK(item_manager_);
 
-    // Add browser shortcut launcher item at index 0 for test.
+    // Add browser shortcut shelf item at index 0 for test.
     AddBrowserShortcut();
   }
 
   virtual void TearDown() OVERRIDE {
     test_api_.reset();
     AshTestBase::TearDown();
   }
 
  protected:
   void CreateAndSetShelfItemDelegateForID(LauncherID id) {
@@ skipping 81 matching lines @@
          ++model_index) {
       LauncherItem item = model_->items()[model_index];
       LauncherID id = item.id;
       EXPECT_EQ(id_map[map_index].first, id);
       EXPECT_EQ(id_map[map_index].second, GetButtonByID(id));
       ++map_index;
     }
     ASSERT_EQ(map_index, id_map.size());
   }
 
-  void VerifyLauncherItemBoundsAreValid() {
+  void VerifyShelfItemBoundsAreValid() {
     for (int i=0;i <= test_api_->GetLastVisibleIndex(); ++i) {
       if (test_api_->GetButton(i)) {
         gfx::Rect shelf_view_bounds = shelf_view_->GetLocalBounds();
         gfx::Rect item_bounds = test_api_->GetBoundsByIndex(i);
         EXPECT_GE(item_bounds.x(), 0);
         EXPECT_GE(item_bounds.y(), 0);
         EXPECT_LE(item_bounds.right(), shelf_view_bounds.width());
         EXPECT_LE(item_bounds.bottom(), shelf_view_bounds.height());
       }
     }
@@ skipping 31 matching lines @@
     views::View* destination = test_api_->GetButton(destination_index);
     ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED,
                               destination->bounds().origin(),
                               destination->GetBoundsInScreen().origin(), 0, 0);
     button_host->PointerDraggedOnButton(button, pointer, drag_event);
     return button;
   }
 
   void SetupForDragTest(
       std::vector<std::pair<LauncherID, views::View*> >* id_map) {
-    // Initialize |id_map| with the automatically-created launcher buttons.
+    // Initialize |id_map| with the automatically-created shelf buttons.
     for (size_t i = 0; i < model_->items().size(); ++i) {
       internal::ShelfButton* button = test_api_->GetButton(i);
       id_map->push_back(std::make_pair(model_->items()[i].id, button));
     }
     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(*id_map));
 
-    // Add 5 app launcher buttons for testing.
+    // Add 5 app shelf buttons for testing.
     for (int i = 0; i < 5; ++i) {
       LauncherID id = AddAppShortcut();
       // App Icon is located at index 0, and browser shortcut is located at
       // index 1. So we should start to add app shortcut at index 2.
       id_map->insert(id_map->begin() + (i + browser_index_ + 1),
                      std::make_pair(id, GetButtonByID(id)));
     }
     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(*id_map));
   }
 
@@ skipping 106 matching lines @@
     DCHECK_GE(index, 0);
     return model_->items()[index].id;
   }
 
   void ReplaceShelfDelegateForRipOffTest() {
     // Replace ShelfDelegate.
     test::ShellTestApi test_api(Shell::GetInstance());
     test_api.SetShelfDelegate(NULL);
     ShelfDelegate* delegate = new TestShelfDelegateForShelfView(model_);
     test_api.SetShelfDelegate(delegate);
-    test::LauncherTestAPI(
-        Launcher::ForPrimaryDisplay()).SetShelfDelegate(delegate);
+    test::ShelfTestAPI(Shelf::ForPrimaryDisplay()).SetShelfDelegate(delegate);
     test_api_->SetShelfDelegate(delegate);
   }
 
   ShelfModel* model_;
   internal::ShelfView* shelf_view_;
   int browser_index_;
   ShelfItemDelegateManager* item_manager_;
 
   scoped_ptr<ShelfViewTestAPI> test_api_;
 
@@ skipping 366 matching lines @@
   // Verifies non-overflow buttons are visible.
   for (int i = 0; i <= test_api_->GetLastVisibleIndex(); ++i) {
     internal::ShelfButton* button = test_api_->GetButton(i);
     if (button) {
       EXPECT_TRUE(button->visible()) << "button index=" << i;
       EXPECT_EQ(1.0f, button->layer()->opacity()) << "button index=" << i;
     }
   }
 }
 
-// Check that model changes are handled correctly while a launcher icon is being
+// Check that model changes are handled correctly while a shelf icon is being
 // dragged.
 TEST_F(ShelfViewTest, ModelChangesWhileDragging) {
   internal::ShelfButtonHost* button_host = shelf_view_;
 
   std::vector<std::pair<LauncherID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // Dragging browser shortcut at index 1.
   EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
   views::View* dragged_button = SimulateDrag(
@@ skipping 25 matching lines @@
 
   // Deleting an item keeps the remaining intact.
   dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 1, 3);
   model_->RemoveItemAt(1);
   id_map.erase(id_map.begin() + 1);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(dragged_button,
                                        internal::ShelfButtonHost::MOUSE,
                                        false);
 
-  // Adding a launcher item cancels the drag and respects the order.
+  // Adding a shelf item cancels the drag and respects the order.
   dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 1, 3);
   LauncherID new_id = AddAppShortcut();
   id_map.insert(id_map.begin() + 6,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(dragged_button,
                                        internal::ShelfButtonHost::MOUSE,
                                        false);
 
-  // Adding a launcher item at the end (i.e. a panel)  canels drag and respects
+  // Adding a shelf item at the end (i.e. a panel)  canels drag and respects
   // the order.
   dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 1, 3);
   new_id = AddPanel();
   id_map.insert(id_map.begin() + 7,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(dragged_button,
                                        internal::ShelfButtonHost::MOUSE,
                                        false);
 }
@@ skipping 35 matching lines @@
 
   // Deleting an item keeps the remaining intact.
   dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 0, 2);
   model_->RemoveItemAt(1);
   id_map.erase(id_map.begin() + 1);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(dragged_button,
                                        internal::ShelfButtonHost::MOUSE,
                                        false);
 
-  // Adding a launcher item cancels the drag and respects the order.
+  // Adding a shelf item cancels the drag and respects the order.
   dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 0, 2);
   LauncherID new_id = AddAppShortcut();
   id_map.insert(id_map.begin() + 5,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(dragged_button,
                                        internal::ShelfButtonHost::MOUSE,
                                        false);
 
-  // Adding a launcher item at the end (i.e. a panel)  canels drag and respects
+  // Adding a shelf item at the end (i.e. a panel)  canels drag and respects
   // the order.
   dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 0, 2);
   new_id = AddPanel();
   id_map.insert(id_map.begin() + 7,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(dragged_button,
                                        internal::ShelfButtonHost::MOUSE,
                                        false);
 }
@@ skipping 63 matching lines @@
               id_map.begin() + 2,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(dragged_button,
                                        internal::ShelfButtonHost::MOUSE,
                                        false);
   EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
 }
 
 // Confirm that item status changes are reflected in the buttons.
-TEST_F(ShelfViewTest, LauncherItemStatus) {
+TEST_F(ShelfViewTest, ShelfItemStatus) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(),
             test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
   LauncherID last_added = AddPlatformApp();
   LauncherItem item = GetItemByID(last_added);
   int index = model_->ItemIndexByID(last_added);
   internal::ShelfButton* button = GetButtonByID(last_added);
   ASSERT_EQ(internal::ShelfButton::STATE_RUNNING, button->state());
   item.status = STATUS_ACTIVE;
   model_->Set(index, item);
   ASSERT_EQ(internal::ShelfButton::STATE_ACTIVE, button->state());
   item.status = STATUS_ATTENTION;
   model_->Set(index, item);
   ASSERT_EQ(internal::ShelfButton::STATE_ATTENTION, button->state());
 }
 
 TEST_F(ShelfViewLegacyShelfLayoutTest,
-       LauncherItemPositionReflectedOnStateChanged) {
+       ShelfItemPositionReflectedOnStateChanged) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(),
             test_api_->GetLastVisibleIndex() + 1);
 
-  // Add 2 items to the launcher.
+  // Add 2 items to the shelf.
   LauncherID item1_id = AddPlatformApp();
   LauncherID item2_id = AddPlatformAppNoWait();
   internal::ShelfButton* item1_button = GetButtonByID(item1_id);
   internal::ShelfButton* item2_button = GetButtonByID(item2_id);
 
   internal::ShelfButton::State state_mask =
       static_cast<internal::ShelfButton::State>(
           internal::ShelfButton::STATE_NORMAL |
           internal::ShelfButton::STATE_HOVERED |
           internal::ShelfButton::STATE_RUNNING |
           internal::ShelfButton::STATE_ACTIVE |
           internal::ShelfButton::STATE_ATTENTION |
           internal::ShelfButton::STATE_FOCUSED);
 
   // Clear the button states.
   item1_button->ClearState(state_mask);
   item2_button->ClearState(state_mask);
 
   // Since default alignment in tests is bottom, state is reflected in y-axis.
   ASSERT_EQ(item1_button->GetIconBounds().y(),
             item2_button->GetIconBounds().y());
   item1_button->AddState(internal::ShelfButton::STATE_HOVERED);
   ASSERT_NE(item1_button->GetIconBounds().y(),
             item2_button->GetIconBounds().y());
   item1_button->ClearState(internal::ShelfButton::STATE_HOVERED);
 }
 
 // Confirm that item status changes are reflected in the buttons
 // for platform apps.
-TEST_F(ShelfViewTest, LauncherItemStatusPlatformApp) {
+TEST_F(ShelfViewTest, ShelfItemStatusPlatformApp) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(),
             test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
   LauncherID last_added = AddPlatformApp();
   LauncherItem item = GetItemByID(last_added);
   int index = model_->ItemIndexByID(last_added);
   internal::ShelfButton* button = GetButtonByID(last_added);
   ASSERT_EQ(internal::ShelfButton::STATE_RUNNING, button->state());
   item.status = STATUS_ACTIVE;
   model_->Set(index, item);
   ASSERT_EQ(internal::ShelfButton::STATE_ACTIVE, button->state());
   item.status = STATUS_ATTENTION;
   model_->Set(index, item);
   ASSERT_EQ(internal::ShelfButton::STATE_ATTENTION, button->state());
 }
 
-// Confirm that launcher item bounds are correctly updated on shelf changes.
-TEST_F(ShelfViewTest, LauncherItemBoundsCheck) {
-  VerifyLauncherItemBoundsAreValid();
+// Confirm that shelf item bounds are correctly updated on shelf changes.
+TEST_F(ShelfViewTest, ShelfItemBoundsCheck) {
+  VerifyShelfItemBoundsAreValid();
   shelf_view_->shelf_layout_manager()->SetAutoHideBehavior(
       SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   test_api_->RunMessageLoopUntilAnimationsDone();
-  VerifyLauncherItemBoundsAreValid();
+  VerifyShelfItemBoundsAreValid();
   shelf_view_->shelf_layout_manager()->SetAutoHideBehavior(
       SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   test_api_->RunMessageLoopUntilAnimationsDone();
-  VerifyLauncherItemBoundsAreValid();
+  VerifyShelfItemBoundsAreValid();
 }
 
 TEST_F(ShelfViewTest, ShelfTooltipTest) {
   ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
             test_api_->GetButtonCount());
 
-  // Prepare some items to the launcher.
+  // Prepare some items to the shelf.
   LauncherID app_button_id = AddAppShortcut();
   LauncherID platform_button_id = AddPlatformApp();
 
   internal::ShelfButton* app_button = GetButtonByID(app_button_id);
   internal::ShelfButton* platform_button = GetButtonByID(platform_button_id);
 
   internal::ShelfButtonHost* button_host = shelf_view_;
   internal::ShelfTooltipManager* tooltip_manager =
       shelf_view_->tooltip_manager();
 
@@ skipping 21 matching lines @@
   tooltip_manager->Close();
 
   // Next time: enter app_button -> move immediately to tab_button.
   button_host->MouseEnteredButton(app_button);
   button_host->MouseExitedButton(app_button);
   button_host->MouseEnteredButton(platform_button);
   EXPECT_FALSE(tooltip_manager->IsVisible());
   EXPECT_EQ(platform_button, GetTooltipAnchorView());
 }
 
-// Verify a fix for crash caused by a tooltip update for a deleted launcher
+// Verify a fix for crash caused by a tooltip update for a deletedshelf
 // button, see crbug.com/288838.
 TEST_F(ShelfViewTest, RemovingItemClosesTooltip) {
   internal::ShelfButtonHost* button_host = shelf_view_;
   internal::ShelfTooltipManager* tooltip_manager =
       shelf_view_->tooltip_manager();
 
-  // Add an item to the launcher.
+  // Add an item to the shelf.
   LauncherID app_button_id = AddAppShortcut();
   internal::ShelfButton* app_button = GetButtonByID(app_button_id);
 
   // Spawn a tooltip on that item.
   button_host->MouseEnteredButton(app_button);
   ShowTooltip();
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Remove the app shortcut while the tooltip is open. The tooltip should be
   // closed.
   RemoveByID(app_button_id);
   EXPECT_FALSE(tooltip_manager->IsVisible());
 
   // Change the shelf layout. This should not crash.
   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT,
                                           Shell::GetPrimaryRootWindow());
 }
 
 // Changing the shelf alignment closes any open tooltip.
 TEST_F(ShelfViewTest, ShelfAlignmentClosesTooltip) {
   internal::ShelfButtonHost* button_host = shelf_view_;
   internal::ShelfTooltipManager* tooltip_manager =
       shelf_view_->tooltip_manager();
 
-  // Add an item to the launcher.
+  // Add an item to the shelf.
   LauncherID app_button_id = AddAppShortcut();
   internal::ShelfButton* app_button = GetButtonByID(app_button_id);
 
   // Spawn a tooltip on the item.
   button_host->MouseEnteredButton(app_button);
   ShowTooltip();
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Changing shelf alignment hides the tooltip.
   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT,
@@ skipping 273 matching lines @@
   EXPECT_TRUE(drag_reinsert_bounds.Contains(last_point));
 }
 
 // Check the drag insertion bounds of shelf view in multi monitor environment.
 TEST_F(ShelfViewTest, CheckDragInsertBoundsWithMultiMonitor) {
   // win8-aura doesn't support multiple display.
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,800x600");
-  Launcher* secondary_launcher =
-      Launcher::ForWindow(Shell::GetAllRootWindows()[1]);
+  Shelf* secondary_shelf = Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
   internal::ShelfView* shelf_view_for_secondary =
-      test::LauncherTestAPI(secondary_launcher).shelf_view();
+      ShelfTestAPI(secondary_shelf).shelf_view();
 
   // The bounds should be big enough for 4 buttons + overflow chevron.
   shelf_view_for_secondary->SetBounds(0, 0, 500,
       internal::ShelfLayoutManager::GetPreferredShelfSize());
 
   ShelfViewTestAPI test_api_for_secondary(shelf_view_for_secondary);
   // Speeds up animation for test.
   test_api_for_secondary.SetAnimationDuration(1);
 
   AddButtonsUntilOverflow();
@@ skipping 60 matching lines @@
 
   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT, second_root);
   ASSERT_EQ(SHELF_ALIGNMENT_LEFT,
             Shell::GetInstance()->GetShelfAlignment(second_root));
 
   // Initially, app list and browser shortcut are added.
   EXPECT_EQ(2, model_->item_count());
   int browser_index = model_->GetItemIndexForType(TYPE_BROWSER_SHORTCUT);
   EXPECT_GT(browser_index, 0);
 
-  Launcher* secondary_launcher = Launcher::ForWindow(second_root);
+  Shelf* secondary_shelf = Shelf::ForWindow(second_root);
   internal::ShelfView* shelf_view_for_secondary =
-      test::LauncherTestAPI(secondary_launcher).shelf_view();
+      ShelfTestAPI(secondary_shelf).shelf_view();
 
   ShelfViewTestAPI test_api_for_secondary_shelf_view(shelf_view_for_secondary);
   internal::ShelfButton* button =
     test_api_for_secondary_shelf_view.GetButton(browser_index);
 
   // Fetch the start point of dragging.
   gfx::Point start_point = button->GetBoundsInScreen().CenterPoint();
   wm::ConvertPointFromScreen(second_root, &start_point);
 
   aura::test::EventGenerator generator(second_root, start_point);
@@ skipping 16 matching lines @@
   TestDraggingAnItemFromOverflowToShelf(true);
 }
 
 class ShelfViewVisibleBoundsTest : public ShelfViewTest,
                                    public testing::WithParamInterface<bool> {
  public:
   ShelfViewVisibleBoundsTest() : text_direction_change_(GetParam()) {}
 
   void CheckAllItemsAreInBounds() {
     gfx::Rect visible_bounds = shelf_view_->GetVisibleItemsBoundsInScreen();
-    gfx::Rect launcher_bounds = shelf_view_->GetBoundsInScreen();
-    EXPECT_TRUE(launcher_bounds.Contains(visible_bounds));
+    gfx::Rect shelf_bounds = shelf_view_->GetBoundsInScreen();
+    EXPECT_TRUE(shelf_bounds.Contains(visible_bounds));
     for (int i = 0; i < test_api_->GetButtonCount(); ++i)
       if (internal::ShelfButton* button = test_api_->GetButton(i))
         EXPECT_TRUE(visible_bounds.Contains(button->GetBoundsInScreen()));
     CheckAppListButtonIsInBounds();
   }
 
   void CheckAppListButtonIsInBounds() {
     gfx::Rect visible_bounds = shelf_view_->GetVisibleItemsBoundsInScreen();
     gfx::Rect app_list_button_bounds = shelf_view_->GetAppListButtonView()->
        GetBoundsInScreen();
@@ skipping 21 matching lines @@
   test_api_->RunMessageLoopUntilAnimationsDone();
   CheckAllItemsAreInBounds();
 }
 
 INSTANTIATE_TEST_CASE_P(LtrRtl, ShelfViewTextDirectionTest, testing::Bool());
 INSTANTIATE_TEST_CASE_P(VisibleBounds, ShelfViewVisibleBoundsTest,
     testing::Bool());
 
 }  // namespace test
 }  // namespace ash