mash: Convert ShelfView to wm common types, clean up Shelf access

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 "ash/common/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "ash/common/shelf/app_list_button.h"
 #include "ash/common/shelf/overflow_bubble.h"
 #include "ash/common/shelf/overflow_bubble_view.h"
 #include "ash/common/shelf/shelf_button.h"
 #include "ash/common/shelf/shelf_constants.h"
+#include "ash/common/shelf/shelf_icon_observer.h"
 #include "ash/common/shelf/shelf_menu_model.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/shelf_tooltip_manager.h"
+#include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/test/material_design_controller_test_api.h"
 #include "ash/common/wm_shell.h"
-#include "ash/root_window_controller.h"
-#include "ash/shelf/shelf.h"
-#include "ash/shelf/shelf_icon_observer.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/ash_test_helper.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/test_shelf_delegate.h"
 #include "ash/test/test_shelf_item_delegate.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/test/test_system_tray_delegate.h"
-#include "base/compiler_specific.h"
 #include "base/i18n/rtl.h"
+#include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/user_action_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/app_list/presenter/app_list_presenter.h"
@@ skipping 137 matching lines @@
   EXPECT_TRUE(observer()->change_notified());
   observer()->Reset();
 
   widget->Show();
   widget->GetNativeWindow()->parent()->RemoveChild(widget->GetNativeWindow());
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->change_notified());
   observer()->Reset();
 }
 
-// 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
 // shelf on external display as well as one on primary.
