mash: Fold ShelfItemDelegateManager into ShelfModel

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/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_constants.h"
-#include "ash/common/shelf/shelf_item_delegate_manager.h"
 #include "ash/common/shelf/shelf_menu_model.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm_shell.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_icon_observer.h"
 #include "ash/shelf/shelf_tooltip_manager.h"
 #include "ash/shelf/shelf_widget.h"
@@ skipping 275 matching lines @@
   std::string app_id_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShelfDelegateForShelfView);
 };
 
 class ShelfViewTest : public AshTestBase {
  public:
   static const char*
       kTimeBetweenWindowMinimizedAndActivatedActionsHistogramName;
 
-  ShelfViewTest()
-      : model_(NULL),
-        shelf_view_(NULL),
-        browser_index_(1),
-        item_manager_(NULL) {}
+  ShelfViewTest() : model_(nullptr), shelf_view_(nullptr), browser_index_(1) {}
   ~ShelfViewTest() override {}
 
   void SetUp() override {
     AshTestBase::SetUp();
     ShellTestApi test_api(Shell::GetInstance());
     model_ = test_api.shelf_model();
     Shelf* shelf = Shelf::ForPrimaryDisplay();
     shelf_view_ = ShelfTestAPI(shelf).shelf_view();
 
     // The bounds should be big enough for 4 buttons + overflow chevron.
     shelf_view_->SetBounds(0, 0, 500, GetShelfConstant(SHELF_SIZE));
 
     test_api_.reset(new ShelfViewTestAPI(shelf_view_));
     test_api_->SetAnimationDuration(1);  // Speeds up animation for test.
 
     ReplaceShelfDelegate();
 
-    item_manager_ = Shell::GetInstance()->shelf_item_delegate_manager();
-    DCHECK(item_manager_);
-
     // Add browser shortcut shelf item at index 0 for test.
     AddBrowserShortcut();
   }
 
   void TearDown() override {
     shelf_delegate_ = nullptr;
     test_api_.reset();
     AshTestBase::TearDown();
   }
 
  protected:
   void CreateAndSetShelfItemDelegateForID(ShelfID id) {
     std::unique_ptr<ShelfItemDelegate> delegate(
         new TestShelfItemDelegate(NULL));
-    item_manager_->SetShelfItemDelegate(id, std::move(delegate));
+    model_->SetShelfItemDelegate(id, std::move(delegate));
   }
 
   ShelfID AddBrowserShortcut() {
     ShelfItem browser_shortcut;
     browser_shortcut.type = TYPE_BROWSER_SHORTCUT;
 
     ShelfID id = model_->next_id();
     model_->AddAt(browser_index_, browser_shortcut);
     CreateAndSetShelfItemDelegateForID(id);
     test_api_->RunMessageLoopUntilAnimationsDone();
@@ skipping 336 matching lines @@
     shell_test_api.SetShelfDelegate(NULL);
     shelf_delegate_ = new TestShelfDelegateForShelfView();
     shell_test_api.SetShelfDelegate(shelf_delegate_);
     ShelfTestAPI(Shelf::ForPrimaryDisplay()).set_delegate(shelf_delegate_);
     test_api_->SetShelfDelegate(shelf_delegate_);
   }
 
   ShelfModel* model_;
   ShelfView* shelf_view_;
   int browser_index_;
-  ShelfItemDelegateManager* item_manager_;
 
   // Owned by ash::Shell.
   TestShelfDelegateForShelfView* shelf_delegate_;
 
   std::unique_ptr<ShelfViewTestAPI> test_api_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShelfViewTest);
 };
 
@@ skipping 484 matching lines @@
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 }
 
 // Check that whether the ash behaves correctly if not draggable
 // item are in front of the shelf.
 TEST_F(ShelfViewTest, DragWithNotDraggableItemInFront) {
   std::vector<std::pair<ShelfID, views::View*>> id_map;
   SetupForDragTest(&id_map);
 
   (static_cast<TestShelfItemDelegate*>(
-       item_manager_->GetShelfItemDelegate(id_map[1].first)))
+       model_->GetShelfItemDelegate(id_map[1].first)))
       ->set_is_draggable(false);
   (static_cast<TestShelfItemDelegate*>(
-       item_manager_->GetShelfItemDelegate(id_map[2].first)))
+       model_->GetShelfItemDelegate(id_map[2].first)))
       ->set_is_draggable(false);
 
   ASSERT_NO_FATAL_FAILURE(DragAndVerify(3, 1, shelf_view_, id_map));
   ASSERT_NO_FATAL_FAILURE(DragAndVerify(3, 2, shelf_view_, id_map));
 
   std::rotate(id_map.begin() + 3, id_map.begin() + 4, id_map.begin() + 5);
   ASSERT_NO_FATAL_FAILURE(DragAndVerify(4, 1, shelf_view_, id_map));
   std::rotate(id_map.begin() + 3, id_map.begin() + 5, id_map.begin() + 6);
   ASSERT_NO_FATAL_FAILURE(DragAndVerify(5, 1, shelf_view_, id_map));
 }
