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

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

 // Copyright (c) 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/browser_shortcut_launcher_item_controller.h"
 
 #include <limits>
 #include <vector>
 
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
-#include "ash/public/cpp/shelf_application_menu_item.h"
 #include "ash/resources/grit/ash_resources.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller_util.h"
 #include "chrome/browser/ui/ash/launcher/launcher_context_menu.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
@@ skipping 151 matching lines @@
   // content which might change and as such change the application type.
   if (!browser || !IsBrowserFromActiveUser(browser) ||
       IsSettingsBrowser(browser))
     return;
 
   browser->window()->GetNativeWindow()->SetProperty(
       ash::kShelfIDKey,
       launcher_controller()->GetShelfIDForWebContents(web_contents));
 }
 
-ash::ShelfAction BrowserShortcutLauncherItemController::ItemSelected(
-    ui::EventType event_type,
-    int event_flags,
+void BrowserShortcutLauncherItemController::ItemSelected(
+    std::unique_ptr<ui::Event> event,
     int64_t display_id,
-    ash::ShelfLaunchSource source) {
-  if (event_flags & ui::EF_CONTROL_DOWN) {
+    ash::ShelfLaunchSource source,
+    const ItemSelectedCallback& callback) {
+  if (event && (event->flags() & ui::EF_CONTROL_DOWN)) {
     chrome::NewEmptyWindow(launcher_controller()->profile());
-    return ash::SHELF_ACTION_NEW_WINDOW_CREATED;
+    callback.Run(ash::SHELF_ACTION_NEW_WINDOW_CREATED,
+                 std::vector<ash::mojom::MenuItemPtr>());
+    return;
   }
 
+  std::vector<ash::mojom::MenuItemPtr> items =
+      GetAppMenuItems(event ? event->flags() : ui::EF_NONE);
+
   // In case of a keyboard event, we were called by a hotkey. In that case we
   // activate the next item in line if an item of our list is already active.
-  if (event_type == ui::ET_KEY_RELEASED)
-    return ActivateOrAdvanceToNextBrowser();
+  if (event && event->type() == ui::ET_KEY_RELEASED) {
+    callback.Run(ActivateOrAdvanceToNextBrowser(), std::move(items));
+    return;
+  }
 
   Browser* last_browser =
       chrome::FindTabbedBrowser(launcher_controller()->profile(), true);
 
   if (!last_browser) {
     chrome::NewEmptyWindow(launcher_controller()->profile());
-    return ash::SHELF_ACTION_NEW_WINDOW_CREATED;
+    callback.Run(ash::SHELF_ACTION_NEW_WINDOW_CREATED,
+                 std::vector<ash::mojom::MenuItemPtr>());
+    return;
   }
 
-  return launcher_controller()->ActivateWindowOrMinimizeIfActive(
-      last_browser->window(), GetAppMenuItems(0).size() == 1);
+  ash::ShelfAction action =
+      launcher_controller()->ActivateWindowOrMinimizeIfActive(
+          last_browser->window(), items.size() == 1);
+  callback.Run(action, std::move(items));
 }
 
-ash::ShelfAppMenuItemList
+std::vector<ash::mojom::MenuItemPtr>
 BrowserShortcutLauncherItemController::GetAppMenuItems(int event_flags) {
   browser_menu_items_.clear();
   registrar_.RemoveAll();
 
-  ash::ShelfAppMenuItemList items;
+  std::vector<ash::mojom::MenuItemPtr> items;
   bool found_tabbed_browser = false;
   for (auto* browser : GetListOfActiveBrowsers()) {
     if (browser_menu_items_.size() >= kMaxItems)
       break;
     TabStripModel* tab_strip = browser->tab_strip_model();
     const int tab_index = tab_strip->active_index();
     if (tab_index < 0 || tab_index >= kMaxItems)
       continue;
     if (browser->is_type_tabbed())
       found_tabbed_browser = true;
     if (!(event_flags & ui::EF_SHIFT_DOWN)) {
       content::WebContents* tab = tab_strip->GetWebContentsAt(tab_index);
-      gfx::Image icon = GetBrowserListIcon(tab);
-      base::string16 title = GetBrowserListTitle(tab);
-      items.push_back(base::MakeUnique<ash::ShelfApplicationMenuItem>(
-          GetCommandId(browser_menu_items_.size(), kNoTab), title, &icon));
+      ash::mojom::MenuItemPtr item(ash::mojom::MenuItem::New());
+      item->command_id = GetCommandId(browser_menu_items_.size(), kNoTab);
+      item->label = GetBrowserListTitle(tab);
+      item->image = *GetBrowserListIcon(tab).ToSkBitmap();
+      items.push_back(std::move(item));
     } else {
       for (uint16_t i = 0; i < tab_strip->count() && i < kMaxItems; ++i) {
         content::WebContents* tab = tab_strip->GetWebContentsAt(i);
-        gfx::Image icon = launcher_controller()->GetAppListIcon(tab);
-        base::string16 title = launcher_controller()->GetAppListTitle(tab);
-        items.push_back(base::MakeUnique<ash::ShelfApplicationMenuItem>(
-            GetCommandId(browser_menu_items_.size(), i), title, &icon));
+        ash::mojom::MenuItemPtr item(ash::mojom::MenuItem::New());
+        item->command_id = GetCommandId(browser_menu_items_.size(), i);
+        item->label = launcher_controller()->GetAppListTitle(tab);
+        item->image = *launcher_controller()->GetAppListIcon(tab).ToSkBitmap();
+        items.push_back(std::move(item));
       }
     }
     browser_menu_items_.push_back(browser);
     registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSING,
                    content::Source<Browser>(browser));
   }
   // If only windowed applications are open, we return an empty list to
   // enforce the creation of a new browser.
   if (!found_tabbed_browser) {
     items.clear();
     browser_menu_items_.clear();
     registrar_.RemoveAll();
   }
   return items;
 }
 
-void BrowserShortcutLauncherItemController::ExecuteCommand(uint32_t command_id,
-                                                           int event_flags) {
+void BrowserShortcutLauncherItemController::ExecuteCommand(
+    uint32_t command_id,
+    int32_t event_flags) {
   const uint16_t browser_index = GetBrowserIndex(command_id);
   // Check that the index is valid and the browser has not been closed.
   if (browser_index < browser_menu_items_.size() &&
       browser_menu_items_[browser_index]) {
     Browser* browser = browser_menu_items_[browser_index];
     TabStripModel* tab_strip = browser->tab_strip_model();
     const uint16_t tab_index = GetWebContentsIndex(command_id);
     if (event_flags & (ui::EF_SHIFT_DOWN | ui::EF_MIDDLE_MOUSE_BUTTON)) {
       if (tab_index == kNoTab) {
         tab_strip->CloseAllTabs();
@@ skipping 122 matching lines @@
   Browser* browser = content::Source<Browser>(source).ptr();
   DCHECK(browser);
   BrowserList::BrowserVector::iterator item = std::find(
       browser_menu_items_.begin(), browser_menu_items_.end(), browser);
   DCHECK(item != browser_menu_items_.end());
   // Clear the entry for the closed browser and leave other indices intact.
   *item = nullptr;
   registrar_.Remove(this, chrome::NOTIFICATION_BROWSER_CLOSING,
                     content::Source<Browser>(browser));
 }