mash: Move LauncherItemController to ash, rename ShelfItemDelegate.

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/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"
-#include "chrome/browser/ui/ash/launcher/launcher_item_controller.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_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "content/public/browser/navigation_entry.h"
@@ skipping 11 matching lines @@
 namespace {
 
 // The time delta between clicks in which clicks to launch V2 apps are ignored.
 const int kClickSuppressionInMS = 1000;
 
 // Check if a browser can be used for activation. This addresses a special use
 // case in the M31 multi profile mode where a user activates a V1 app which only
 // exists yet on another users desktop, but they expect to get only their own
 // app items and not the ones from other users through activation.
 // TODO(skuhne): Remove this function and replace the call with
-// launcher_controller()->IsBrowserFromActiveUser(browser) once this experiment
-// goes away.
+// ChromeLauncherController::IsBrowserFromActiveUser(browser) once this
+// experiment goes away.
 bool CanBrowserBeUsedForDirectActivation(Browser* browser,
                                          ChromeLauncherController* launcher) {
   if (chrome::MultiUserWindowManager::GetMultiProfileMode() ==
           chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_OFF)
     return true;
   return multi_user_util::IsProfileFromActiveUser(browser->profile());
 }
 
 }  // namespace
 
 // static
-AppShortcutLauncherItemController* AppShortcutLauncherItemController::Create(
-    const ash::AppLaunchId& app_launch_id,
-    ChromeLauncherController* controller) {
+std::unique_ptr<AppShortcutLauncherItemController>
+AppShortcutLauncherItemController::Create(
+    const ash::AppLaunchId& app_launch_id) {
   if (app_launch_id.app_id() == ArcSupportHost::kHostAppId ||
       app_launch_id.app_id() == arc::kPlayStoreAppId) {
-    return new ArcPlaystoreShortcutLauncherItemController(controller);
+    return base::MakeUnique<ArcPlaystoreShortcutLauncherItemController>();
   }
-  return new AppShortcutLauncherItemController(app_launch_id, controller);
+  return base::WrapUnique<AppShortcutLauncherItemController>(
+      new AppShortcutLauncherItemController(app_launch_id));
 }
 
 // Item controller for an app shortcut. Shortcuts track app and launcher ids,
 // but do not have any associated windows (opening a shortcut will replace the
-// item with the appropriate LauncherItemController type).
+// item with the appropriate ash::ShelfItemDelegate type).
 AppShortcutLauncherItemController::AppShortcutLauncherItemController(
-    const ash::AppLaunchId& app_launch_id,
-    ChromeLauncherController* controller)
-    : LauncherItemController(app_launch_id, controller),
-      chrome_launcher_controller_(controller) {
+    const ash::AppLaunchId& app_launch_id)
+    : ash::ShelfItemDelegate(app_launch_id) {
   // To detect V1 applications we use their domain and match them against the
   // used URL. This will also work with applications like Google Drive.
-  const Extension* extension =
-      GetExtensionForAppID(app_launch_id.app_id(), controller->profile());
+  const Extension* extension = GetExtensionForAppID(
+      app_launch_id.app_id(), ChromeLauncherController::instance()->profile());
   // Some unit tests have no real extension.
   if (extension) {
     set_refocus_url(GURL(
         extensions::AppLaunchInfo::GetLaunchWebURL(extension).spec() + "*"));
   }
 }
 
 AppShortcutLauncherItemController::~AppShortcutLauncherItemController() {}
 
 void AppShortcutLauncherItemController::ItemSelected(
@@ skipping 16 matching lines @@
     // 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()) {
       callback.Run(ash::SHELF_ACTION_NONE,
                    GetAppMenuItems(event ? event->flags() : ui::EF_NONE));
       return;
     }
 
     // Launching some items replaces this item controller instance, which
     // destroys its AppLaunchId string pair; making copies avoid crashes.
-    launcher_controller()->LaunchApp(ash::AppLaunchId(app_launch_id()), source,
-                                     ui::EF_NONE);
+    ChromeLauncherController::instance()->LaunchApp(
+        ash::AppLaunchId(app_launch_id()), source, ui::EF_NONE);
     callback.Run(ash::SHELF_ACTION_NEW_WINDOW_CREATED, base::nullopt);
     return;
   }
 
   const ash::ShelfAction action = ActivateContent(content);
   callback.Run(action, GetAppMenuItems(event ? event->flags() : ui::EF_NONE));
 }
 
