chromeos: Rename ash::WmShelf to Shelf

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 <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "ash/public/cpp/config.h"
 #include "ash/public/cpp/shelf_item_delegate.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/app_list_button.h"
 #include "ash/shelf/overflow_bubble.h"
 #include "ash/shelf/overflow_bubble_view.h"
 #include "ash/shelf/overflow_button.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_model.h"
+#include "ash/shelf/shelf_observer.h"
 #include "ash/shelf/shelf_tooltip_manager.h"
 #include "ash/shelf/shelf_widget.h"
-#include "ash/shelf/wm_shelf.h"
-#include "ash/shelf/wm_shelf_observer.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/system/web_notification/web_notification_tray.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/overflow_button_test_api.h"
 #include "ash/test/shelf_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_shell_delegate.h"
@@ skipping 41 matching lines @@
 namespace test {
 namespace {
 
 int64_t GetPrimaryDisplayId() {
   return display::Screen::GetScreen()->GetPrimaryDisplay().id();
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
-// WmShelfObserver::OnShelfIconPositionsChanged tests.
+// ShelfObserver::OnShelfIconPositionsChanged tests.
 
-class TestWmShelfObserver : public WmShelfObserver {
+class TestShelfObserver : public ShelfObserver {
  public:
-  explicit TestWmShelfObserver(WmShelf* shelf) : shelf_(shelf) {
+  explicit TestShelfObserver(Shelf* shelf) : shelf_(shelf) {
     shelf_->AddObserver(this);
   }
 
-  ~TestWmShelfObserver() override { shelf_->RemoveObserver(this); }
+  ~TestShelfObserver() override { shelf_->RemoveObserver(this); }
 
-  // WmShelfObserver implementation.
+  // ShelfObserver implementation.
   void OnShelfIconPositionsChanged() override {
     icon_positions_changed_ = true;
   }
 
   bool icon_positions_changed() const { return icon_positions_changed_; }
   void Reset() { icon_positions_changed_ = false; }
 
  private:
-  WmShelf* shelf_;
+  Shelf* shelf_;
   bool icon_positions_changed_ = false;
 
-  DISALLOW_COPY_AND_ASSIGN(TestWmShelfObserver);
+  DISALLOW_COPY_AND_ASSIGN(TestShelfObserver);
 };
 
-class WmShelfObserverIconTest : public AshTestBase {
+class ShelfObserverIconTest : public AshTestBase {
  public:
-  WmShelfObserverIconTest() {}
-  ~WmShelfObserverIconTest() override {}
+  ShelfObserverIconTest() {}
+  ~ShelfObserverIconTest() override {}
 
   void SetUp() override {
     AshTestBase::SetUp();
-    observer_.reset(new TestWmShelfObserver(GetPrimaryShelf()));
+    observer_.reset(new TestShelfObserver(GetPrimaryShelf()));
     shelf_view_test_.reset(
         new ShelfViewTestAPI(GetPrimaryShelf()->GetShelfViewForTesting()));
     shelf_view_test_->SetAnimationDuration(1);
   }
 
   void TearDown() override {
     observer_.reset();
     AshTestBase::TearDown();
   }
 
-  TestWmShelfObserver* observer() { return observer_.get(); }
+  TestShelfObserver* observer() { return observer_.get(); }
 
   ShelfViewTestAPI* shelf_view_test() { return shelf_view_test_.get(); }
 
  private:
-  std::unique_ptr<TestWmShelfObserver> observer_;
+  std::unique_ptr<TestShelfObserver> observer_;
   std::unique_ptr<ShelfViewTestAPI> shelf_view_test_;
 
-  DISALLOW_COPY_AND_ASSIGN(WmShelfObserverIconTest);
+  DISALLOW_COPY_AND_ASSIGN(ShelfObserverIconTest);
 };
 
 // A ShelfItemDelegate that tracks selections and reports a custom action.
 class ShelfItemSelectionTracker : public ShelfItemDelegate {
  public:
   ShelfItemSelectionTracker() : ShelfItemDelegate(ShelfID()) {}
   ~ShelfItemSelectionTracker() override {}
 
   size_t item_selected_count() const { return item_selected_count_; }
   void set_item_selected_action(ShelfAction item_selected_action) {
@@ skipping 11 matching lines @@
   void ExecuteCommand(uint32_t command_id, int32_t event_flags) override {}
   void Close() override {}
 
  private:
   size_t item_selected_count_ = 0;
   ShelfAction item_selected_action_ = SHELF_ACTION_NONE;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfItemSelectionTracker);
 };
 
-TEST_F(WmShelfObserverIconTest, AddRemove) {
+TEST_F(ShelfObserverIconTest, AddRemove) {
   ShelfItem item;
   item.id = ShelfID("foo");
   item.type = TYPE_APP;
   EXPECT_FALSE(observer()->icon_positions_changed());
   const int shelf_item_index = Shell::Get()->shelf_model()->Add(item);
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->icon_positions_changed());
   observer()->Reset();
 
   EXPECT_FALSE(observer()->icon_positions_changed());
   Shell::Get()->shelf_model()->RemoveItemAt(shelf_item_index);
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->icon_positions_changed());
   observer()->Reset();
 }
 
 // Make sure creating/deleting an window on one displays notifies a
 // shelf on external display as well as one on primary.
-TEST_F(WmShelfObserverIconTest, AddRemoveWithMultipleDisplays) {
+TEST_F(ShelfObserverIconTest, AddRemoveWithMultipleDisplays) {
   // TODO: investigate failure in mash, http://crbug.com/695751.
   if (Shell::GetAshConfig() == Config::MASH)
     return;
 
   UpdateDisplay("400x400,400x400");
   observer()->Reset();
 
-  WmShelf* second_shelf = WmShelf::ForWindow(Shell::GetAllRootWindows()[1]);
-  TestWmShelfObserver second_observer(second_shelf);
+  Shelf* second_shelf = Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
+  TestShelfObserver second_observer(second_shelf);
 
   ShelfItem item;
   item.id = ShelfID("foo");
   item.type = TYPE_APP;
   EXPECT_FALSE(observer()->icon_positions_changed());
   EXPECT_FALSE(second_observer.icon_positions_changed());
   const int shelf_item_index = Shell::Get()->shelf_model()->Add(item);
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->icon_positions_changed());
   EXPECT_TRUE(second_observer.icon_positions_changed());
   observer()->Reset();
   second_observer.Reset();
 
   EXPECT_FALSE(observer()->icon_positions_changed());
   EXPECT_FALSE(second_observer.icon_positions_changed());
   Shell::Get()->shelf_model()->RemoveItemAt(shelf_item_index);
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->icon_positions_changed());
   EXPECT_TRUE(second_observer.icon_positions_changed());
 
   observer()->Reset();
   second_observer.Reset();
 }
 
-TEST_F(WmShelfObserverIconTest, BoundsChanged) {
+TEST_F(ShelfObserverIconTest, BoundsChanged) {
   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()->icon_positions_changed());
   observer()->Reset();
 }
@@ skipping 669 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_->wm_shelf()->SetAlignment(alignment);
+    shelf_view_->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);
@@ skipping 348 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_->wm_shelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
+  shelf_view_->shelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   test_api_->RunMessageLoopUntilAnimationsDone();
   VerifyShelfItemBoundsAreValid();
-  shelf_view_->wm_shelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
+  shelf_view_->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 = AddApp();
@@ skipping 337 matching lines @@
       test_for_overflow_view.GetBoundsForDragInsertInScreen();
   first_point = first_button->GetBoundsInScreen().CenterPoint();
   last_point = last_button->GetBoundsInScreen().CenterPoint();
   EXPECT_FALSE(drag_reinsert_bounds.Contains(first_point));
   EXPECT_TRUE(drag_reinsert_bounds.Contains(last_point));
 }
 
 // Check the drag insertion bounds of shelf view in multi monitor environment.
 TEST_F(ShelfViewTest, CheckDragInsertBoundsWithMultiMonitor) {
   UpdateDisplay("800x600,800x600");
-  WmShelf* secondary_shelf = WmShelf::ForWindow(Shell::GetAllRootWindows()[1]);
+  Shelf* secondary_shelf = Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
   ShelfView* shelf_view_for_secondary =
       secondary_shelf->GetShelfViewForTesting();
 
   // The bounds should be big enough for 4 buttons + overflow chevron.
   shelf_view_for_secondary->SetBounds(0, 0, 500, kShelfSize);
 
   ShelfViewTestAPI test_api_for_secondary(shelf_view_for_secondary);
   // Speeds up animation for test.
   test_api_for_secondary.SetAnimationDuration(1);
 
@@ skipping 44 matching lines @@
   // Checks that a point of overflow bubble in primary shelf should not be
   // contained by insert bounds of secondary shelf.
   EXPECT_FALSE(drag_reinsert_bounds_in_secondary.Contains(point_in_shelf_view));
 }
 
 // Checks the rip an item off from left aligned shelf in secondary monitor.
 TEST_F(ShelfViewTest, CheckRipOffFromLeftShelfAlignmentWithMultiMonitor) {
   UpdateDisplay("800x600,800x600");
   ASSERT_EQ(2U, ShellPort::Get()->GetAllRootWindows().size());
 
-  WmShelf* secondary_shelf = WmShelf::ForWindow(Shell::GetAllRootWindows()[1]);
+  Shelf* secondary_shelf = Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
 
   secondary_shelf->SetAlignment(SHELF_ALIGNMENT_LEFT);
   ASSERT_EQ(SHELF_ALIGNMENT_LEFT, secondary_shelf->alignment());
 
   // Initially, app list and browser shortcut are added.
   EXPECT_EQ(2, model_->item_count());
   int browser_index = model_->GetItemIndexForType(TYPE_BROWSER_SHORTCUT);
   EXPECT_GT(browser_index, 0);
 
   ShelfView* shelf_view_for_secondary =
@@ skipping 802 matching lines @@
 };
 
 // A test ShellDelegate implementation for overflow button tests that returns a
 // TestShelfMenuModel for the shell context menu.
 class TestOverflowButtonShellDelegate : public TestShellDelegate {
  public:
   TestOverflowButtonShellDelegate() {}
   ~TestOverflowButtonShellDelegate() override {}
 
   // TestShellDelegate:
-  ui::MenuModel* CreateContextMenu(WmShelf* wm_shelf,
+  ui::MenuModel* CreateContextMenu(Shelf* shelf,
                                    const ShelfItem* item) override {
     // Caller takes ownership of the returned object.
     return new TestShellMenuModel;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestOverflowButtonShellDelegate);
 };
 
 std::string ToString(ShelfAlignment shelf_alignment) {
@@ skipping 593 matching lines @@
   EXPECT_EQ(views::InkDropState::ACTIVATED,
             overflow_button_ink_drop_->GetTargetInkDropState());
   EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
               IsEmpty());
 
   ASSERT_TRUE(test_api_->IsShowingOverflowBubble());
 }
 
 }  // namespace test
 }  // namespace ash