@@ skipping 14 matching lines @@
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, false);
   EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
 }
 
 // Tests that double-clicking an item does not activate it twice.
 TEST_F(ShelfViewTest, ClickingTwiceActivatesOnce) {
   // Watch for selection of the browser shortcut.
   ShelfID browser_shelf_id = model_->items()[browser_index_].id;
   ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
-  item_manager_->SetShelfItemDelegate(
+  model_->SetShelfItemDelegate(
       browser_shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
 
   // A single click selects the item.
   SimulateClick(browser_index_);
   EXPECT_TRUE(selection_tracker->WasSelected());
 
   // A double-click does not select the item.
   selection_tracker->Reset();
   SimulateDoubleClick(browser_index_);
   EXPECT_FALSE(selection_tracker->WasSelected());
 }
 
 // Check that clicking an item and jittering the mouse a bit still selects the
 // item.
 TEST_F(ShelfViewTest, ClickAndMoveSlightly) {
   std::vector<std::pair<ShelfID, views::View*>> id_map;
   SetupForDragTest(&id_map);
 
   ShelfID shelf_id = (id_map.begin() + 1)->first;
   views::View* button = (id_map.begin() + 1)->second;
 
   // Replace the ShelfItemDelegate for |shelf_id| with one which tracks whether
   // the shelf item gets selected.
   ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
-  item_manager_->SetShelfItemDelegate(
+  model_->SetShelfItemDelegate(
       shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
 
   gfx::Vector2d press_offset(5, 30);
   gfx::Point press_location = gfx::Point() + press_offset;
   gfx::Point press_location_in_screen =
       button->GetBoundsInScreen().origin() + press_offset;
 
   ui::MouseEvent click_event(ui::ET_MOUSE_PRESSED, press_location,
                              press_location_in_screen, ui::EventTimeForNow(),
                              ui::EF_LEFT_MOUSE_BUTTON, 0);
@@ skipping 587 matching lines @@
 }
 
 // Verifies that Launcher_ButtonPressed_* UMA user actions are recorded when an
 // item is selected.
 TEST_F(ShelfViewTest,
        Launcher_ButtonPressedUserActionsRecordedWhenItemSelected) {
   base::UserActionTester user_action_tester;
 
   ShelfID browser_shelf_id = model_->items()[browser_index_].id;
   ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
-  item_manager_->SetShelfItemDelegate(
+  model_->SetShelfItemDelegate(
       browser_shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
 
   SimulateClick(browser_index_);
   EXPECT_EQ(1,
             user_action_tester.GetActionCount("Launcher_ButtonPressed_Mouse"));
 }
 
 // Verifies that Launcher_*Task UMA user actions are recorded when an item is
 // selected.
 TEST_F(ShelfViewTest, Launcher_TaskUserActionsRecordedWhenItemSelected) {
   base::UserActionTester user_action_tester;
 
   ShelfID browser_shelf_id = model_->items()[browser_index_].id;
   ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
   selection_tracker->set_item_selected_action(
       ShelfItemDelegate::kNewWindowCreated);
-  item_manager_->SetShelfItemDelegate(
+  model_->SetShelfItemDelegate(
       browser_shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
 
   SimulateClick(browser_index_);
   EXPECT_EQ(1, user_action_tester.GetActionCount("Launcher_LaunchTask"));
 }
 
 // Verifies that metrics are recorded when an item is minimized and subsequently
 // activated.
 TEST_F(ShelfViewTest,
        VerifyMetricsAreRecordedWhenAnItemIsMinimizedAndActivated) {
   base::HistogramTester histogram_tester;
 
   ShelfID browser_shelf_id = model_->items()[browser_index_].id;
   ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
-  item_manager_->SetShelfItemDelegate(
+  model_->SetShelfItemDelegate(
       browser_shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
 
   selection_tracker->set_item_selected_action(
       ShelfItemDelegate::kExistingWindowMinimized);
   SimulateClick(browser_index_);
 
   selection_tracker->set_item_selected_action(
       ShelfItemDelegate::kExistingWindowActivated);
   SimulateClick(browser_index_);
 
@@ skipping 635 matching lines @@
 }
 
 // Tests that clicking on a shelf item that shows an app list menu transitions
 // ink drop state correctly.
 TEST_F(ShelfViewInkDropTest, ShelfButtonWithMenuPressRelease) {
   InitBrowserButtonInkDrop();
 
   // Set a delegate for the shelf item that returns an app list menu.
   ShelfID browser_shelf_id = model_->items()[browser_index_].id;
   ListMenuShelfItemDelegate* list_menu_delegate = new ListMenuShelfItemDelegate;
-  item_manager_->SetShelfItemDelegate(browser_shelf_id,
-                                      base::WrapUnique(list_menu_delegate));
+  model_->SetShelfItemDelegate(browser_shelf_id,
+                               base::WrapUnique(list_menu_delegate));
 
   views::CustomButton* button = browser_button_;
   gfx::Point mouse_location = button->GetLocalBounds().CenterPoint();
 
   ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, mouse_location,
                              mouse_location, ui::EventTimeForNow(),
                              ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMousePressed(press_event);
   EXPECT_EQ(views::InkDropState::ACTION_PENDING,
             browser_button_ink_drop_->GetTargetInkDropState());
   EXPECT_THAT(browser_button_ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::ACTION_PENDING));
 
   // Mouse release will spawn a menu which we will then close.
   ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, mouse_location,
                                mouse_location, ui::EventTimeForNow(),
                                ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseReleased(release_event);
   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