Refactors DockedWindowLayoutManager in terms of ash/wm/common

ash/shelf/shelf_widget_unittest.cc

 // Copyright (c) 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 "ash/shelf/shelf_widget.h"
 
 #include "ash/root_window_controller.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_layout_manager.h"
@@ skipping 22 matching lines @@
 
 ShelfLayoutManager* GetShelfLayoutManager() {
   return GetShelfWidget()->shelf_layout_manager();
 }
 
 } // namespace
 
 typedef test::AshTestBase ShelfWidgetTest;
 
 void TestLauncherAlignment(aura::Window* root,
-                           ShelfAlignment alignment,
+                           wm::ShelfAlignment alignment,
                            const std::string& expected) {
   Shell::GetInstance()->SetShelfAlignment(alignment, root);
   gfx::Screen* screen = gfx::Screen::GetScreen();
   EXPECT_EQ(expected,
             screen->GetDisplayNearestWindow(root).work_area().ToString());
 }
 
 #if defined(OS_WIN) && !defined(USE_ASH)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #define MAYBE_TestAlignment DISABLED_TestAlignment
 #else
 #define MAYBE_TestAlignment TestAlignment
 #endif
 TEST_F(ShelfWidgetTest, MAYBE_TestAlignment) {
   Shelf* shelf = Shelf::ForPrimaryDisplay();
   UpdateDisplay("400x400");
   ASSERT_TRUE(shelf);
   {
     SCOPED_TRACE("Single Bottom");
     TestLauncherAlignment(Shell::GetPrimaryRootWindow(),
-                          SHELF_ALIGNMENT_BOTTOM,
-                          "0,0 400x353");
+                          wm::SHELF_ALIGNMENT_BOTTOM, "0,0 400x353");
   }
   {
     SCOPED_TRACE("Single Locked");
     TestLauncherAlignment(Shell::GetPrimaryRootWindow(),
-                          SHELF_ALIGNMENT_BOTTOM_LOCKED, "0,0 400x353");
+                          wm::SHELF_ALIGNMENT_BOTTOM_LOCKED, "0,0 400x353");
   }
   {
     SCOPED_TRACE("Single Right");
     TestLauncherAlignment(Shell::GetPrimaryRootWindow(),
-                          SHELF_ALIGNMENT_RIGHT,
-                          "0,0 353x400");
+                          wm::SHELF_ALIGNMENT_RIGHT, "0,0 353x400");
   }
   {
     SCOPED_TRACE("Single Left");
     TestLauncherAlignment(Shell::GetPrimaryRootWindow(),
-                          SHELF_ALIGNMENT_LEFT,
-                          "47,0 353x400");
+                          wm::SHELF_ALIGNMENT_LEFT, "47,0 353x400");
   }
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("300x300,500x500");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   {
     SCOPED_TRACE("Primary Bottom");
-    TestLauncherAlignment(root_windows[0],
-                          SHELF_ALIGNMENT_BOTTOM,
+    TestLauncherAlignment(root_windows[0], wm::SHELF_ALIGNMENT_BOTTOM,
                           "0,0 300x253");
   }
   {
     SCOPED_TRACE("Primary Locked");
-    TestLauncherAlignment(root_windows[0], SHELF_ALIGNMENT_BOTTOM_LOCKED,
+    TestLauncherAlignment(root_windows[0], wm::SHELF_ALIGNMENT_BOTTOM_LOCKED,
                           "0,0 300x253");
   }
   {
     SCOPED_TRACE("Primary Right");
-    TestLauncherAlignment(root_windows[0],
-                          SHELF_ALIGNMENT_RIGHT,
+    TestLauncherAlignment(root_windows[0], wm::SHELF_ALIGNMENT_RIGHT,
                           "0,0 253x300");
   }
   {
     SCOPED_TRACE("Primary Left");
-    TestLauncherAlignment(root_windows[0],
-                          SHELF_ALIGNMENT_LEFT,
+    TestLauncherAlignment(root_windows[0], wm::SHELF_ALIGNMENT_LEFT,
                           "47,0 253x300");
   }
   {
     SCOPED_TRACE("Secondary Bottom");
-    TestLauncherAlignment(root_windows[1],
-                          SHELF_ALIGNMENT_BOTTOM,
+    TestLauncherAlignment(root_windows[1], wm::SHELF_ALIGNMENT_BOTTOM,
                           "300,0 500x453");
   }
   {
     SCOPED_TRACE("Secondary Locked");
-    TestLauncherAlignment(root_windows[1], SHELF_ALIGNMENT_BOTTOM_LOCKED,
+    TestLauncherAlignment(root_windows[1], wm::SHELF_ALIGNMENT_BOTTOM_LOCKED,
                           "300,0 500x453");
   }
   {
     SCOPED_TRACE("Secondary Right");
-    TestLauncherAlignment(root_windows[1],
-                          SHELF_ALIGNMENT_RIGHT,
+    TestLauncherAlignment(root_windows[1], wm::SHELF_ALIGNMENT_RIGHT,
                           "300,0 453x500");
   }
   {
     SCOPED_TRACE("Secondary Left");
-    TestLauncherAlignment(root_windows[1],
-                          SHELF_ALIGNMENT_LEFT,
+    TestLauncherAlignment(root_windows[1], wm::SHELF_ALIGNMENT_LEFT,
                           "347,0 453x500");
   }
 }
 
 // Makes sure the shelf is initially sized correctly.
 TEST_F(ShelfWidgetTest, LauncherInitiallySized) {
   ShelfWidget* shelf_widget = GetShelfWidget();
   Shelf* shelf = shelf_widget->shelf();
   ASSERT_TRUE(shelf);
   ShelfLayoutManager* shelf_layout_manager = GetShelfLayoutManager();
@@ skipping 89 matching lines @@
     // window-targeter should find |widget| as the target (instead of the
     // shelf).
     gfx::Point event_location(widget_bounds.x() + 5, shelf_bounds.y() + 1);
     ui::MouseEvent mouse(ui::ET_MOUSE_MOVED, event_location, event_location,
                          ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
     ui::EventTarget* target = targeter->FindTargetForEvent(root, &mouse);
     EXPECT_EQ(widget->GetNativeWindow(), target);
   }
 
   // Change shelf alignment to verify that the targeter insets are updated.
-  shelf_layout_manager->SetAlignment(SHELF_ALIGNMENT_LEFT);
+  shelf_layout_manager->SetAlignment(wm::SHELF_ALIGNMENT_LEFT);
   shelf_layout_manager->LayoutShelf();
   shelf_bounds = shelf_widget->GetWindowBoundsInScreen();
   {
     // Create a mouse-event targeting the right edge of the shelf widget. The
     // window-targeter should find |widget| as the target (instead of the
     // shelf).
     gfx::Point event_location(shelf_bounds.right() - 1, widget_bounds.y() + 5);
     ui::MouseEvent mouse(ui::ET_MOUSE_MOVED, event_location, event_location,
                          ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
     ui::EventTarget* target = targeter->FindTargetForEvent(root, &mouse);
     EXPECT_EQ(widget->GetNativeWindow(), target);
   }
 
   // Now restore shelf alignment (bottom) and auto-hide (hidden) the shelf.
-  shelf_layout_manager->SetAlignment(SHELF_ALIGNMENT_BOTTOM);
+  shelf_layout_manager->SetAlignment(wm::SHELF_ALIGNMENT_BOTTOM);
   shelf_layout_manager->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   shelf_layout_manager->LayoutShelf();
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf_layout_manager->visibility_state());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf_layout_manager->auto_hide_state());
   shelf_bounds = shelf_widget->GetWindowBoundsInScreen();
   EXPECT_TRUE(!shelf_bounds.IsEmpty());
 
   // Move |widget| so it still overlaps the shelf.
   widget->SetBounds(gfx::Rect(0,
                               shelf_bounds.y() - kWindowHeight + kOverlapSize,
@@ skipping 61 matching lines @@
               targeter->FindTargetForEvent(root, &touch));
   }
 }
 
 namespace {
 
 // A TestShelfDelegate that sets the shelf alignment and auto hide behavior in
 // OnShelfCreated, to simulate ChromeLauncherController's behavior.
 class TestShelfDelegate : public ShelfDelegate {
  public:
-  TestShelfDelegate(ShelfAlignment initial_alignment,
+  TestShelfDelegate(wm::ShelfAlignment initial_alignment,
                     ShelfAutoHideBehavior initial_auto_hide_behavior)
       : initial_alignment_(initial_alignment),
         initial_auto_hide_behavior_(initial_auto_hide_behavior) {}
   ~TestShelfDelegate() override {}
 
   // ShelfDelegate implementation.
   void OnShelfCreated(Shelf* shelf) override {
     shelf->SetAlignment(initial_alignment_);
     shelf->SetAutoHideBehavior(initial_auto_hide_behavior_);
   }
   void OnShelfDestroyed(Shelf* shelf) override {}
   void OnShelfAlignmentChanged(Shelf* shelf) override {}
   void OnShelfAutoHideBehaviorChanged(Shelf* shelf) override {}
   ShelfID GetShelfIDForAppID(const std::string& app_id) override { return 0; }
   bool HasShelfIDToAppIDMapping(ShelfID id) const override { return false; }
   const std::string& GetAppIDForShelfID(ShelfID id) override {
     return base::EmptyString();
   }
   void PinAppWithID(const std::string& app_id) override {}
   bool IsAppPinned(const std::string& app_id) override { return false; }
   void UnpinAppWithID(const std::string& app_id) override {}
 
  private:
-  ShelfAlignment initial_alignment_;
+  wm::ShelfAlignment initial_alignment_;
   ShelfAutoHideBehavior initial_auto_hide_behavior_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShelfDelegate);
 };
 
 // A TestShellDelegate that creates a TestShelfDelegate with initial values.
 class ShelfWidgetTestShellDelegate : public test::TestShellDelegate {
  public:
   ShelfWidgetTestShellDelegate() {}
   ~ShelfWidgetTestShellDelegate() override {}
 
   // test::TestShellDelegate
   ShelfDelegate* CreateShelfDelegate(ShelfModel* model) override {
     return new TestShelfDelegate(initial_alignment_,
                                  initial_auto_hide_behavior_);
   }
 
-  void set_initial_alignment(ShelfAlignment alignment) {
+  void set_initial_alignment(wm::ShelfAlignment alignment) {
     initial_alignment_ = alignment;
   }
 
   void set_initial_auto_hide_behavior(ShelfAutoHideBehavior behavior) {
     initial_auto_hide_behavior_ = behavior;
   }
 
  private:
-  ShelfAlignment initial_alignment_ = SHELF_ALIGNMENT_BOTTOM;
+  wm::ShelfAlignment initial_alignment_ = wm::SHELF_ALIGNMENT_BOTTOM;
   ShelfAutoHideBehavior initial_auto_hide_behavior_ =
       SHELF_AUTO_HIDE_BEHAVIOR_NEVER;
   DISALLOW_COPY_AND_ASSIGN(ShelfWidgetTestShellDelegate);
 };
 
 class ShelfWidgetTestWithDelegate : public ShelfWidgetTest {
  public:
   ShelfWidgetTestWithDelegate() { set_start_session(false); }
   ~ShelfWidgetTestWithDelegate() override {}
 
   // ShelfWidgetTest:
   void SetUp() override {
     shelf_widget_test_shell_delegate_ = new ShelfWidgetTestShellDelegate;
     ash_test_helper()->set_test_shell_delegate(
         shelf_widget_test_shell_delegate_);
     ShelfWidgetTest::SetUp();
   }
 
   void TestCreateShelfWithInitialValues(
-      ShelfAlignment initial_alignment,
+      wm::ShelfAlignment initial_alignment,
       ShelfAutoHideBehavior initial_auto_hide_behavior,
       ShelfVisibilityState expected_shelf_visibility_state,
       ShelfAutoHideState expected_shelf_auto_hide_state) {
     shelf_widget_test_shell_delegate_->set_initial_alignment(initial_alignment);
     shelf_widget_test_shell_delegate_->set_initial_auto_hide_behavior(
         initial_auto_hide_behavior);
     SetUserLoggedIn(true);
     SetSessionStarted(true);
 
     ShelfWidget* shelf_widget = GetShelfWidget();
@@ skipping 15 matching lines @@
 
  private:
   ShelfWidgetTestShellDelegate* shelf_widget_test_shell_delegate_;
   DISALLOW_COPY_AND_ASSIGN(ShelfWidgetTestWithDelegate);
 };
 
 }  // namespace
 
 TEST_F(ShelfWidgetTestWithDelegate, CreateAutoHideAlwaysShelf) {
   // The actual auto hide state is shown because there are no open windows.
-  TestCreateShelfWithInitialValues(SHELF_ALIGNMENT_BOTTOM,
+  TestCreateShelfWithInitialValues(wm::SHELF_ALIGNMENT_BOTTOM,
                                    SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS,
                                    SHELF_AUTO_HIDE, SHELF_AUTO_HIDE_SHOWN);
 }
 
 TEST_F(ShelfWidgetTestWithDelegate, CreateAutoHideNeverShelf) {
   // The auto hide state 'HIDDEN' is returned for any non-auto-hide behavior.
-  TestCreateShelfWithInitialValues(SHELF_ALIGNMENT_LEFT,
+  TestCreateShelfWithInitialValues(wm::SHELF_ALIGNMENT_LEFT,
                                    SHELF_AUTO_HIDE_BEHAVIOR_NEVER,
                                    SHELF_VISIBLE, SHELF_AUTO_HIDE_HIDDEN);
 }
 
 TEST_F(ShelfWidgetTestWithDelegate, CreateAutoHideAlwaysHideShelf) {
   // The auto hide state 'HIDDEN' is returned for any non-auto-hide behavior.
-  TestCreateShelfWithInitialValues(SHELF_ALIGNMENT_RIGHT,
+  TestCreateShelfWithInitialValues(wm::SHELF_ALIGNMENT_RIGHT,
                                    SHELF_AUTO_HIDE_ALWAYS_HIDDEN, SHELF_HIDDEN,
                                    SHELF_AUTO_HIDE_HIDDEN);
 }
 
 TEST_F(ShelfWidgetTestWithDelegate, CreateLockedShelf) {
   // The auto hide state 'HIDDEN' is returned for any non-auto-hide behavior.
-  TestCreateShelfWithInitialValues(SHELF_ALIGNMENT_BOTTOM_LOCKED,
+  TestCreateShelfWithInitialValues(wm::SHELF_ALIGNMENT_BOTTOM_LOCKED,
                                    SHELF_AUTO_HIDE_BEHAVIOR_NEVER,
                                    SHELF_VISIBLE, SHELF_AUTO_HIDE_HIDDEN);
 }
 
 }  // namespace ash