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

chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl_unittest.cc

 // Copyright 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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 140 matching lines @@
 
   void ShelfItemChanged(int index, const ash::ShelfItem& old_item) override {
     ++changed_;
     last_index_ = index;
   }
 
   void ShelfItemMoved(int start_index, int target_index) override {
     last_index_ = target_index;
   }
 
-  void OnSetShelfItemDelegate(ash::ShelfID id,
-                              ash::ShelfItemDelegate* item_delegate) override {}
+  void OnSetShelfItemDelegate(
+      ash::ShelfID id,
+      ash::mojom::ShelfItemDelegate* item_delegate) override {}
 
   void clear_counts() {
     added_ = 0;
     removed_ = 0;
     changed_ = 0;
     last_index_ = 0;
   }
 
   int added() const { return added_; }
   int removed() const { return removed_; }
@@ skipping 82 matching lines @@
 // Test implementation of a V2 app launcher item controller.
 class TestV2AppLauncherItemController : public LauncherItemController {
  public:
   TestV2AppLauncherItemController(const std::string& app_id,
                                   ChromeLauncherController* controller)
       : LauncherItemController(app_id, std::string(), controller) {}
 
   ~TestV2AppLauncherItemController() override {}
 
   // Override for LauncherItemController:
-  ash::ShelfAction ItemSelected(ui::EventType event_type,
-                                int event_flags,
-                                int64_t display_id,
-                                ash::ShelfLaunchSource source) override {
-    return ash::SHELF_ACTION_WINDOW_ACTIVATED;
+  void ItemSelected(std::unique_ptr<ui::Event> event,
+                    int64_t display_id,
+                    ash::ShelfLaunchSource source,
+                    const ItemSelectedCallback& callback) override {
+    callback.Run(ash::SHELF_ACTION_WINDOW_ACTIVATED,
+                 std::vector<ash::mojom::MenuItemPtr>());
   }
-  ash::ShelfAppMenuItemList GetAppMenuItems(int event_flags) override {
-    ash::ShelfAppMenuItemList items;
-    items.push_back(
-        base::MakeUnique<ash::ShelfApplicationMenuItem>(0, base::string16()));
-    items.push_back(
-        base::MakeUnique<ash::ShelfApplicationMenuItem>(1, base::string16()));
-    return items;
-  }
-  void ExecuteCommand(uint32_t command_id, int event_flags) override {}
+  void ExecuteCommand(uint32_t command_id, int32_t event_flags) override {}
   void Close() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestV2AppLauncherItemController);
 };
 
 // Proxies to ShelfDelegate invocation to the given
 // ChromeLauncherControllerImpl instance. Because of ownership management,
 // ChromeLauncherControllerImpl instance cannot be injected to WmShell.
 // This wraps the instance, so that it can be injected.
@@ skipping 2554 matching lines @@
   expected_launchers.insert(expected_launchers.begin() + 1, extension2_->id());
   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 }
 
 // Ensure |controller| creates the expected menu items for the given shelf item.
 void CheckAppMenu(ChromeLauncherControllerImpl* controller,
                   const ash::ShelfItem& item,
                   size_t expected_item_count,
                   base::string16 expected_item_titles[]) {
-  ash::ShelfAppMenuItemList items = controller->GetAppMenuItemsForTesting(item);
+  std::vector<ash::mojom::MenuItemPtr> items =
+      controller->GetAppMenuItemsForTesting(item);
   ASSERT_EQ(expected_item_count, items.size());
   for (size_t i = 0; i < expected_item_count; i++)
-    EXPECT_EQ(expected_item_titles[i], items[i]->title());
+    EXPECT_EQ(expected_item_titles[i], items[i]->label);
 }
 
 // Check that browsers get reflected correctly in the launcher menu.
 TEST_F(ChromeLauncherControllerImplTest, BrowserMenuGeneration) {
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   chrome::NewTab(browser());
 
   InitLauncherController();
 
   // Check that the browser list is empty at this time.
@@ skipping 22 matching lines @@
 
   // Check that the list contains now two entries - make furthermore sure that
   // the active item is the first entry.
   base::string16 two_menu_items[] = {title1, title2};
   CheckAppMenu(launcher_controller_.get(), item_browser, 2, two_menu_items);
 
   // Apparently we have to close all tabs we have.
   chrome::CloseTab(browser2.get());
 }
 
-// Check the multi profile case where only user related browsers should show
-// up.
+// Check the multi profile case where only user related browsers should show up.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,
        BrowserMenuGenerationTwoUsers) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
 
   ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
   item_browser.id =
       launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
 
@@ skipping 439 matching lines @@
   item_gmail.id = gmail_id;
   base::string16 two_menu_items[] = {title1, title2};
   CheckAppMenu(launcher_controller_.get(), item_gmail, 2, two_menu_items);
 
   LauncherItemController* item_controller =
       launcher_controller_->GetLauncherItemController(gmail_id);
   ASSERT_TRUE(item_controller);
   int tabs = browser()->tab_strip_model()->count();
   // Activate the proper tab through the menu item.
   {
-    ash::ShelfAppMenuItemList items =
+    std::vector<ash::mojom::MenuItemPtr> items =
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail);
-    item_controller->ExecuteCommand(items[1]->command_id(), ui::EF_NONE);
+    item_controller->ExecuteCommand(items[1]->command_id, ui::EF_NONE);
     EXPECT_EQ(tabs, browser()->tab_strip_model()->count());
   }
 
   // Delete one tab through the menu item.
   {
-    ash::ShelfAppMenuItemList items =
+    std::vector<ash::mojom::MenuItemPtr> items =
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail);
-    item_controller->ExecuteCommand(items[1]->command_id(), ui::EF_SHIFT_DOWN);
+    item_controller->ExecuteCommand(items[1]->command_id, ui::EF_SHIFT_DOWN);
     EXPECT_EQ(--tabs, browser()->tab_strip_model()->count());
   }
 }
 
 // Tests that panels create launcher items correctly
 TEST_F(ChromeLauncherControllerImplTest, AppPanels) {
   InitLauncherController();
   model_observer_->clear_counts();
   const std::string app_id = extension1_->id();
 
@@ skipping 928 matching lines @@
   EXPECT_EQ(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS,
             shelf_controller->auto_hide());
   EXPECT_EQ(2u, shelf_controller->auto_hide_change_count());
 
   PrefService* prefs = profile()->GetTestingPrefService();
   EXPECT_EQ("Left", prefs->GetString(prefs::kShelfAlignmentLocal));
   EXPECT_EQ("Left", prefs->GetString(prefs::kShelfAlignment));
   EXPECT_EQ("Always", prefs->GetString(prefs::kShelfAutoHideBehaviorLocal));
   EXPECT_EQ("Always", prefs->GetString(prefs::kShelfAutoHideBehavior));
 }