Rename Launcher to Shelf.

ash/wm/panels/panel_layout_manager_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/wm/panels/panel_layout_manager.h"
 
 #include "ash/ash_switches.h"
-#include "ash/launcher/launcher.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shelf/shelf_view.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/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/wm/mru_window_tracker.h"
 #include "ash/wm/window_util.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/i18n/rtl.h"
 #include "base/run_loop.h"
@@ skipping 14 matching lines @@
 class PanelLayoutManagerTest : public test::AshTestBase {
  public:
   PanelLayoutManagerTest() {}
   virtual ~PanelLayoutManagerTest() {}
 
   virtual void SetUp() OVERRIDE {
     test::AshTestBase::SetUp();
     ASSERT_TRUE(test::TestShelfDelegate::instance());
 
     shelf_view_test_.reset(new test::ShelfViewTestAPI(
-        GetShelfView(Launcher::ForPrimaryDisplay())));
+        GetShelfView(Shelf::ForPrimaryDisplay())));
     shelf_view_test_->SetAnimationDuration(1);
   }
 
   aura::Window* CreateNormalWindow(const gfx::Rect& bounds) {
     return CreateTestWindowInShellWithBounds(bounds);
   }
 
   aura::Window* CreatePanelWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
         NULL,
@@ skipping 50 matching lines @@
 
     EXPECT_FALSE(window1_bounds.Intersects(window2_bounds));
   }
 
   // TODO(dcheng): This should be const, but GetScreenBoundsOfItemIconForWindow
   // takes a non-const Window. We can probably fix that.
   void IsPanelAboveLauncherIcon(aura::Window* panel) {
     // Waits until all shelf view animations are done.
     shelf_view_test()->RunMessageLoopUntilAnimationsDone();
 
-    Launcher* launcher =
-        RootWindowController::ForLauncher(panel)->shelf()->launcher();
-    gfx::Rect icon_bounds = launcher->GetScreenBoundsOfItemIconForWindow(panel);
+    Shelf* shelf = RootWindowController::ForShelf(panel)->shelf()->shelf();
+    gfx::Rect icon_bounds = shelf->GetScreenBoundsOfItemIconForWindow(panel);
     ASSERT_FALSE(icon_bounds.width() == 0 && icon_bounds.height() == 0);
 
     gfx::Rect window_bounds = panel->GetBoundsInScreen();
     ASSERT_LT(icon_bounds.width(), window_bounds.width());
     ASSERT_LT(icon_bounds.height(), window_bounds.height());
-    gfx::Rect launcher_bounds = launcher->shelf_widget()->
-        GetWindowBoundsInScreen();
+    gfx::Rect shelf_bounds = shelf->shelf_widget()->GetWindowBoundsInScreen();
     ShelfAlignment alignment = GetAlignment(panel->GetRootWindow());
 
     if (IsHorizontal(alignment)) {
       // The horizontal bounds of the panel window should contain the bounds of
-      // the launcher icon.
+      // the shelf icon.
       EXPECT_LE(window_bounds.x(), icon_bounds.x());
       EXPECT_GE(window_bounds.right(), icon_bounds.right());
     } else {
       // The vertical bounds of the panel window should contain the bounds of
-      // the launcher icon.
+      // the shelf icon.
       EXPECT_LE(window_bounds.y(), icon_bounds.y());
       EXPECT_GE(window_bounds.bottom(), icon_bounds.bottom());
     }
 
     switch (alignment) {
       case SHELF_ALIGNMENT_BOTTOM:
-        EXPECT_EQ(launcher_bounds.y(), window_bounds.bottom());
+        EXPECT_EQ(shelf_bounds.y(), window_bounds.bottom());
         break;
       case SHELF_ALIGNMENT_LEFT:
-        EXPECT_EQ(launcher_bounds.right(), window_bounds.x());
+        EXPECT_EQ(shelf_bounds.right(), window_bounds.x());
         break;
       case SHELF_ALIGNMENT_RIGHT:
-        EXPECT_EQ(launcher_bounds.x(), window_bounds.right());
+        EXPECT_EQ(shelf_bounds.x(), window_bounds.right());
         break;
       case SHELF_ALIGNMENT_TOP:
-        EXPECT_EQ(launcher_bounds.bottom(), window_bounds.y());
+        EXPECT_EQ(shelf_bounds.bottom(), window_bounds.y());
         break;
     }
   }
 
   void IsCalloutAboveLauncherIcon(aura::Window* panel) {
     // Flush the message loop, since callout updates use a delayed task.
     base::RunLoop().RunUntilIdle();
     views::Widget* widget = GetCalloutWidgetForPanel(panel);
 
-    Launcher* launcher =
-        RootWindowController::ForLauncher(panel)->shelf()->launcher();
-    gfx::Rect icon_bounds = launcher->GetScreenBoundsOfItemIconForWindow(panel);
+    Shelf* shelf = RootWindowController::ForShelf(panel)->shelf()->shelf();
+    gfx::Rect icon_bounds = shelf->GetScreenBoundsOfItemIconForWindow(panel);
     ASSERT_FALSE(icon_bounds.IsEmpty());
 
     gfx::Rect panel_bounds = panel->GetBoundsInScreen();
     gfx::Rect callout_bounds = widget->GetWindowBoundsInScreen();
     ASSERT_FALSE(icon_bounds.IsEmpty());
 
     EXPECT_TRUE(widget->IsVisible());
 
     ShelfAlignment alignment = GetAlignment(panel->GetRootWindow());
     switch (alignment) {
@@ skipping 24 matching lines @@
 
   bool IsPanelCalloutVisible(aura::Window* panel) {
     views::Widget* widget = GetCalloutWidgetForPanel(panel);
     return widget->IsVisible();
   }
 
   test::ShelfViewTestAPI* shelf_view_test() {
     return shelf_view_test_.get();
   }
 
-  // Clicks the launcher items on |shelf_view| that is
-  /// associated with given |window|.
+  // Clicks the shelf items on |shelf_view| that is associated with given
+  // |window|.
   void ClickLauncherItemForWindow(ShelfView* shelf_view,
                                   aura::Window* window) {
     test::ShelfViewTestAPI test_api(shelf_view);
     test_api.SetAnimationDuration(1);
     test_api.RunMessageLoopUntilAnimationsDone();
     ShelfModel* model = test::ShellTestApi(Shell::GetInstance()).shelf_model();
     int index = model->ItemIndexByID(GetLauncherIDForWindow(window));
     gfx::Rect bounds = test_api.GetButton(index)->GetBoundsInScreen();
 
     aura::test::EventGenerator& event_generator = GetEventGenerator();
@@ skipping 12 matching lines @@
     ash::Shell* shell = ash::Shell::GetInstance();
     return shell->GetShelfAlignment(root_window);
   }
 
   void SetShelfAutoHideBehavior(aura::Window* window,
                                 ShelfAutoHideBehavior behavior) {
     internal::ShelfLayoutManager* shelf =
         RootWindowController::ForWindow(window)->shelf()->
         shelf_layout_manager();
     shelf->SetAutoHideBehavior(behavior);
-    ShelfView* shelf_view = GetShelfView(Launcher::ForWindow(window));
+    ShelfView* shelf_view = GetShelfView(Shelf::ForWindow(window));
     test::ShelfViewTestAPI test_api(shelf_view);
     test_api.RunMessageLoopUntilAnimationsDone();
   }
 
   void SetShelfVisibilityState(aura::Window* window,
                                ShelfVisibilityState visibility_state) {
     internal::ShelfLayoutManager* shelf =
         RootWindowController::ForWindow(window)->shelf()->
         shelf_layout_manager();
     shelf->SetState(visibility_state);
   }
 
-  internal::ShelfView* GetShelfView(Launcher* launcher) {
-    return test::LauncherTestAPI(launcher).shelf_view();
+  internal::ShelfView* GetShelfView(Shelf* shelf) {
+    return test::ShelfTestAPI(shelf).shelf_view();
   }
 
  private:
   scoped_ptr<test::ShelfViewTestAPI> shelf_view_test_;
 
   bool IsHorizontal(ShelfAlignment alignment) {
     return alignment == SHELF_ALIGNMENT_BOTTOM ||
            alignment == SHELF_ALIGNMENT_TOP;
   }
 
@@ skipping 21 matching lines @@
     PanelLayoutManagerTest::TearDown();
   }
 
  private:
   bool is_rtl_;
   std::string original_locale;
 
   DISALLOW_COPY_AND_ASSIGN(PanelLayoutManagerTextDirectionTest);
 };
 
-// Tests that a created panel window is above the launcher icon in LTR and RTL.
+// Tests that a created panel window is above the shelf icon in LTR and RTL.
 TEST_P(PanelLayoutManagerTextDirectionTest, AddOnePanel) {
   gfx::Rect bounds(0, 0, 201, 201);
   scoped_ptr<aura::Window> window(CreatePanelWindow(bounds));
   EXPECT_EQ(GetPanelContainer(window.get()), window->parent());
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(window.get()));
   EXPECT_NO_FATAL_FAILURE(IsCalloutAboveLauncherIcon(window.get()));
 }
 
 // Tests that a created panel window is successfully aligned over a hidden
