ash: Move alignment and autohide behavior from Shelf to WmShelf

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/common/shelf/shelf_widget.h"
 
 #include "ash/common/material_design/material_design_controller.h"
-#include "ash/common/shelf/shelf.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_layout_manager.h"
 #include "ash/common/shelf/shelf_view.h"
+#include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/system/status_area_widget.h"
+#include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/test/ash_md_test_base.h"
 #include "ash/test/ash_test_helper.h"
 #include "ash/test/shelf_test_api.h"
 #include "ash/test/shelf_view_test_api.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/window_util.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/display/display.h"
 #include "ui/events/event_utils.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 
 namespace {
 
 ShelfWidget* GetShelfWidget() {
-  return Shelf::ForPrimaryDisplay()->shelf_widget();
+  return test::AshTestBase::GetPrimaryShelf()->GetShelfWidgetForTesting();
 }
 
 ShelfLayoutManager* GetShelfLayoutManager() {
   return GetShelfWidget()->shelf_layout_manager();
 }
 
 }  // namespace
 
 using ShelfWidgetTest = test::AshMDTestBase;
 
 INSTANTIATE_TEST_CASE_P(
     /* prefix intentionally left blank due to only one parameterization */,
     ShelfWidgetTest,
     testing::Values(MaterialDesignController::NON_MATERIAL,
                     MaterialDesignController::MATERIAL_NORMAL,
                     MaterialDesignController::MATERIAL_EXPERIMENTAL));
 
 void TestLauncherAlignment(WmWindow* root,
                            ShelfAlignment alignment,
                            const gfx::Rect& expected) {
-  Shelf::ForWindow(root)->SetAlignment(alignment);
+  root->GetRootWindowController()->GetShelf()->SetAlignment(alignment);
   EXPECT_EQ(expected.ToString(),
             root->GetDisplayNearestWindow().work_area().ToString());
 }
 
 TEST_P(ShelfWidgetTest, TestAlignment) {
   if (!SupportsHostWindowResize())
     return;
 
   // Note that for a left- and right-aligned shelf, this offset must be
   // applied to a maximized window's width rather than its height.
@@ skipping 74 matching lines @@
   {
     SCOPED_TRACE("Secondary Left");
     TestLauncherAlignment(root_windows[1], SHELF_ALIGNMENT_LEFT,
                           gfx::Rect(300 + kShelfSize, 0, 453 + offset, 500));
   }
 }
 
 // Makes sure the shelf is initially sized correctly.
 TEST_P(ShelfWidgetTest, LauncherInitiallySized) {
   ShelfWidget* shelf_widget = GetShelfWidget();
-  Shelf* shelf = shelf_widget->shelf();
-  ASSERT_TRUE(shelf);
   ShelfLayoutManager* shelf_layout_manager = GetShelfLayoutManager();
   ASSERT_TRUE(shelf_layout_manager);
   ASSERT_TRUE(shelf_widget->status_area_widget());
   int status_width =
       shelf_widget->status_area_widget()->GetWindowBoundsInScreen().width();
   // Test only makes sense if the status is > 0, which it better be.
   EXPECT_GT(status_width, 0);
-  EXPECT_EQ(status_width, shelf_widget->GetContentsView()->width() -
-                              test::ShelfTestAPI(shelf).shelf_view()->width());
+  EXPECT_EQ(status_width,
+            shelf_widget->GetContentsView()->width() -
+                GetPrimaryShelf()->GetShelfViewForTesting()->width());
 }
 
 // Verifies when the shell is deleted with a full screen window we don't crash.
 TEST_P(ShelfWidgetTest, DontReferenceShelfAfterDeletion) {
   views::Widget* widget = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
   params.bounds = gfx::Rect(0, 0, 200, 200);
   params.context = CurrentContext();
   // Widget is now owned by the parent window.
   widget->Init(params);
@@ skipping 75 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* shelf = Shelf::ForPrimaryDisplay();
+  WmShelf* shelf = GetPrimaryShelf();
   shelf->SetAlignment(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);
@@ skipping 23 matching lines @@
     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(shelf_widget->GetNativeWindow(), target);
   }
 }
 
 // Tests that the shelf has a slightly larger hit-region for touch-events when
 // it's in the auto-hidden state.
 TEST_P(ShelfWidgetTest, HiddenShelfHitTestTouch) {
-  Shelf* shelf = Shelf::ForPrimaryDisplay();
+  WmShelf* shelf = GetPrimaryShelf();
   ShelfWidget* shelf_widget = GetShelfWidget();
   gfx::Rect shelf_bounds = shelf_widget->GetWindowBoundsInScreen();
   EXPECT_TRUE(!shelf_bounds.IsEmpty());
   ShelfLayoutManager* shelf_layout_manager =
       shelf_widget->shelf_layout_manager();
   ASSERT_TRUE(shelf_layout_manager);
   EXPECT_EQ(SHELF_VISIBLE, shelf_layout_manager->visibility_state());
 
   // Create a widget to make sure that the shelf does auto-hide.
   views::Widget* widget = new views::Widget;
@@ skipping 42 matching lines @@
 class TestShelfDelegate : public ShelfDelegate {
  public:
   TestShelfDelegate(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_);
+    shelf->wm_shelf()->SetAlignment(initial_alignment_);
+    shelf->wm_shelf()->SetAutoHideBehavior(initial_auto_hide_behavior_);
   }
   void OnShelfDestroyed(Shelf* shelf) override {}
   void OnShelfAlignmentChanged(Shelf* shelf) override {}
   void OnShelfAutoHideBehaviorChanged(Shelf* shelf) override {}
   void OnShelfAutoHideStateChanged(Shelf* shelf) override {}
   void OnShelfVisibilityStateChanged(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();
@@ skipping 55 matching lines @@
       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();
     ASSERT_NE(nullptr, shelf_widget);
-    Shelf* shelf = shelf_widget->shelf();
+    WmShelf* shelf = GetPrimaryShelf();
     ASSERT_NE(nullptr, shelf);
     ShelfLayoutManager* shelf_layout_manager =
         shelf_widget->shelf_layout_manager();
     ASSERT_NE(nullptr, shelf_layout_manager);
 
     EXPECT_EQ(initial_alignment, shelf->alignment());
     EXPECT_EQ(initial_auto_hide_behavior, shelf->auto_hide_behavior());
     EXPECT_EQ(expected_shelf_visibility_state,
               shelf_layout_manager->visibility_state());
     EXPECT_EQ(expected_shelf_auto_hide_state,
@@ skipping 36 matching lines @@
 }
 
 TEST_P(ShelfWidgetTestWithDelegate, CreateLockedShelf) {
   // The auto hide state 'HIDDEN' is returned for any non-auto-hide behavior.
   TestCreateShelfWithInitialValues(SHELF_ALIGNMENT_BOTTOM_LOCKED,
                                    SHELF_AUTO_HIDE_BEHAVIOR_NEVER,
                                    SHELF_VISIBLE, SHELF_AUTO_HIDE_HIDDEN);
 }
 
 }  // namespace ash