-TEST_F(ShelfViewIconObserverTest, MAYBE_AddRemoveWithMultipleDisplays) {
+TEST_F(ShelfViewIconObserverTest, AddRemoveWithMultipleDisplays) {
+  if (!SupportsMultipleDisplays())
+    return;
+
   UpdateDisplay("400x400,400x400");
   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();
@@ skipping 10 matching lines @@
   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* widget = Shell::GetPrimaryRootWindowController()->shelf_widget();
+  views::Widget* widget =
+      GetPrimaryShelf()->GetShelfViewForTesting()->GetWidget();
   gfx::Rect shelf_bounds = widget->GetWindowBoundsInScreen();
   shelf_bounds.set_width(shelf_bounds.width() / 2);
   ASSERT_GT(shelf_bounds.width(), 0);
   widget->SetBounds(shelf_bounds);
   // No animation happens for ShelfView bounds change.
   EXPECT_TRUE(observer()->change_notified());
   observer()->Reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 363 matching lines @@
         GetItemId(test_api_for_overflow.GetFirstVisibleIndex());
     int second_last_visible_item_id_in_overflow =
         GetItemId(test_api_for_overflow.GetLastVisibleIndex() - 1);
 
     int drag_item_index = test_api_for_overflow.GetLastVisibleIndex();
     ShelfID drag_item_id = GetItemId(drag_item_index);
     ShelfButton* drag_button = test_api_for_overflow.GetButton(drag_item_index);
     gfx::Point center_point_of_drag_item =
         drag_button->GetBoundsInScreen().CenterPoint();
 
-    ui::test::EventGenerator generator(ash::Shell::GetPrimaryRootWindow(),
-                                       center_point_of_drag_item);
+    ui::test::EventGenerator& generator = GetEventGenerator();
+    generator.set_current_location(center_point_of_drag_item);
     // Rip an item off to OverflowBubble.
     generator.PressLeftButton();
     gfx::Point rip_off_point(center_point_of_drag_item.x(), 0);
     generator.MoveMouseTo(rip_off_point);
     test_api_for_overflow.RunMessageLoopUntilAnimationsDone();
     ASSERT_TRUE(test_api_for_overflow.IsRippedOffFromShelf());
     ASSERT_FALSE(test_api_for_overflow.DraggedItemFromOverflowToShelf());
 
     // Move a dragged item into Shelf at |drop_index|.
     int drop_index = 1;
@@ skipping 338 matching lines @@
   EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
 
   // Test that any two successive visible icons never overlap in all shelf
   // alignment types.
   const ShelfAlignment kAlignments[] = {
       SHELF_ALIGNMENT_LEFT, SHELF_ALIGNMENT_RIGHT, SHELF_ALIGNMENT_BOTTOM,
       SHELF_ALIGNMENT_BOTTOM_LOCKED,
   };
 
   for (ShelfAlignment alignment : kAlignments) {
-    shelf_view_->shelf()->SetAlignment(alignment);
+    shelf_view_->wm_shelf()->SetAlignment(alignment);
     // For every 2 successive visible icons, expect that their bounds don't
     // intersect.
     for (int i = 1; i < test_api_->GetButtonCount() - 1; ++i) {
       if (!(test_api_->GetButton(i)->visible() &&
             test_api_->GetButton(i + 1)->visible())) {
         continue;
       }
 
       const gfx::Rect& bounds1 = test_api_->GetBoundsByIndex(i);
       const gfx::Rect& bounds2 = test_api_->GetBoundsByIndex(i + 1);
       EXPECT_FALSE(bounds1.Intersects(bounds2));
     }
   }
 }
 
 // Making sure the overflow bubble arrow correctly tracks with shelf position.
 TEST_P(ShelfViewTextDirectionTest, OverflowArrowForShelfPosition) {
   const ShelfAlignment kAlignments[] = {
       SHELF_ALIGNMENT_BOTTOM, SHELF_ALIGNMENT_LEFT, SHELF_ALIGNMENT_RIGHT,
       SHELF_ALIGNMENT_BOTTOM_LOCKED,
   };
 
   // These must match what is expected for each alignment above.
   const views::BubbleBorder::Arrow kArrows[] = {
       views::BubbleBorder::BOTTOM_LEFT, views::BubbleBorder::LEFT_TOP,
       views::BubbleBorder::RIGHT_TOP, views::BubbleBorder::BOTTOM_LEFT,
   };
 
   for (size_t i = 0; i < arraysize(kAlignments); i++) {
-    shelf_view_->shelf()->SetAlignment(kAlignments[i]);
+    shelf_view_->wm_shelf()->SetAlignment(kAlignments[i]);
 
     // Make sure there are enough icons to trigger the overflow in new
     // orientation.
     AddButtonsUntilOverflow();
     test_api_->ShowOverflowBubble();
     ASSERT_TRUE(test_api_->overflow_bubble() &&
                 test_api_->overflow_bubble()->IsShowing());
 
     EXPECT_EQ(kArrows[i], test_api_->overflow_bubble()->bubble_view()->arrow());
     OverflowBubbleViewTestAPI bubble_view_api(
@@ skipping 308 matching lines @@
   model_->Set(index, item);
   ASSERT_EQ(ShelfButton::STATE_ACTIVE, button->state());
   item.status = STATUS_ATTENTION;
   model_->Set(index, item);
   ASSERT_EQ(ShelfButton::STATE_ATTENTION, button->state());
 }
 
 // Confirm that shelf item bounds are correctly updated on shelf changes.
 TEST_F(ShelfViewTest, ShelfItemBoundsCheck) {
   VerifyShelfItemBoundsAreValid();
-  shelf_view_->shelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
+  shelf_view_->wm_shelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   test_api_->RunMessageLoopUntilAnimationsDone();
   VerifyShelfItemBoundsAreValid();
-  shelf_view_->shelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
+  shelf_view_->wm_shelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   test_api_->RunMessageLoopUntilAnimationsDone();
   VerifyShelfItemBoundsAreValid();
 }
 
 TEST_F(ShelfViewTest, ShelfTooltipTest) {
   ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, test_api_->GetButtonCount());
 
   // Prepare some items to the shelf.
   ShelfID app_button_id = AddAppShortcut();
   ShelfID platform_button_id = AddPlatformApp();
 
   ShelfButton* app_button = GetButtonByID(app_button_id);
   ShelfButton* platform_button = GetButtonByID(platform_button_id);
 
   ShelfTooltipManager* tooltip_manager = test_api_->tooltip_manager();
   EXPECT_TRUE(test_api_->shelf_view()->GetWidget()->GetNativeWindow());
-  ui::test::EventGenerator generator(ash::Shell::GetPrimaryRootWindow());
+  ui::test::EventGenerator& generator = GetEventGenerator();
 
   generator.MoveMouseTo(app_button->GetBoundsInScreen().CenterPoint());
   // There's a delay to show the tooltip, so it's not visible yet.
   EXPECT_FALSE(tooltip_manager->IsVisible());
   EXPECT_EQ(nullptr, tooltip_manager->GetCurrentAnchorView());
 
   tooltip_manager->ShowTooltip(app_button);
   EXPECT_TRUE(tooltip_manager->IsVisible());
   EXPECT_EQ(app_button, tooltip_manager->GetCurrentAnchorView());
 
@@ skipping 129 matching lines @@
   AppListButton* app_list_button = shelf_view_->GetAppListButton();
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       app_list_button->GetMirroredBounds().CenterPoint()));
 }
 
 // Test that by moving the mouse cursor off the button onto the bubble it closes
 // the bubble.
 TEST_F(ShelfViewTest, ShouldHideTooltipWhenHoveringOnTooltip) {
   ShelfTooltipManager* tooltip_manager = test_api_->tooltip_manager();
   tooltip_manager->set_timer_delay_for_test(0);
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
+  ui::test::EventGenerator& generator = GetEventGenerator();
 
   // Move the mouse off any item and check that no tooltip is shown.
   generator.MoveMouseTo(gfx::Point(0, 0));
   EXPECT_FALSE(tooltip_manager->IsVisible());
 
   // Move the mouse over the button and check that it is visible.
   AppListButton* app_list_button = shelf_view_->GetAppListButton();
   gfx::Rect bounds = app_list_button->GetBoundsInScreen();
   generator.MoveMouseTo(bounds.CenterPoint());
   // Wait for the timer to go off.
@@ skipping 71 matching lines @@
               test_api_->overflow_bubble()->IsShowing());
 
   ShelfViewTestAPI test_for_overflow_view(
       test_api_->overflow_bubble()->shelf_view());
 
   int ripped_index = test_for_overflow_view.GetLastVisibleIndex();
   gfx::Size bubble_size = test_for_overflow_view.GetPreferredSize();
   int item_width = test_for_overflow_view.GetButtonSize() +
                    test_for_overflow_view.GetButtonSpacing();
 
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                     gfx::Point());
+  ui::test::EventGenerator& generator = GetEventGenerator();
   ShelfButton* button = test_for_overflow_view.GetButton(ripped_index);
   // Rip off the last visible item.
   gfx::Point start_point = button->GetBoundsInScreen().CenterPoint();
   gfx::Point rip_off_point(start_point.x(), 0);
   generator.MoveMouseTo(start_point.x(), start_point.y());
   base::RunLoop().RunUntilIdle();
   generator.PressLeftButton();
   base::RunLoop().RunUntilIdle();
   generator.MoveMouseTo(rip_off_point.x(), rip_off_point.y());
   base::RunLoop().RunUntilIdle();