-// launcher icon.
+// shelf icon.
 TEST_F(PanelLayoutManagerTest, PanelAlignsToHiddenLauncherIcon) {
   gfx::Rect bounds(0, 0, 201, 201);
   SetShelfAutoHideBehavior(Shell::GetPrimaryRootWindow(),
                            SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   scoped_ptr<aura::Window> normal_window(CreateNormalWindow(bounds));
   scoped_ptr<aura::Window> window(CreatePanelWindow(bounds));
   EXPECT_EQ(GetPanelContainer(window.get()), window->parent());
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(window.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, PanelAlignsToHiddenLauncherIconSecondDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
-  // Keep the displays wide so that launchers have enough
-  // space for launcher buttons.
+  // Keep the displays wide so that shelves have enough space for shelves
+  // buttons.
   UpdateDisplay("400x400,600x400");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   scoped_ptr<aura::Window> normal_window(
       CreateNormalWindow(gfx::Rect(450, 0, 100, 100)));
   scoped_ptr<aura::Window> panel(CreatePanelWindow(gfx::Rect(400, 0, 50, 50)));
   EXPECT_EQ(root_windows[1], panel->GetRootWindow());
   EXPECT_NO_FATAL_FAILURE(IsPanelAboveLauncherIcon(panel.get()));
   gfx::Rect shelf_visible_position = panel->GetBoundsInScreen();
 
@@ skipping 45 matching lines @@
   EXPECT_TRUE(WindowIsAbove(w1.get(), w3.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w3.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w1.get()));
 
   wm::ActivateWindow(w3.get());
   EXPECT_TRUE(WindowIsAbove(w3.get(), w2.get()));
   EXPECT_TRUE(WindowIsAbove(w2.get(), w1.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, MultiplePanelStackingVertical) {
-  // set launcher shelf to be aligned on the right
+  // Set shelf to be aligned on the right.
   SetAlignment(Shell::GetPrimaryRootWindow(), SHELF_ALIGNMENT_RIGHT);
 
   // Size panels in such a way that ordering them by X coordinate would cause
   // stacking order to be incorrect. Test that stacking order is based on Y.
   scoped_ptr<aura::Window> w1(CreatePanelWindow(gfx::Rect(0, 0, 210, 201)));
   scoped_ptr<aura::Window> w2(CreatePanelWindow(gfx::Rect(0, 0, 220, 201)));
   scoped_ptr<aura::Window> w3(CreatePanelWindow(gfx::Rect(0, 0, 200, 201)));
 
   // Default stacking order.
   EXPECT_TRUE(WindowIsAbove(w3.get(), w2.get()));
@@ skipping 128 matching lines @@
 TEST_F(PanelLayoutManagerTest, FanWindows) {
   gfx::Rect bounds(0, 0, 201, 201);
   scoped_ptr<aura::Window> w1(CreatePanelWindow(bounds));
   scoped_ptr<aura::Window> w2(CreatePanelWindow(bounds));
   scoped_ptr<aura::Window> w3(CreatePanelWindow(bounds));
 
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   int window_x1 = w1->GetBoundsInRootWindow().CenterPoint().x();
   int window_x2 = w2->GetBoundsInRootWindow().CenterPoint().x();
   int window_x3 = w3->GetBoundsInRootWindow().CenterPoint().x();
-  Launcher* launcher = Launcher::ForPrimaryDisplay();
-  int icon_x1 = launcher->GetScreenBoundsOfItemIconForWindow(w1.get()).x();
-  int icon_x2 = launcher->GetScreenBoundsOfItemIconForWindow(w2.get()).x();
+  Shelf* shelf = Shelf::ForPrimaryDisplay();
+  int icon_x1 = shelf->GetScreenBoundsOfItemIconForWindow(w1.get()).x();
+  int icon_x2 = shelf->GetScreenBoundsOfItemIconForWindow(w2.get()).x();
   EXPECT_EQ(window_x2 - window_x1, window_x3 - window_x2);
   int spacing = window_x2 - window_x1;
   EXPECT_GT(spacing, icon_x2 - icon_x1);
 }
 
 TEST_F(PanelLayoutManagerTest, FanLargeWindow) {
   gfx::Rect small_bounds(0, 0, 201, 201);
   gfx::Rect large_bounds(0, 0, 501, 201);
   scoped_ptr<aura::Window> w1(CreatePanelWindow(small_bounds));
   scoped_ptr<aura::Window> w2(CreatePanelWindow(large_bounds));
@@ skipping 28 matching lines @@
   // Activate the window, ensure callout is visible.
   wm::ActivateWindow(window.get());
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(IsPanelCalloutVisible(window.get()));
 }
 
 TEST_F(PanelLayoutManagerTest, PanelMoveBetweenMultipleDisplays) {
   if (!SupportsMultipleDisplays())
     return;
 
-  // Keep the displays wide so that launchers have enough
-  // space for launcher buttons.
+  // Keep the displays wide so that shelves have enough space for launcher
+  // buttons.
   UpdateDisplay("600x400,600x400");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   scoped_ptr<aura::Window> p1_d1(CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
   scoped_ptr<aura::Window> p2_d1(CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
   scoped_ptr<aura::Window> p1_d2(CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
   scoped_ptr<aura::Window> p2_d2(CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
 
-  ShelfView* shelf_view_1st = GetShelfView(Launcher::ForPrimaryDisplay());
+  ShelfView* shelf_view_1st = GetShelfView(Shelf::ForPrimaryDisplay());
   ShelfView* shelf_view_2nd =
-      GetShelfView(Launcher::ForWindow(root_windows[1]));
+      GetShelfView(Shelf::ForWindow(root_windows[1]));
 
   EXPECT_EQ(root_windows[0], p1_d1->GetRootWindow());
   EXPECT_EQ(root_windows[0], p2_d1->GetRootWindow());
   EXPECT_EQ(root_windows[1], p1_d2->GetRootWindow());
   EXPECT_EQ(root_windows[1], p2_d2->GetRootWindow());
 
   EXPECT_EQ(internal::kShellWindowId_PanelContainer, p1_d1->parent()->id());
   EXPECT_EQ(internal::kShellWindowId_PanelContainer, p2_d1->parent()->id());
   EXPECT_EQ(internal::kShellWindowId_PanelContainer, p1_d2->parent()->id());
   EXPECT_EQ(internal::kShellWindowId_PanelContainer, p2_d2->parent()->id());
@@ skipping 46 matching lines @@
   EXPECT_EQ(root_windows[0], p1_d2->GetRootWindow());
   EXPECT_EQ(root_windows[1], p2_d2->GetRootWindow());
   EXPECT_TRUE(root_windows[0]->GetBoundsInScreen().Contains(
       p1_d1->GetBoundsInScreen()));
 }
 
 TEST_F(PanelLayoutManagerTest, PanelAttachPositionMultipleDisplays) {
   if (!SupportsMultipleDisplays())
     return;
 
-  // Keep the displays wide so that launchers have enough space for launcher
-  // buttons. Use differently sized displays so the launcher is in a different
+  // Keep the displays wide so that shelves have enough space for shelf buttons.
+  // Use differently sized displays so the shelf is in a different
   // position on second display.
   UpdateDisplay("600x400,600x600");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   scoped_ptr<aura::Window> p1_d1(CreatePanelWindow(gfx::Rect(0, 0, 50, 50)));
   scoped_ptr<aura::Window> p1_d2(CreatePanelWindow(gfx::Rect(600, 0, 50, 50)));
 
   EXPECT_EQ(root_windows[0], p1_d1->GetRootWindow());
   EXPECT_EQ(root_windows[1], p1_d2->GetRootWindow());
 
@@ skipping 99 matching lines @@
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_FALSE(w2->IsVisible());
   EXPECT_TRUE(w3->IsVisible());
 }
 
 INSTANTIATE_TEST_CASE_P(LtrRtl, PanelLayoutManagerTextDirectionTest,
                         testing::Bool());
 
 }  // namespace internal
 }  // namespace ash