mash: Move LauncherItemController to ash, rename ShelfItemDelegate.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl.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 <vector>
 
 #include "ash/common/multi_profile_uma.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/public/cpp/app_launch_id.h"
+#include "ash/public/cpp/shelf_item_delegate.h"
 #include "ash/resources/grit/ash_resources.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 17 matching lines @@
 #include "chrome/browser/ui/ash/launcher/app_window_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/app_window_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_deferred_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_window_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/browser_shortcut_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/browser_status_monitor.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller_util.h"
 #include "chrome/browser/ui/ash/launcher/launcher_arc_app_updater.h"
 #include "chrome/browser/ui/ash/launcher/launcher_controller_helper.h"
 #include "chrome/browser/ui/ash/launcher/launcher_extension_app_updater.h"
-#include "chrome/browser/ui/ash/launcher/launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/multi_profile_app_window_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/multi_profile_browser_status_monitor.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ skipping 30 matching lines @@
 namespace {
 
 int64_t GetDisplayIDForShelf(ash::WmShelf* shelf) {
   display::Display display =
       shelf->GetWindow()->GetRootWindow()->GetDisplayNearestWindow();
   DCHECK(display.is_valid());
   return display.id();
 }
 
 // A callback that does nothing after shelf item selection handling.
-void NoopCallback(ash::ShelfAction, base::Optional<MenuItemList>) {}
+void NoopCallback(ash::ShelfAction, base::Optional<ash::MenuItemList>) {}
 
 // Calls ItemSelected with |source|, default arguments, and no callback.
-void SelectItemWithSource(ash::mojom::ShelfItemDelegate* delegate,
+void SelectItemWithSource(ash::ShelfItemDelegate* delegate,
                           ash::ShelfLaunchSource source) {
   delegate->ItemSelected(nullptr, display::kInvalidDisplayId, source,
                          base::Bind(&NoopCallback));
 }
 
 // Returns true if the given |item| has a pinned shelf item type.
 bool ItemTypeIsPinned(const ash::ShelfItem& item) {
   return item.type == ash::TYPE_PINNED_APP ||
          item.type == ash::TYPE_BROWSER_SHORTCUT;
 }
@@ skipping 164 matching lines @@
   }
 
   // Release all profile dependent resources.
   ReleaseProfile();
 
   // Get rid of the multi user window manager instance.
   chrome::MultiUserWindowManager::DeleteInstance();
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::CreateAppLauncherItem(
-    LauncherItemController* controller,
+    std::unique_ptr<ash::ShelfItemDelegate> item_delegate,
     ash::ShelfItemStatus status) {
-  return InsertAppLauncherItem(controller, status, model_->item_count(),
-                               ash::TYPE_APP);
+  return InsertAppLauncherItem(std::move(item_delegate), status,
+                               model_->item_count(), ash::TYPE_APP);
 }
 
 const ash::ShelfItem* ChromeLauncherControllerImpl::GetItem(
     ash::ShelfID id) const {
   const int index = model_->ItemIndexByID(id);
   if (index >= 0 && index < model_->item_count())
     return &model_->items()[index];
   return nullptr;
 }
 
@@ skipping 10 matching lines @@
 void ChromeLauncherControllerImpl::SetItemStatus(ash::ShelfID id,
                                                  ash::ShelfItemStatus status) {
   const ash::ShelfItem* item = GetItem(id);
   if (item && item->status != status) {
     ash::ShelfItem new_item = *item;
     new_item.status = status;
     model_->Set(model_->ItemIndexByID(id), new_item);
   }
 }
 
-void ChromeLauncherControllerImpl::SetItemController(
+void ChromeLauncherControllerImpl::SetShelfItemDelegate(
     ash::ShelfID id,
-    LauncherItemController* controller) {
-  CHECK(controller);
+    std::unique_ptr<ash::ShelfItemDelegate> item_delegate) {
+  CHECK(item_delegate);
   IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
   CHECK(iter != id_to_item_controller_map_.end());
-  controller->set_shelf_id(id);
-  iter->second = controller;
-  // Existing controller is destroyed and replaced by registering again.
-  SetShelfItemDelegate(id, controller);
+  item_delegate->set_shelf_id(id);
+  iter->second = item_delegate.get();
+  model_->SetShelfItemDelegate(id, std::move(item_delegate));
 }
 
 void ChromeLauncherControllerImpl::CloseLauncherItem(ash::ShelfID id) {
   CHECK(id);
   if (IsPinned(id)) {
-    // Create a new shortcut controller.
-    IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
-    CHECK(iter != id_to_item_controller_map_.end());
-    LauncherItemController* controller = iter->second;
+    // Create a new shortcut delegate.
     SetItemStatus(id, ash::STATUS_CLOSED);
-    const ash::AppLaunchId& app_launch_id = controller->app_launch_id();
-    controller = AppShortcutLauncherItemController::Create(app_launch_id, this);
-    controller->set_shelf_id(id);
-    // Existing controller is destroyed and replaced by registering again.
-    iter->second = controller;
-    SetShelfItemDelegate(id, controller);
+    SetShelfItemDelegate(id, AppShortcutLauncherItemController::Create(
+                                 GetItem(id)->app_launch_id));
   } else {
     LauncherItemClosed(id);
   }
 }
 
 void ChromeLauncherControllerImpl::UnpinShelfItemInternal(ash::ShelfID id) {
   const ash::ShelfItem* item = GetItem(id);
   if (item && item->status != ash::STATUS_CLOSED)
     UnpinRunningAppInternal(model_->ItemIndexByID(id));
   else
     LauncherItemClosed(id);
 }
 
 bool ChromeLauncherControllerImpl::IsPinned(ash::ShelfID id) {
   const ash::ShelfItem* item = GetItem(id);
   return item && ItemTypeIsPinned(*item);
 }
 
 void ChromeLauncherControllerImpl::SetV1AppStatus(const std::string& app_id,
                                                   ash::ShelfItemStatus status) {
   ash::ShelfID id = GetShelfIDForAppID(app_id);
   const ash::ShelfItem* item = GetItem(id);
   if (item) {
     if (!IsPinned(id) && status == ash::STATUS_CLOSED)
       LauncherItemClosed(id);
     else
       SetItemStatus(id, status);
   } else if (status != ash::STATUS_CLOSED && !app_id.empty()) {
-    InsertAppLauncherItem(AppShortcutLauncherItemController::Create(
-                              ash::AppLaunchId(app_id), this),
-                          status, model_->item_count(), ash::TYPE_APP);
+    InsertAppLauncherItem(
+        AppShortcutLauncherItemController::Create(ash::AppLaunchId(app_id)),
+        status, model_->item_count(), ash::TYPE_APP);
   }
 }
 
 void ChromeLauncherControllerImpl::Launch(ash::ShelfID id, int event_flags) {
-  LauncherItemController* controller = GetLauncherItemController(id);
-  if (!controller)
+  ash::ShelfItemDelegate* delegate = GetShelfItemDelegate(id);
+  if (!delegate)
     return;  // In case invoked from menu and item closed while menu up.
 
-  // Launching some items replaces the associated item controller instance,
+  // Launching some items replaces the associated item delegate instance,
   // which destroys the app and launch id strings; making copies avoid crashes.
-  LaunchApp(ash::AppLaunchId(controller->app_id(), controller->launch_id()),
+  LaunchApp(ash::AppLaunchId(delegate->app_id(), delegate->launch_id()),
             ash::LAUNCH_FROM_UNKNOWN, event_flags);
 }
 
 void ChromeLauncherControllerImpl::Close(ash::ShelfID id) {
-  ash::mojom::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(id);
+  ash::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(id);
   if (!delegate)
     return;  // May happen if menu closed.
   delegate->Close();
 }
 
 bool ChromeLauncherControllerImpl::IsOpen(ash::ShelfID id) {
   const ash::ShelfItem* item = GetItem(id);
   return item && item->status != ash::STATUS_CLOSED;
 }
 
 bool ChromeLauncherControllerImpl::IsPlatformApp(ash::ShelfID id) {
   std::string app_id = GetAppIDForShelfID(id);
   const Extension* extension = GetExtensionForAppID(app_id, profile());
   // An extension can be synced / updated at any time and therefore not be
   // available.
   return extension ? extension->is_platform_app() : false;
 }
 
 void ChromeLauncherControllerImpl::ActivateApp(const std::string& app_id,
                                                ash::ShelfLaunchSource source,
                                                int event_flags) {
-  // If there is an existing non-shortcut controller for this app, open it.
+  // If there is an existing non-shortcut delegate for this app, open it.
   ash::ShelfID id = GetShelfIDForAppID(app_id);
   if (id) {
     SelectItemWithSource(model_->GetShelfItemDelegate(id), source);
     return;
   }
 
   // Create a temporary application launcher item and use it to see if there are
   // running instances.
   ash::AppLaunchId app_launch_id(app_id);
-  std::unique_ptr<AppShortcutLauncherItemController> controller(
-      AppShortcutLauncherItemController::Create(app_launch_id, this));
-  if (!controller->GetRunningApplications().empty())
-    SelectItemWithSource(controller.get(), source);
+  std::unique_ptr<AppShortcutLauncherItemController> item_delegate =
+      AppShortcutLauncherItemController::Create(app_launch_id);
+  if (!item_delegate->GetRunningApplications().empty())
+    SelectItemWithSource(item_delegate.get(), source);
   else
     LaunchApp(app_launch_id, source, event_flags);
 }
 
 void ChromeLauncherControllerImpl::SetLauncherItemImage(
     ash::ShelfID shelf_id,
     const gfx::ImageSkia& image) {
   const ash::ShelfItem* item = GetItem(shelf_id);
   if (item) {
     ash::ShelfItem new_item = *item;
@@ skipping 59 matching lines @@
 
   return id;
 }
 
 void ChromeLauncherControllerImpl::SetRefocusURLPatternForTest(
     ash::ShelfID id,
     const GURL& url) {
   const ash::ShelfItem* item = GetItem(id);
   if (item && !IsPlatformApp(id) &&
       (item->type == ash::TYPE_PINNED_APP || item->type == ash::TYPE_APP)) {
-    LauncherItemController* controller = GetLauncherItemController(id);
-    DCHECK(controller);
-    AppShortcutLauncherItemController* app_controller =
-        static_cast<AppShortcutLauncherItemController*>(controller);
-    app_controller->set_refocus_url(url);
+    ash::ShelfItemDelegate* item_delegate = GetShelfItemDelegate(id);
+    AppShortcutLauncherItemController* item_controller =
+        static_cast<AppShortcutLauncherItemController*>(item_delegate);
+    item_controller->set_refocus_url(url);
   } else {
     NOTREACHED() << "Invalid launcher item or type";
   }
 }
 
 ash::ShelfAction ChromeLauncherControllerImpl::ActivateWindowOrMinimizeIfActive(
     ui::BaseWindow* window,
     bool allow_minimize) {
   // In separated desktop mode we might have to teleport a window back to the
   // current user.
@@ skipping 53 matching lines @@
     ash::Shell::GetInstance()->CreateKeyboard();
 }
 
 void ChromeLauncherControllerImpl::AdditionalUserAddedToSession(
     Profile* profile) {
   // Switch the running applications to the new user.
   for (auto& controller : app_window_controllers_)
     controller->AdditionalUserAddedToSession(profile);
 }
 
-MenuItemList ChromeLauncherControllerImpl::GetAppMenuItemsForTesting(
+ash::MenuItemList ChromeLauncherControllerImpl::GetAppMenuItemsForTesting(
     const ash::ShelfItem& item) {
-  LauncherItemController* controller = GetLauncherItemController(item.id);
-  return controller ? controller->GetAppMenuItems(ui::EF_NONE) : MenuItemList();
+  ash::ShelfItemDelegate* item_delegate = GetShelfItemDelegate(item.id);
+  return item_delegate ? item_delegate->GetAppMenuItems(ui::EF_NONE)
+                       : ash::MenuItemList();
 }
 
 std::vector<content::WebContents*>
 ChromeLauncherControllerImpl::GetV1ApplicationsFromAppId(
     const std::string& app_id) {
   const ash::ShelfItem* item = GetItem(GetShelfIDForAppID(app_id));
   // If there is no such item pinned to the launcher, no menu gets created.
   if (!item || item->type != ash::TYPE_PINNED_APP)
     return std::vector<content::WebContents*>();
-  LauncherItemController* controller = GetLauncherItemController(item->id);
-  AppShortcutLauncherItemController* app_controller =
-      static_cast<AppShortcutLauncherItemController*>(controller);
-  return app_controller->GetRunningApplications();
+  ash::ShelfItemDelegate* item_delegate = GetShelfItemDelegate(item->id);
+  AppShortcutLauncherItemController* item_controller =
+      static_cast<AppShortcutLauncherItemController*>(item_delegate);
+  return item_controller->GetRunningApplications();
 }
 
 void ChromeLauncherControllerImpl::ActivateShellApp(const std::string& app_id,
                                                     int window_index) {
   const ash::ShelfItem* item = GetItem(GetShelfIDForAppID(app_id));
   if (item &&
       (item->type == ash::TYPE_APP || item->type == ash::TYPE_PINNED_APP)) {
-    LauncherItemController* controller = GetLauncherItemController(item->id);
-    AppWindowLauncherItemController* app_window_controller =
-        controller->AsAppWindowLauncherItemController();
-    DCHECK(app_window_controller);
-    app_window_controller->ActivateIndexedApp(window_index);
+    ash::ShelfItemDelegate* item_delegate = GetShelfItemDelegate(item->id);
+    AppWindowLauncherItemController* item_controller =
+        item_delegate->AsAppWindowLauncherItemController();
+    item_controller->ActivateIndexedApp(window_index);
   }
 }
 
 bool ChromeLauncherControllerImpl::IsWebContentHandledByApplication(
     content::WebContents* web_contents,
     const std::string& app_id) {
   if ((web_contents_to_app_id_.find(web_contents) !=
        web_contents_to_app_id_.end()) &&
       (web_contents_to_app_id_[web_contents] == app_id))
     return true;
@@ skipping 52 matching lines @@
   for (const auto& pair : id_to_item_controller_map_) {
     const ash::ShelfItem* item = GetItem(pair.first);
     if (item && item->type == ash::TYPE_BROWSER_SHORTCUT)
       return static_cast<BrowserShortcutLauncherItemController*>(pair.second);
   }
   NOTREACHED()
       << "There should be always be a BrowserShortcutLauncherItemController.";
   return nullptr;
 }
 
-LauncherItemController* ChromeLauncherControllerImpl::GetLauncherItemController(
+ash::ShelfItemDelegate* ChromeLauncherControllerImpl::GetShelfItemDelegate(
     const ash::ShelfID id) {
   IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
   return iter == id_to_item_controller_map_.end() ? nullptr : iter->second;
 }
 
 bool ChromeLauncherControllerImpl::ShelfBoundsChangesProbablyWithUser(
     ash::WmShelf* shelf,
     const AccountId& account_id) const {
   Profile* other_profile = multi_user_util::GetProfileFromAccountId(account_id);
   if (!other_profile || other_profile == profile())
@@ skipping 23 matching lines @@
     user_switch_observer_->OnUserProfileReadyToSwitch(profile);
 }
 
 ArcAppDeferredLauncherController*
 ChromeLauncherControllerImpl::GetArcDeferredLauncher() {
   return arc_deferred_launcher_.get();
 }
 
 const std::string& ChromeLauncherControllerImpl::GetLaunchIDForShelfID(
     ash::ShelfID id) {
-  LauncherItemController* controller = GetLauncherItemController(id);
-  return controller ? controller->launch_id() : base::EmptyString();
+  ash::ShelfItemDelegate* delegate = GetShelfItemDelegate(id);
+  return delegate ? delegate->launch_id() : base::EmptyString();
 }
 
 void ChromeLauncherControllerImpl::AttachProfile(Profile* profile_to_attach) {
   // The base class implementation updates the helper and app icon loaders.
   ChromeLauncherController::AttachProfile(profile_to_attach);
 
   pref_change_registrar_.Init(profile()->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kPolicyPinnedLauncherApps,
       base::Bind(&ChromeLauncherControllerImpl::UpdateAppLaunchersFromPref,
@@ skipping 183 matching lines @@
   if (ash::Shell::HasInstance())
     SetVirtualKeyboardBehaviorFromPrefs();
 
   prefs_observer_ =
       ash::launcher::ChromeLauncherPrefsObserver::CreateIfNecessary(profile());
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::CreateAppShortcutLauncherItem(
     const ash::AppLaunchId& app_launch_id,
     int index) {
-  AppShortcutLauncherItemController* controller =
-      AppShortcutLauncherItemController::Create(app_launch_id, this);
-  return InsertAppLauncherItem(controller, ash::STATUS_CLOSED, index,
-                               ash::TYPE_PINNED_APP);
+  return InsertAppLauncherItem(
+      AppShortcutLauncherItemController::Create(app_launch_id),
+      ash::STATUS_CLOSED, index, ash::TYPE_PINNED_APP);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeLauncherControllerImpl private:
 
 void ChromeLauncherControllerImpl::RememberUnpinnedRunningApplicationOrder() {
   RunningAppListIds list;
   for (int i = 0; i < model_->item_count(); i++) {
     if (model_->items()[i].type == ash::TYPE_APP)
       list.push_back(GetAppIDForShelfID(model_->items()[i].id));
@@ skipping 242 matching lines @@
                    : ash::STATUS_RUNNING;
       } else {
         status = ash::STATUS_RUNNING;
       }
     }
   }
   return status;
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::InsertAppLauncherItem(
-    LauncherItemController* controller,
+    std::unique_ptr<ash::ShelfItemDelegate> item_delegate,
     ash::ShelfItemStatus status,
     int index,
     ash::ShelfItemType shelf_item_type) {
   ash::ShelfID id = model_->next_id();
   CHECK(!GetItem(id));
-  CHECK(controller);
+  CHECK(item_delegate);
   // Ash's ShelfWindowWatcher handles app panel windows separately.
   DCHECK_NE(ash::TYPE_APP_PANEL, shelf_item_type);
-  id_to_item_controller_map_[id] = controller;
-  controller->set_shelf_id(id);
+  id_to_item_controller_map_[id] = item_delegate.get();
+  item_delegate->set_shelf_id(id);
 
   ash::ShelfItem item;
   item.type = shelf_item_type;
-  item.app_launch_id = controller->app_launch_id();
+  item.app_launch_id = item_delegate->app_launch_id();
   item.image = extensions::util::GetDefaultAppIcon();
 
-  const std::string& app_id = controller->app_id();
+  const std::string& app_id = item_delegate->app_id();
   item.title = LauncherControllerHelper::GetAppTitle(profile(), app_id);
 
   ash::ShelfItemStatus new_state = GetAppState(app_id);
   if (new_state != ash::STATUS_CLOSED)
     status = new_state;
 
   item.status = status;
   model_->AddAt(index, item);
 
   AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(app_id);
   if (app_icon_loader) {
     app_icon_loader->FetchImage(app_id);
     app_icon_loader->UpdateImage(app_id);
   }
 
-  SetShelfItemDelegate(id, controller);
+  model_->SetShelfItemDelegate(id, std::move(item_delegate));
   return id;
 }
 
 void ChromeLauncherControllerImpl::CreateBrowserShortcutLauncherItem() {
   // Do not sync the pin position of the browser shortcut item when it is added;
   // its initial position before prefs have loaded is unimportant and the sync
   // service may not yet be initialized.
   ScopedPinSyncDisabler scoped_pin_sync_disabler = GetScopedPinSyncDisabler();
 
   ash::ShelfItem browser_shortcut;
   browser_shortcut.type = ash::TYPE_BROWSER_SHORTCUT;
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   browser_shortcut.image = *rb.GetImageSkiaNamed(IDR_PRODUCT_LOGO_32);
   browser_shortcut.title = l10n_util::GetStringUTF16(IDS_PRODUCT_NAME);
   browser_shortcut.app_launch_id =
       ash::AppLaunchId(extension_misc::kChromeAppId);
   ash::ShelfID id = model_->next_id();
   model_->AddAt(0, browser_shortcut);
-  BrowserShortcutLauncherItemController* controller =
-      new BrowserShortcutLauncherItemController(this, model_);
-  controller->set_shelf_id(id);
-  id_to_item_controller_map_[id] = controller;
-  // ShelfModel owns BrowserShortcutLauncherItemController.
-  SetShelfItemDelegate(id, controller);
-  controller->UpdateBrowserItemState();
+  std::unique_ptr<BrowserShortcutLauncherItemController> item_delegate =
+      base::MakeUnique<BrowserShortcutLauncherItemController>(model_);
+  BrowserShortcutLauncherItemController* item_controller = item_delegate.get();
+  item_controller->set_shelf_id(id);
+  id_to_item_controller_map_[id] = item_controller;
+  model_->SetShelfItemDelegate(id, std::move(item_delegate));
+  item_controller->UpdateBrowserItemState();
 }
 
 bool ChromeLauncherControllerImpl::IsIncognito(
     const content::WebContents* web_contents) const {
   const Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   return profile->IsOffTheRecord() && !profile->IsGuestSession() &&
          !profile->IsSystemProfile();
 }
 
@@ skipping 28 matching lines @@
     }
   }
   while (!browser_to_close.empty()) {
     TabStripModel* tab_strip = browser_to_close.back()->tab_strip_model();
     if (!tab_strip->empty())
       tab_strip->CloseWebContentsAt(0, TabStripModel::CLOSE_NONE);
     browser_to_close.pop_back();
   }
 }
 
-void ChromeLauncherControllerImpl::SetShelfItemDelegate(
-    ash::ShelfID id,
-    ash::mojom::ShelfItemDelegate* item_delegate) {
-  DCHECK_NE(id, ash::kInvalidShelfID);
-  DCHECK(item_delegate);
-  model_->SetShelfItemDelegate(
-      id, base::WrapUnique<ash::mojom::ShelfItemDelegate>(item_delegate));
-}
-
 void ChromeLauncherControllerImpl::ReleaseProfile() {
   if (app_sync_ui_state_)
     app_sync_ui_state_->RemoveObserver(this);
 
   app_updaters_.clear();
 
   prefs_observer_.reset();
 
   pref_change_registrar_.RemoveAll();
 
@@ skipping 61 matching lines @@
             old_item.app_launch_id.app_id());
 
     ash::AppLaunchId app_launch_id(shelf_app_id,
                                    old_item.app_launch_id.launch_id());
     ash::launcher::RemovePinPosition(profile(), app_launch_id);
   }
 }
 
 void ChromeLauncherControllerImpl::OnSetShelfItemDelegate(
     ash::ShelfID id,
-    ash::mojom::ShelfItemDelegate* item_delegate) {
+    ash::ShelfItemDelegate* item_delegate) {
   // TODO(skuhne): This fixes crbug.com/429870, but it does not answer why we
   // get into this state in the first place.
   IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
   if (iter == id_to_item_controller_map_.end() || item_delegate == iter->second)
     return;
   LOG(ERROR) << "Unexpected change of shelf item delegate, id: " << id;
   id_to_item_controller_map_.erase(iter);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 32 matching lines @@
 // AppIconLoaderDelegate:
 
 void ChromeLauncherControllerImpl::OnAppImageUpdated(
     const std::string& id,
     const gfx::ImageSkia& image) {
   // TODO: need to get this working for shortcuts.
   for (int index = 0; index < model_->item_count(); ++index) {
     ash::ShelfItem item = model_->items()[index];
     if (GetAppIDForShelfID(item.id) != id)
       continue;
-    LauncherItemController* controller = GetLauncherItemController(item.id);
-    if (!controller || controller->image_set_by_controller())
+    ash::ShelfItemDelegate* delegate = GetShelfItemDelegate(item.id);
+    if (!delegate || delegate->image_set_by_controller())
       continue;
     item.image = image;
     if (arc_deferred_launcher_)
       arc_deferred_launcher_->MaybeApplySpinningEffect(id, &item.image);
     model_->Set(index, item);
     // It's possible we're waiting on more than one item, so don't break.
   }
 }