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

chrome/browser/ui/ash/launcher/app_shortcut_launcher_item_controller.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 "chrome/browser/ui/ash/launcher/app_shortcut_launcher_item_controller.h"
 
 #include <stddef.h>
 
-#include "ash/public/cpp/shelf_application_menu_item.h"
 #include "ash/wm/window_util.h"
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/ash/launcher/arc_playstore_shortcut_launcher_item_controller.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/launcher/launcher_controller_helper.h"
@@ skipping 66 matching lines @@
       GetExtensionForAppID(app_id, controller->profile());
   // Some unit tests have no real extension.
   if (extension) {
     set_refocus_url(GURL(
         extensions::AppLaunchInfo::GetLaunchWebURL(extension).spec() + "*"));
   }
 }
 
 AppShortcutLauncherItemController::~AppShortcutLauncherItemController() {}
 
-ash::ShelfAction AppShortcutLauncherItemController::ItemSelected(
-    ui::EventType event_type,
-    int event_flags,
+void AppShortcutLauncherItemController::ItemSelected(
+    std::unique_ptr<ui::Event> event,
     int64_t display_id,
-    ash::ShelfLaunchSource source) {
+    ash::ShelfLaunchSource source,
+    const ItemSelectedCallback& callback) {
   // 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 && AdvanceToNextApp())
-    return ash::SHELF_ACTION_WINDOW_ACTIVATED;
+  if (event && event->type() == ui::ET_KEY_RELEASED && AdvanceToNextApp()) {
+    callback.Run(ash::SHELF_ACTION_WINDOW_ACTIVATED,
+                 std::vector<ash::mojom::MenuItemPtr>());

[James Cook, 2017/03/10 16:56:01]

optional: Out of curiosity, WDTY of using an optional array parameter? All these
inlined empty vectors are awkward to read. I think the calls would all end up
like callback.Run(ACTION_TYPE, base::nullopt_t).

Aside: It's annoying C++ won't let you do "using ash::mojom::MenuItemPtr" on a
typedef. :-(

[msw, 2017/03/10 20:44:45]

Done; I also added a using statement in launcher_item_controller.h

+    return;
+  }
 
   content::WebContents* content = GetLRUApplication();
   if (!content) {
     // Ideally we come here only once. After that ShellLauncherItemController
     // will take over when the shell window gets opened. However there are apps
     // which take a lot of time for pre-processing (like the files app) before
     // they open a window. Since there is currently no other way to detect if an
     // app was started we suppress any further clicks within a special time out.
-    if (IsV2App() && !AllowNextLaunchAttempt())
-      return ash::SHELF_ACTION_NONE;
+    if (IsV2App() && !AllowNextLaunchAttempt()) {
+      callback.Run(ash::SHELF_ACTION_NONE,
+                   GetAppMenuItems(event ? event->flags() : ui::EF_NONE));
+      return;
+    }
 
     // Launching some items replaces this item controller instance, which
     // destroys the app and launch id strings; making copies avoid crashes.
     launcher_controller()->LaunchApp(ash::AppLauncherId(app_id(), launch_id()),
                                      source, ui::EF_NONE);
-    return ash::SHELF_ACTION_NEW_WINDOW_CREATED;
+    callback.Run(ash::SHELF_ACTION_NEW_WINDOW_CREATED,
+                 std::vector<ash::mojom::MenuItemPtr>());
+    return;
   }
-  return ActivateContent(content);
+
+  const ash::ShelfAction action = ActivateContent(content);
+  callback.Run(action, GetAppMenuItems(event ? event->flags() : ui::EF_NONE));
 }
 
-ash::ShelfAppMenuItemList AppShortcutLauncherItemController::GetAppMenuItems(
-    int event_flags) {
-  ash::ShelfAppMenuItemList items;
+std::vector<ash::mojom::MenuItemPtr>
+AppShortcutLauncherItemController::GetAppMenuItems(int event_flags) {
+  std::vector<ash::mojom::MenuItemPtr> items;
   app_menu_items_ = GetRunningApplications();
   for (size_t i = 0; i < app_menu_items_.size(); i++) {
-    content::WebContents* web_contents = app_menu_items_[i];
-    gfx::Image icon = launcher_controller()->GetAppListIcon(web_contents);
-    base::string16 title = launcher_controller()->GetAppListTitle(web_contents);
-    items.push_back(base::MakeUnique<ash::ShelfApplicationMenuItem>(
-        base::checked_cast<uint32_t>(i), title, &icon));
+    content::WebContents* tab = app_menu_items_[i];
+    ash::mojom::MenuItemPtr item(ash::mojom::MenuItem::New());
+    item->command_id = base::checked_cast<uint32_t>(i);
+    item->label = launcher_controller()->GetAppListTitle(tab);
+    item->image = *launcher_controller()->GetAppListIcon(tab).ToSkBitmap();
+    items.push_back(std::move(item));
   }
   return items;
 }
 
 void AppShortcutLauncherItemController::ExecuteCommand(uint32_t command_id,
-                                                       int event_flags) {
+                                                       int32_t event_flags) {
   if (static_cast<size_t>(command_id) >= app_menu_items_.size()) {
     app_menu_items_.clear();
     return;
   }
 
   // If the web contents was destroyed while the menu was open, then the invalid
   // pointer cached in |app_menu_items_| should yield a null browser or kNoTab.
   content::WebContents* web_contents = app_menu_items_[command_id];
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
   TabStripModel* tab_strip = browser ? browser->tab_strip_model() : nullptr;
@@ skipping 200 matching lines @@
 
 bool AppShortcutLauncherItemController::AllowNextLaunchAttempt() {
   if (last_launch_attempt_.is_null() ||
       last_launch_attempt_ + base::TimeDelta::FromMilliseconds(
           kClickSuppressionInMS) < base::Time::Now()) {
     last_launch_attempt_ = base::Time::Now();
     return true;
   }
   return false;
 }