@@ skipping 205 matching lines @@
   // invisible.
   SetShelfItemTypeToAppShortcut(platform_app_id);
   EXPECT_FALSE(GetButtonByID(platform_app_id)->visible());
 }
 
 // Tests that the AppListButton renders as active in response to touches.
 TEST_F(ShelfViewTest, AppListButtonTouchFeedback) {
   AppListButton* app_list_button = shelf_view_->GetAppListButton();
   EXPECT_FALSE(app_list_button->draw_background_as_active());
 
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
+  ui::test::EventGenerator& generator = GetEventGenerator();
   generator.set_current_location(
       app_list_button->GetBoundsInScreen().CenterPoint());
   generator.PressTouch();
   EXPECT_TRUE(app_list_button->draw_background_as_active());
 
   generator.ReleaseTouch();
   EXPECT_FALSE(app_list_button->draw_background_as_active());
   EXPECT_TRUE(WmShell::Get()->GetAppListTargetVisibility());
 }
 
 // Tests that a touch that slides out of the bounds of the AppListButton leads
 // to the end of rendering an active state.
 TEST_F(ShelfViewTest, AppListButtonTouchFeedbackCancellation) {
   AppListButton* app_list_button = shelf_view_->GetAppListButton();
   EXPECT_FALSE(app_list_button->draw_background_as_active());
 
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
+  ui::test::EventGenerator& generator = GetEventGenerator();
   generator.set_current_location(
       app_list_button->GetBoundsInScreen().CenterPoint());
   generator.PressTouch();
   EXPECT_TRUE(app_list_button->draw_background_as_active());
 
   gfx::Point moved_point(
       app_list_button->GetBoundsInScreen().right() + 1,
       app_list_button->GetBoundsInScreen().CenterPoint().y());
   generator.MoveTouch(moved_point);
   EXPECT_FALSE(app_list_button->draw_background_as_active());
@@ skipping 707 matching lines @@
   test_api_->CloseMenu();
   EXPECT_EQ(views::InkDropState::HIDDEN,
             browser_button_ink_drop_->GetTargetInkDropState());
   EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::ACTIVATED,
                           views::InkDropState::DEACTIVATED));
 }
 
 }  // namespace test
 }  // namespace ash