mash: Use mojo for ShelfItemDelegate and [app] MenuItem.

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/common/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 137 matching lines @@
   void Reset() { selected_ = false; }
 
   void set_item_selected_action(ShelfAction item_selected_action) {
     item_selected_action_ = item_selected_action;
   }
 
   // Returns true if the delegate was selected.
   bool WasSelected() { return selected_; }
 
   // TestShelfItemDelegate:
-  ShelfAction ItemSelected(ui::EventType event_type,
-                           int event_flags,
-                           int64_t display_id,
-                           ShelfLaunchSource source) override {
+  void ItemSelected(std::unique_ptr<ui::Event> event,
+                    int64_t display_id,
+                    ShelfLaunchSource source,
+                    const ItemSelectedCallback& callback) override {
     selected_ = true;
-    return item_selected_action_;
+    callback.Run(item_selected_action_, std::vector<mojom::MenuItemPtr>());
   }
 
  private:
   bool selected_;
 
-  // The action returned from ItemSelected(const ui::Event&).
+  // The action reported by ItemSelected.
   ShelfAction item_selected_action_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfItemSelectionTracker);
 };
 
 TEST_F(WmShelfObserverIconTest, AddRemove) {
   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 139 matching lines @@
   void TearDown() override {
     WebNotificationTray::DisableAnimationsForTest(false);  // Reenable animation
 
     shelf_delegate_ = nullptr;
     test_api_.reset();
     AshTestBase::TearDown();
   }
 
  protected:
   void CreateAndSetShelfItemDelegateForID(ShelfID id) {
-    std::unique_ptr<ShelfItemDelegate> delegate(
-        new TestShelfItemDelegate(NULL));
-    model_->SetShelfItemDelegate(id, std::move(delegate));
+    model_->SetShelfItemDelegate(
+        id, base::MakeUnique<TestShelfItemDelegate>(nullptr));
   }
 
   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 881 matching lines @@
   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;
   model_->SetShelfItemDelegate(
-      browser_shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
+      browser_shelf_id,
+      base::WrapUnique<ShelfItemSelectionTracker>(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;
   model_->SetShelfItemDelegate(
-      shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
+      shelf_id, base::WrapUnique<ShelfItemSelectionTracker>(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);
   button->OnMousePressed(click_event);
@@ skipping 553 matching lines @@
        Launcher_ButtonPressedUserActionsRecordedWhenItemSelected) {
   // TODO: investigate failure in mash, http://crbug.com/695751.
   if (WmShell::Get()->IsRunningInMash())
     return;
 
   base::UserActionTester user_action_tester;
 
   ShelfID browser_shelf_id = model_->items()[browser_index_].id;
   ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
   model_->SetShelfItemDelegate(
-      browser_shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
+      browser_shelf_id,
+      base::WrapUnique<ShelfItemSelectionTracker>(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) {
   // TODO: investigate failure in mash, http://crbug.com/695751.
   if (WmShell::Get()->IsRunningInMash())
     return;
 
   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(SHELF_ACTION_NEW_WINDOW_CREATED);
   model_->SetShelfItemDelegate(
-      browser_shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
+      browser_shelf_id,
+      base::WrapUnique<ShelfItemSelectionTracker>(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;
   model_->SetShelfItemDelegate(
-      browser_shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
+      browser_shelf_id,
+      base::WrapUnique<ShelfItemSelectionTracker>(selection_tracker));
 
   selection_tracker->set_item_selected_action(SHELF_ACTION_WINDOW_MINIMIZED);
   SimulateClick(browser_index_);
 
   selection_tracker->set_item_selected_action(SHELF_ACTION_WINDOW_ACTIVATED);
   SimulateClick(browser_index_);
 
   histogram_tester.ExpectTotalCount(
       kTimeBetweenWindowMinimizedAndActivatedActionsHistogramName, 1);
 }
@@ skipping 94 matching lines @@
 };
 
 // A ShelfItemDelegate that returns a menu for the shelf item.
 class ListMenuShelfItemDelegate : public TestShelfItemDelegate {
  public:
   ListMenuShelfItemDelegate() : TestShelfItemDelegate(nullptr) {}
   ~ListMenuShelfItemDelegate() override {}
 
  private:
   // TestShelfItemDelegate:
-  ShelfAppMenuItemList GetAppMenuItems(int event_flags) override {
-    ShelfAppMenuItemList items;
-    base::string16 title = base::ASCIIToUTF16("title");
-    items.push_back(base::MakeUnique<ShelfApplicationMenuItem>(0, title));
-    items.push_back(base::MakeUnique<ShelfApplicationMenuItem>(1, title));
-    return items;
+  void ItemSelected(std::unique_ptr<ui::Event> event,
+                    int64_t display_id,
+                    ShelfLaunchSource source,
+                    const ItemSelectedCallback& callback) override {
+    // Two items are needed to show a menu; the data in the items is not tested.
+    std::vector<mojom::MenuItemPtr> items;
+    items.push_back(ash::mojom::MenuItem::New());
+    items.push_back(ash::mojom::MenuItem::New());
+    callback.Run(ash::SHELF_ACTION_NONE, std::move(items));
   }
 
   DISALLOW_COPY_AND_ASSIGN(ListMenuShelfItemDelegate);
 };
 
 }  // namespace
 
 // Test fixture for testing material design ink drop ripples on shelf.
 class ShelfViewInkDropTest : public ShelfViewTest {
  public:
@@ skipping 421 matching lines @@
               IsEmpty());
 }
 
 // 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;
   model_->SetShelfItemDelegate(browser_shelf_id,
-                               base::WrapUnique(list_menu_delegate));
+                               base::MakeUnique<ListMenuShelfItemDelegate>());
 
   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());
@@ skipping 565 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