mash: Move ash/common/wm/shelf to ash/common/shelf

ash/shelf/shelf_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/shelf/shelf_layout_manager.h"
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_table.h"
 #include "ash/ash_switches.h"
 #include "ash/common/shell_window_ids.h"
@@ skipping 148 matching lines @@
     if (type == ui::ET_GESTURE_SCROLL_END)
       return;
 
     if (type == ui::ET_GESTURE_SCROLL_UPDATE)
       scroll_.Add(delta);
 
     gfx::Rect shelf_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
     if (GetShelfLayoutManager()->IsHorizontalAlignment()) {
       EXPECT_EQ(not_visible_bounds_.bottom(), shelf_bounds.bottom());
       EXPECT_EQ(visible_bounds_.bottom(), shelf_bounds.bottom());
-    } else if (wm::SHELF_ALIGNMENT_RIGHT ==
+    } else if (SHELF_ALIGNMENT_RIGHT ==
                GetShelfLayoutManager()->GetAlignment()) {
       EXPECT_EQ(not_visible_bounds_.right(), shelf_bounds.right());
       EXPECT_EQ(visible_bounds_.right(), shelf_bounds.right());
-    } else if (wm::SHELF_ALIGNMENT_LEFT ==
+    } else if (SHELF_ALIGNMENT_LEFT ==
                GetShelfLayoutManager()->GetAlignment()) {
       EXPECT_EQ(not_visible_bounds_.x(), shelf_bounds.x());
       EXPECT_EQ(visible_bounds_.x(), shelf_bounds.x());
     }
 
     // if the shelf is being dimmed test dimmer bounds as well.
     if (GetShelfWidget()->GetDimsShelf())
       EXPECT_EQ(GetShelfWidget()->GetWindowBoundsInScreen(),
                 GetShelfWidget()->GetDimmerBoundsForTest());
 
@@ skipping 297 matching lines @@
       end,
       start,
       kTimeDelta,
       kNumScrollSteps,
       base::Bind(&ShelfDragCallback::ProcessScroll,
                  base::Unretained(&handler)));
 
   // Swipe down very little. It shouldn't change any state.
   if (GetShelfLayoutManager()->IsHorizontalAlignment())
     end.set_y(start.y() + shelf_shown.height() * 3 / 10);
