Use mojo Shelf interfaces for both mash and classic ash.

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

 // Copyright 2016 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_mus.h"
 
-#include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/browser/ui/ash/launcher/chrome_mash_shelf_controller.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
+#include "chrome/browser/ui/ash/launcher/launcher_controller_helper.h"
+#include "extensions/grit/extensions_browser_resources.h"
+#include "mojo/common/common_type_converters.h"
+#include "ui/base/resource/resource_bundle.h"
 
-// static
-ChromeLauncherController* ChromeLauncherControllerMus::CreateInstance() {
-  DCHECK(!ChromeLauncherController::instance());
-  ChromeLauncherControllerMus* instance = new ChromeLauncherControllerMus();
-  ChromeLauncherController::set_instance(instance);
-  return instance;
-}
+class ChromeShelfItemDelegate : public ash::mojom::ShelfItemDelegate {
+ public:
+  explicit ChromeShelfItemDelegate(const std::string& app_id,
+                                   ChromeLauncherController* controller)
+      : app_id_(app_id),
+        item_delegate_binding_(this),
+        controller_(controller) {}
+  ~ChromeShelfItemDelegate() override {}
 
-ChromeLauncherControllerMus::ChromeLauncherControllerMus()
-    : shelf_controller_(new ChromeMashShelfController) {}
+  ash::mojom::ShelfItemDelegateAssociatedPtrInfo CreateInterfacePtrInfoAndBind(
+      mojo::AssociatedGroup* associated_group) {
+    DCHECK(!item_delegate_binding_.is_bound());
+    ash::mojom::ShelfItemDelegateAssociatedPtrInfo ptr_info;
+    item_delegate_binding_.Bind(&ptr_info, associated_group);
+    return ptr_info;
+  }
+
+ private:
+  // ash::mojom::ShelfItemDelegate:
+  void LaunchItem() override {
+    controller_->LaunchApp(app_id_, ash::LAUNCH_FROM_UNKNOWN, ui::EF_NONE);
+  }
+  void ExecuteCommand(uint32_t command_id, int32_t event_flags) override {
+    NOTIMPLEMENTED();
+  }
+  void ItemPinned() override { NOTIMPLEMENTED(); }
+  void ItemUnpinned() override { NOTIMPLEMENTED(); }
+  void ItemReordered(uint32_t order) override { NOTIMPLEMENTED(); }
+
+  std::string app_id_;
+  mojo::AssociatedBinding<ash::mojom::ShelfItemDelegate> item_delegate_binding_;
+
+  // Not owned.
+  ChromeLauncherController* controller_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeShelfItemDelegate);
+};
+
+ChromeLauncherControllerMus::ChromeLauncherControllerMus() {}
 
 ChromeLauncherControllerMus::~ChromeLauncherControllerMus() {}
 
-void ChromeLauncherControllerMus::Init() {}
+void ChromeLauncherControllerMus::Init() {
+  NOTIMPLEMENTED();
+}
 
 ash::ShelfID ChromeLauncherControllerMus::CreateAppLauncherItem(
     LauncherItemController* controller,
     const std::string& app_id,
     ash::ShelfItemStatus status) {
   NOTIMPLEMENTED();
   return ash::TYPE_UNDEFINED;
 }
 
 void ChromeLauncherControllerMus::SetItemStatus(ash::ShelfID id,
@@ skipping 52 matching lines @@
 bool ChromeLauncherControllerMus::IsOpen(ash::ShelfID id) {
   NOTIMPLEMENTED();
   return false;
 }
 
 bool ChromeLauncherControllerMus::IsPlatformApp(ash::ShelfID id) {
   NOTIMPLEMENTED();
   return false;
 }
 
-void ChromeLauncherControllerMus::LaunchApp(const std::string& app_id,
-                                            ash::LaunchSource source,
-                                            int event_flags) {
-  shelf_controller_->LaunchItem(app_id);
-}
-
 void ChromeLauncherControllerMus::ActivateApp(const std::string& app_id,
                                               ash::LaunchSource source,
                                               int event_flags) {
   NOTIMPLEMENTED();
 }
 
 extensions::LaunchType ChromeLauncherControllerMus::GetLaunchType(
     ash::ShelfID id) {
   NOTIMPLEMENTED();
   return extensions::LAUNCH_TYPE_INVALID;
@@ skipping 10 matching lines @@
   NOTIMPLEMENTED();
   return false;
 }
 
 void ChromeLauncherControllerMus::SetLaunchType(
     ash::ShelfID id,
     extensions::LaunchType launch_type) {
   NOTIMPLEMENTED();
 }
 
-Profile* ChromeLauncherControllerMus::GetProfile() {
-  return ProfileManager::GetActiveUserProfile();
-}
-
 void ChromeLauncherControllerMus::UpdateAppState(content::WebContents* contents,
                                                  AppState app_state) {
   NOTIMPLEMENTED();
 }
 
 ash::ShelfID ChromeLauncherControllerMus::GetShelfIDForWebContents(
     content::WebContents* contents) {
   NOTIMPLEMENTED();
   return ash::TYPE_UNDEFINED;
 }
@@ skipping 86 matching lines @@
 
 void ChromeLauncherControllerMus::OnUserProfileReadyToSwitch(Profile* profile) {
   NOTIMPLEMENTED();
 }
 
 ArcAppDeferredLauncherController*
 ChromeLauncherControllerMus::GetArcDeferredLauncher() {
   NOTIMPLEMENTED();
   return nullptr;
 }
+
+void ChromeLauncherControllerMus::OnAppImageUpdated(
+    const std::string& app_id,
+    const gfx::ImageSkia& image) {
+  if (ConnectToShelfController())
+    shelf_controller()->SetItemImage(app_id, *image.bitmap());
+}
+
+void ChromeLauncherControllerMus::PinAppsFromPrefs() {
+  if (!ConnectToShelfController())
+    return;
+
+  std::vector<std::string> pinned_apps = ash::launcher::GetPinnedAppsFromPrefs(
+      profile()->GetPrefs(), launcher_controller_helper());
+
+  for (const auto& app : pinned_apps) {
+    if (app == ash::launcher::kPinnedAppsPlaceholder)
+      continue;
+
+    ash::mojom::ShelfItemPtr item(ash::mojom::ShelfItem::New());
+    item->app_id = app;
+    item->app_title = mojo::String::From(
+        launcher_controller_helper()->GetAppTitle(profile(), app));
+    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+    const gfx::Image& image = rb.GetImageNamed(IDR_APP_DEFAULT_ICON);
+    item->image = *image.ToSkBitmap();
+    std::unique_ptr<ChromeShelfItemDelegate> delegate(
+        new ChromeShelfItemDelegate(app, this));
+    shelf_controller()->PinItem(std::move(item),
+                                delegate->CreateInterfacePtrInfoAndBind(
+                                    shelf_controller().associated_group()));
+    app_id_to_item_delegate_.insert(std::make_pair(app, std::move(delegate)));
+
+    AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(app);
+    if (app_icon_loader) {
+      app_icon_loader->FetchImage(app);
+      app_icon_loader->UpdateImage(app);
+    }
+  }
+}