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,
+    ash::ShelfItemDelegate* controller,
     ash::ShelfItemStatus status) {
   return InsertAppLauncherItem(controller, 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];
@@ skipping 15 matching lines @@
   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(
     ash::ShelfID id,
-    LauncherItemController* controller) {
+    ash::ShelfItemDelegate* controller) {

[James Cook, 2017/04/04 15:34:45]

ditto on all these locals named "controller"

[msw, 2017/04/04 18:53:09]

Done.

   CHECK(controller);
   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);
 }
 
 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;
+    ash::ShelfItemDelegate* controller = iter->second;
     SetItemStatus(id, ash::STATUS_CLOSED);
     const ash::AppLaunchId& app_launch_id = controller->app_launch_id();
-    controller = AppShortcutLauncherItemController::Create(app_launch_id, this);
+    controller = AppShortcutLauncherItemController::Create(app_launch_id);
     controller->set_shelf_id(id);
     // Existing controller is destroyed and replaced by registering again.

[James Cook, 2017/04/04 23:57:27]

Nice to see junk like this going away.

     iter->second = controller;
     SetShelfItemDelegate(id, controller);
   } else {
     LauncherItemClosed(id);
   }
 }
 
 void ChromeLauncherControllerImpl::UnpinShelfItemInternal(ash::ShelfID id) {
   const ash::ShelfItem* item = GetItem(id);
   if (item && item->status != ash::STATUS_CLOSED)
@@ skipping 10 matching lines @@
 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);
+  ash::ShelfItemDelegate* controller = GetLauncherItemController(id);
   if (!controller)
     return;  // In case invoked from menu and item closed while menu up.
 
   // Launching some items replaces the associated item controller instance,
   // which destroys the app and launch id strings; making copies avoid crashes.
   LaunchApp(ash::AppLaunchId(controller->app_id(), controller->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;
 }
 
@@ skipping 12 matching lines @@
   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));
+      AppShortcutLauncherItemController::Create(app_launch_id));
   if (!controller->GetRunningApplications().empty())
     SelectItemWithSource(controller.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);
@@ skipping 61 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);
+    ash::ShelfItemDelegate* controller = GetLauncherItemController(id);
     DCHECK(controller);
     AppShortcutLauncherItemController* app_controller =
         static_cast<AppShortcutLauncherItemController*>(controller);
     app_controller->set_refocus_url(url);
   } else {
     NOTREACHED() << "Invalid launcher item or type";
   }
 }
 
 ash::ShelfAction ChromeLauncherControllerImpl::ActivateWindowOrMinimizeIfActive(
@@ skipping 57 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* controller = GetLauncherItemController(item.id);
+  return controller ? controller->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);
+  ash::ShelfItemDelegate* controller = GetLauncherItemController(item->id);
   AppShortcutLauncherItemController* app_controller =
       static_cast<AppShortcutLauncherItemController*>(controller);
   return app_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);
+    ash::ShelfItemDelegate* controller = GetLauncherItemController(item->id);
     AppWindowLauncherItemController* app_window_controller =
         controller->AsAppWindowLauncherItemController();
     DCHECK(app_window_controller);
     app_window_controller->ActivateIndexedApp(window_index);
   }
 }
 
 bool ChromeLauncherControllerImpl::IsWebContentHandledByApplication(
     content::WebContents* web_contents,
     const std::string& app_id) {
@@ skipping 56 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::GetLauncherItemController(
     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);
+  ash::ShelfItemDelegate* controller = GetLauncherItemController(id);
   return controller ? controller->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,
@@ skipping 185 matching lines @@
     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);
+      AppShortcutLauncherItemController::Create(app_launch_id);
   return InsertAppLauncherItem(controller, ash::STATUS_CLOSED, index,
                                ash::TYPE_PINNED_APP);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeLauncherControllerImpl private:
 
 void ChromeLauncherControllerImpl::RememberUnpinnedRunningApplicationOrder() {
   RunningAppListIds list;
   for (int i = 0; i < model_->item_count(); i++) {
@@ skipping 244 matching lines @@
                    : ash::STATUS_RUNNING;
       } else {
         status = ash::STATUS_RUNNING;
       }
     }
   }
   return status;
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::InsertAppLauncherItem(
-    LauncherItemController* controller,
+    ash::ShelfItemDelegate* controller,
     ash::ShelfItemStatus status,
     int index,
     ash::ShelfItemType shelf_item_type) {
   ash::ShelfID id = model_->next_id();
   CHECK(!GetItem(id));
   CHECK(controller);
   // 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);
@@ skipping 32 matching lines @@
   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_);
+      new BrowserShortcutLauncherItemController(model_);
   controller->set_shelf_id(id);
   id_to_item_controller_map_[id] = controller;
   // ShelfModel owns BrowserShortcutLauncherItemController.
   SetShelfItemDelegate(id, controller);
   controller->UpdateBrowserItemState();
 }
 
 bool ChromeLauncherControllerImpl::IsIncognito(
     const content::WebContents* web_contents) const {
   const Profile* profile =
@@ skipping 35 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) {
+    ash::ShelfItemDelegate* item_delegate) {
   DCHECK_NE(id, ash::kInvalidShelfID);
   DCHECK(item_delegate);
   model_->SetShelfItemDelegate(
-      id, base::WrapUnique<ash::mojom::ShelfItemDelegate>(item_delegate));
+      id, base::WrapUnique<ash::ShelfItemDelegate>(item_delegate));
 }
 
 void ChromeLauncherControllerImpl::ReleaseProfile() {
   if (app_sync_ui_state_)
     app_sync_ui_state_->RemoveObserver(this);
 
   app_updaters_.clear();
 
   prefs_observer_.reset();
 
@@ skipping 63 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);
+    ash::ShelfItemDelegate* controller = GetLauncherItemController(item.id);
     if (!controller || controller->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.
   }
 }