-  else if (wm::SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
+  else if (SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
     end.set_x(start.x() - shelf_shown.width() * 3 / 10);
-  else if (wm::SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
+  else if (SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
     end.set_x(start.x() + shelf_shown.width() * 3 / 10);
   generator.GestureScrollSequence(start, end, kTimeDelta, 5);
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf->auto_hide_behavior());
   EXPECT_EQ(bounds_shelf.ToString(), window->bounds().ToString());
   EXPECT_EQ(shelf_shown.ToString(),
             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 
   // Swipe down again to hide.
   end = start + delta;
   generator.GestureScrollSequenceWithCallback(
       start,
       end,
       kTimeDelta,
       kNumScrollSteps,
       base::Bind(&ShelfDragCallback::ProcessScroll,
                  base::Unretained(&handler)));
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
   EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(), gfx::Rect());
   EXPECT_EQ(bounds_noshelf.ToString(), window->bounds().ToString());
   EXPECT_EQ(shelf_hidden.ToString(),
             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 
   // Swipe up in extended hit region to show it.
   gfx::Point extended_start = start;
   if (GetShelfLayoutManager()->IsHorizontalAlignment())
     extended_start.set_y(GetShelfWidget()->GetWindowBoundsInScreen().y() -1);
-  else if (wm::SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
+  else if (SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
     extended_start.set_x(
         GetShelfWidget()->GetWindowBoundsInScreen().right() + 1);
-  else if (wm::SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
+  else if (SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
     extended_start.set_x(GetShelfWidget()->GetWindowBoundsInScreen().x() - 1);
   end = extended_start - delta;
   generator.GestureScrollSequenceWithCallback(
       extended_start,
       end,
       kTimeDelta,
       kNumScrollSteps,
       base::Bind(&ShelfDragCallback::ProcessScroll,
                  base::Unretained(&handler)));
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
@@ skipping 33 matching lines @@
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
   EXPECT_EQ(shelf_hidden.ToString(),
             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 
   // Swipe up from below the shelf where a bezel would be, this should show the
   // shelf.
   gfx::Point below_start = start;
   if (GetShelfLayoutManager()->IsHorizontalAlignment())
     below_start.set_y(GetShelfWidget()->GetWindowBoundsInScreen().bottom() + 1);
-  else if (wm::SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
+  else if (SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
     below_start.set_x(
         GetShelfWidget()->GetWindowBoundsInScreen().x() - 1);
-  else if (wm::SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
+  else if (SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
     below_start.set_x(GetShelfWidget()->GetWindowBoundsInScreen().right() + 1);
   end = below_start - delta;
   generator.GestureScrollSequence(
       below_start, end, kTimeDelta, kNumScrollSteps);
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf->auto_hide_behavior());
   EXPECT_EQ(bounds_shelf.ToString(), window->bounds().ToString());
   EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(),
             GetShelfWidget()->GetWindowBoundsInScreen());
   EXPECT_EQ(shelf_shown.ToString(),
@@ skipping 312 matching lines @@
 // boundary between the primary and the secondary display.
 TEST_F(ShelfLayoutManagerTest, AutoHideShelfOnScreenBoundary) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,800x600");
   Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
       test::CreateDisplayLayout(display::DisplayPlacement::RIGHT, 0));
   // Put the primary monitor's shelf on the display boundary.
   Shelf* shelf = GetShelf();
-  shelf->SetAlignment(wm::SHELF_ALIGNMENT_RIGHT);
+  shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
 
   // Create a window because the shelf is always shown when no windows are
   // visible.
   CreateTestWidget();
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   ASSERT_EQ(root_windows[0],
             GetShelfWidget()->GetNativeWindow()->GetRootWindow());
 
   shelf->SetAutoHideBehavior(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
@@ skipping 734 matching lines @@
 }
 
 
 #if defined(OS_WIN)
 // RootWindow and Display can't resize on Windows Ash. http://crbug.com/165962
 #define MAYBE_SetAlignment DISABLED_SetAlignment
 #else
 #define MAYBE_SetAlignment SetAlignment
 #endif
 
-// Tests wm::SHELF_ALIGNMENT_(LEFT, RIGHT).
+// Tests SHELF_ALIGNMENT_(LEFT, RIGHT).
 TEST_F(ShelfLayoutManagerTest, MAYBE_SetAlignment) {
   Shelf* shelf = GetShelf();
   ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
   // Force an initial layout.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   layout_manager->LayoutShelf();
   EXPECT_EQ(SHELF_VISIBLE, shelf->GetVisibilityState());
 
-  shelf->SetAlignment(wm::SHELF_ALIGNMENT_LEFT);
+  shelf->SetAlignment(SHELF_ALIGNMENT_LEFT);
   gfx::Rect shelf_bounds(
       GetShelfWidget()->GetWindowBoundsInScreen());
   const display::Screen* screen = display::Screen::GetScreen();
   display::Display display =
       screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
   ASSERT_NE(-1, display.id());
   EXPECT_EQ(layout_manager->GetIdealBounds().width(),
             display.GetWorkAreaInsets().left());
   EXPECT_GE(
       shelf_bounds.width(),
       GetShelfWidget()->GetContentsView()->GetPreferredSize().width());
-  EXPECT_EQ(wm::SHELF_ALIGNMENT_LEFT, GetSystemTray()->shelf_alignment());
+  EXPECT_EQ(SHELF_ALIGNMENT_LEFT, GetSystemTray()->shelf_alignment());
   StatusAreaWidget* status_area_widget = GetShelfWidget()->status_area_widget();
   gfx::Rect status_bounds(status_area_widget->GetWindowBoundsInScreen());
   EXPECT_GE(status_bounds.width(),
             status_area_widget->GetContentsView()->GetPreferredSize().width());
   EXPECT_EQ(layout_manager->GetIdealBounds().width(),
             display.GetWorkAreaInsets().left());
   EXPECT_EQ(0, display.GetWorkAreaInsets().top());
   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
   EXPECT_EQ(0, display.GetWorkAreaInsets().right());
   EXPECT_EQ(display.bounds().x(), shelf_bounds.x());
   EXPECT_EQ(display.bounds().y(), shelf_bounds.y());
   EXPECT_EQ(display.bounds().height(), shelf_bounds.height());
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
   EXPECT_EQ(ShelfLayoutManager::kAutoHideSize,
       display.GetWorkAreaInsets().left());
   EXPECT_EQ(ShelfLayoutManager::kAutoHideSize, display.work_area().x());
 
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
-  shelf->SetAlignment(wm::SHELF_ALIGNMENT_RIGHT);
+  shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
   display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
   shelf_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
   display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
   ASSERT_NE(-1, display.id());
   EXPECT_EQ(layout_manager->GetIdealBounds().width(),
             display.GetWorkAreaInsets().right());
   EXPECT_GE(shelf_bounds.width(),
             GetShelfWidget()->GetContentsView()->GetPreferredSize().width());
-  EXPECT_EQ(wm::SHELF_ALIGNMENT_RIGHT, GetSystemTray()->shelf_alignment());
+  EXPECT_EQ(SHELF_ALIGNMENT_RIGHT, GetSystemTray()->shelf_alignment());
   status_bounds = gfx::Rect(status_area_widget->GetWindowBoundsInScreen());
   EXPECT_GE(status_bounds.width(),
             status_area_widget->GetContentsView()->GetPreferredSize().width());
   EXPECT_EQ(layout_manager->GetIdealBounds().width(),
             display.GetWorkAreaInsets().right());
   EXPECT_EQ(0, display.GetWorkAreaInsets().top());
   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
   EXPECT_EQ(0, display.GetWorkAreaInsets().left());
   EXPECT_EQ(display.work_area().right(), shelf_bounds.x());
   EXPECT_EQ(display.bounds().y(), shelf_bounds.y());
@@ skipping 128 matching lines @@
 #endif
 
 TEST_F(ShelfLayoutManagerTest, MAYBE_GestureDrag) {
   // Slop is an implementation detail of gesture recognition, and complicates
   // these tests. Ignore it.
   ui::GestureConfiguration::GetInstance()
       ->set_max_touch_move_in_pixels_for_click(0);
   Shelf* shelf = GetShelf();
   {
     SCOPED_TRACE("BOTTOM");
-    shelf->SetAlignment(wm::SHELF_ALIGNMENT_BOTTOM);
+    shelf->SetAlignment(SHELF_ALIGNMENT_BOTTOM);
     RunGestureDragTests(gfx::Vector2d(0, 120));
   }
 
   {
     SCOPED_TRACE("LEFT");
-    shelf->SetAlignment(wm::SHELF_ALIGNMENT_LEFT);
+    shelf->SetAlignment(SHELF_ALIGNMENT_LEFT);
     RunGestureDragTests(gfx::Vector2d(-120, 0));
   }
 
   {
     SCOPED_TRACE("RIGHT");
-    shelf->SetAlignment(wm::SHELF_ALIGNMENT_RIGHT);
+    shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
     RunGestureDragTests(gfx::Vector2d(120, 0));
   }
 }
 
 TEST_F(ShelfLayoutManagerTest, WindowVisibilityDisablesAutoHide) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,800x600");
   Shelf* shelf = GetShelf();
@@ skipping 259 matching lines @@
       EXPECT_TRUE(layout_manager->IsVisible());
       EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
     } else {
       EXPECT_FALSE(layout_manager->IsVisible());
       EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
     }
   }
 }
 
 TEST_F(ShelfLayoutManagerTest, ShelfBackgroundColor) {
-  EXPECT_EQ(wm::SHELF_BACKGROUND_DEFAULT,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_DEFAULT, GetShelfWidget()->GetBackgroundType());
 
   std::unique_ptr<aura::Window> w1(CreateTestWindow());
   w1->Show();
   wm::ActivateWindow(w1.get());
-  EXPECT_EQ(wm::SHELF_BACKGROUND_DEFAULT,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_DEFAULT, GetShelfWidget()->GetBackgroundType());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
-  EXPECT_EQ(wm::SHELF_BACKGROUND_MAXIMIZED,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_MAXIMIZED, GetShelfWidget()->GetBackgroundType());
 
   std::unique_ptr<aura::Window> w2(CreateTestWindow());
   w2->Show();
   wm::ActivateWindow(w2.get());
   // Overlaps with shelf.
   w2->SetBounds(GetShelfLayoutManager()->GetIdealBounds());
 
   // Still background is 'maximized'.
-  EXPECT_EQ(wm::SHELF_BACKGROUND_MAXIMIZED,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_MAXIMIZED, GetShelfWidget()->GetBackgroundType());
 
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
-  EXPECT_EQ(wm::SHELF_BACKGROUND_OVERLAP,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_OVERLAP, GetShelfWidget()->GetBackgroundType());
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
-  EXPECT_EQ(wm::SHELF_BACKGROUND_DEFAULT,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_DEFAULT, GetShelfWidget()->GetBackgroundType());
 
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
-  EXPECT_EQ(wm::SHELF_BACKGROUND_MAXIMIZED,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_MAXIMIZED, GetShelfWidget()->GetBackgroundType());
   w1.reset();
-  EXPECT_EQ(wm::SHELF_BACKGROUND_DEFAULT,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_DEFAULT, GetShelfWidget()->GetBackgroundType());
 }
 
 // Verify that the shelf doesn't have the opaque background if it's auto-hide
 // status.
 TEST_F(ShelfLayoutManagerTest, ShelfBackgroundColorAutoHide) {
-  EXPECT_EQ(wm::SHELF_BACKGROUND_DEFAULT,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_DEFAULT, GetShelfWidget()->GetBackgroundType());
 
   GetShelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   std::unique_ptr<aura::Window> w1(CreateTestWindow());
   w1->Show();
   wm::ActivateWindow(w1.get());
-  EXPECT_EQ(wm::SHELF_BACKGROUND_OVERLAP,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_OVERLAP, GetShelfWidget()->GetBackgroundType());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
-  EXPECT_EQ(wm::SHELF_BACKGROUND_OVERLAP,
-            GetShelfWidget()->GetBackgroundType());
+  EXPECT_EQ(SHELF_BACKGROUND_OVERLAP, GetShelfWidget()->GetBackgroundType());
 }
 
 #if defined(OS_CHROMEOS)
 #define MAYBE_StatusAreaHitBoxCoversEdge StatusAreaHitBoxCoversEdge
 #else
 #define MAYBE_StatusAreaHitBoxCoversEdge DISABLED_StatusAreaHitBoxCoversEdge
 #endif
 
 // Verify the hit bounds of the status area extend to the edge of the shelf.
 TEST_F(ShelfLayoutManagerTest, MAYBE_StatusAreaHitBoxCoversEdge) {
   UpdateDisplay("400x400");
   Shelf* shelf = GetShelf();
   StatusAreaWidget* status_area_widget = Shell::GetPrimaryRootWindowController()
                                              ->shelf_widget()
                                              ->status_area_widget();
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
   generator.MoveMouseTo(399,399);
 
   // Test bottom right pixel for bottom alignment.
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
 
   // Test bottom right pixel for right alignment.
-  shelf->SetAlignment(wm::SHELF_ALIGNMENT_RIGHT);
+  shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
 
   // Test bottom left pixel for left alignment.
   generator.MoveMouseTo(0, 399);
-  shelf->SetAlignment(wm::SHELF_ALIGNMENT_LEFT);
+  shelf->SetAlignment(SHELF_ALIGNMENT_LEFT);
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
   generator.ClickLeftButton();
   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
 }
 
 // Tests that when the auto-hide behaviour is changed during an animation the
 // target bounds are updated to reflect the new state.
 TEST_F(ShelfLayoutManagerTest,
@@ skipping 48 matching lines @@
                                              ->shelf_widget()
                                              ->status_area_widget();
   EXPECT_TRUE(status_area_widget->IsVisible());
   // Shelf should be in the first display's area.
   gfx::Rect status_area_bounds(status_area_widget->GetWindowBoundsInScreen());
   EXPECT_TRUE(gfx::Rect(0, 0, 500, 400).Contains(status_area_bounds));
   EXPECT_EQ(gfx::Point(500, 400), status_area_bounds.bottom_right());
 }
 
 }  // namespace ash