-MenuItemList AppShortcutLauncherItemController::GetAppMenuItems(
+ash::MenuItemList AppShortcutLauncherItemController::GetAppMenuItems(
     int event_flags) {
-  MenuItemList items;
+  ash::MenuItemList items;
   app_menu_items_ = GetRunningApplications();
+  ChromeLauncherController* controller = ChromeLauncherController::instance();
   for (size_t i = 0; i < app_menu_items_.size(); i++) {
     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();
+    item->label = controller->GetAppListTitle(tab);
+    item->image = *controller->GetAppListIcon(tab).ToSkBitmap();
     items.push_back(std::move(item));
   }
   return items;
 }
 
 void AppShortcutLauncherItemController::ExecuteCommand(uint32_t command_id,
                                                        int32_t event_flags) {
   if (static_cast<size_t>(command_id) >= app_menu_items_.size()) {
     app_menu_items_.clear();
     return;
@@ skipping 17 matching lines @@
       browser->window()->Activate();
     }
   }
 
   app_menu_items_.clear();
 }
 
 void AppShortcutLauncherItemController::Close() {
   // Close all running 'programs' of this type.
   std::vector<content::WebContents*> content =
-      launcher_controller()->GetV1ApplicationsFromAppId(app_id());
+      ChromeLauncherController::instance()->GetV1ApplicationsFromAppId(
+          app_id());
   for (size_t i = 0; i < content.size(); i++) {
     Browser* browser = chrome::FindBrowserWithWebContents(content[i]);
     if (!browser || !IsBrowserFromActiveUser(browser))
       continue;
     TabStripModel* tab_strip = browser->tab_strip_model();
     int index = tab_strip->GetIndexOfWebContents(content[i]);
     DCHECK(index != TabStripModel::kNoTab);
     tab_strip->CloseWebContentsAt(index, TabStripModel::CLOSE_NONE);
   }
 }
 
 std::vector<content::WebContents*>
 AppShortcutLauncherItemController::GetRunningApplications() {
   std::vector<content::WebContents*> items;
 
   URLPattern refocus_pattern(URLPattern::SCHEME_ALL);
   refocus_pattern.SetMatchAllURLs(true);
 
   if (!refocus_url_.is_empty()) {
     refocus_pattern.SetMatchAllURLs(false);
     refocus_pattern.Parse(refocus_url_.spec());
   }
 
-  const Extension* extension =
-      GetExtensionForAppID(app_id(), launcher_controller()->profile());
+  const Extension* extension = GetExtensionForAppID(
+      app_id(), ChromeLauncherController::instance()->profile());
 
   // It is possible to come here While an extension gets loaded.
   if (!extension)
     return items;
 
   for (auto* browser : *BrowserList::GetInstance()) {
     if (!IsBrowserFromActiveUser(browser))
       continue;
     TabStripModel* tab_strip = browser->tab_strip_model();
     for (int index = 0; index < tab_strip->count(); index++) {
       content::WebContents* web_contents = tab_strip->GetWebContentsAt(index);
       if (WebContentMatchesApp(
               extension, refocus_pattern, web_contents, browser))
         items.push_back(web_contents);
     }
   }
   return items;
 }
 
 content::WebContents* AppShortcutLauncherItemController::GetLRUApplication() {
   URLPattern refocus_pattern(URLPattern::SCHEME_ALL);
   refocus_pattern.SetMatchAllURLs(true);
 
   if (!refocus_url_.is_empty()) {
     refocus_pattern.SetMatchAllURLs(false);
     refocus_pattern.Parse(refocus_url_.spec());
   }
 
+  ChromeLauncherController* controller = ChromeLauncherController::instance();
   const Extension* extension =
-      GetExtensionForAppID(app_id(), launcher_controller()->profile());
+      GetExtensionForAppID(app_id(), controller->profile());
 
   // We may get here while the extension is loading (and NULL).
   if (!extension)
     return NULL;
 
   const BrowserList* browser_list = BrowserList::GetInstance();
   for (BrowserList::const_reverse_iterator it =
            browser_list->begin_last_active();
        it != browser_list->end_last_active(); ++it) {
     Browser* browser = *it;
-    if (!CanBrowserBeUsedForDirectActivation(browser, launcher_controller()))
+    if (!CanBrowserBeUsedForDirectActivation(browser, controller))
       continue;
     TabStripModel* tab_strip = browser->tab_strip_model();
     // We start to enumerate from the active index.
     int active_index = tab_strip->active_index();
     for (int index = 0; index < tab_strip->count(); index++) {
       content::WebContents* web_contents = tab_strip->GetWebContentsAt(
           (index + active_index) % tab_strip->count());
       if (WebContentMatchesApp(
               extension, refocus_pattern, web_contents, browser))
         return web_contents;
     }
   }
   // Coming here our application was not in the LRU list. This could have
   // happened because it did never get activated yet. So check the browser list
   // as well.
   for (BrowserList::const_iterator it = browser_list->begin();
        it != browser_list->end(); ++it) {
     Browser* browser = *it;
-    if (!CanBrowserBeUsedForDirectActivation(browser, launcher_controller()))
+    if (!CanBrowserBeUsedForDirectActivation(
+            browser, ChromeLauncherController::instance()))
       continue;
     TabStripModel* tab_strip = browser->tab_strip_model();
     for (int index = 0; index < tab_strip->count(); index++) {
       content::WebContents* web_contents = tab_strip->GetWebContentsAt(index);
       if (WebContentMatchesApp(
               extension, refocus_pattern, web_contents, browser))
         return web_contents;
     }
   }
   return NULL;
@@ skipping 18 matching lines @@
   // tabs.
   if (extensions::LaunchesInWindow(browser->profile(), extension))
     return false;
 
   // There are three ways to identify the association of a URL with this
   // extension:
   // - The refocus pattern is matched (needed for apps like drive).
   // - The extension's origin + extent gets matched.
   // - The launcher controller knows that the tab got created for this app.
   const GURL tab_url = web_contents->GetURL();
-  return ((!refocus_pattern.match_all_urls() &&
-           refocus_pattern.MatchesURL(tab_url)) ||
-          (extension->OverlapsWithOrigin(tab_url) &&
-           extension->web_extent().MatchesURL(tab_url)) ||
-          launcher_controller()->IsWebContentHandledByApplication(web_contents,
-                                                                  app_id()));
+  return (
+      (!refocus_pattern.match_all_urls() &&
+       refocus_pattern.MatchesURL(tab_url)) ||
+      (extension->OverlapsWithOrigin(tab_url) &&
+       extension->web_extent().MatchesURL(tab_url)) ||
+      ChromeLauncherController::instance()->IsWebContentHandledByApplication(
+          web_contents, app_id()));
 }
 
 ash::ShelfAction AppShortcutLauncherItemController::ActivateContent(
     content::WebContents* content) {
   Browser* browser = chrome::FindBrowserWithWebContents(content);
   TabStripModel* tab_strip = browser->tab_strip_model();
   int index = tab_strip->GetIndexOfWebContents(content);
   DCHECK_NE(TabStripModel::kNoTab, index);
 
   int old_index = tab_strip->active_index();
   if (index != old_index)
     tab_strip->ActivateTabAt(index, false);
-  return launcher_controller()->ActivateWindowOrMinimizeIfActive(
+  return ChromeLauncherController::instance()->ActivateWindowOrMinimizeIfActive(
       browser->window(),
       index == old_index && GetRunningApplications().size() == 1);
 }
 
 bool AppShortcutLauncherItemController::AdvanceToNextApp() {
   std::vector<content::WebContents*> items = GetRunningApplications();
   if (items.size() >= 1) {
     Browser* browser = chrome::FindBrowserWithWindow(
         ash::wm::GetActiveWindow());
     if (browser) {
@@ skipping 13 matching lines @@
           ActivateContent(items[index]);
         }
         return true;
       }
     }
   }
   return false;
 }
 
 bool AppShortcutLauncherItemController::IsV2App() {
-  const Extension* extension =
-      GetExtensionForAppID(app_id(), launcher_controller()->profile());
+  const Extension* extension = GetExtensionForAppID(
+      app_id(), ChromeLauncherController::instance()->profile());
   return extension && extension->is_platform_app();
 }
 
 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;
 }