Moved methods that don't rely on internal state out of ChromeLauncherController.

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>
 
@@ skipping 23 matching lines @@
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_icon_loader.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/ash/app_sync_ui_state.h"
+
 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
 #include "chrome/browser/ui/ash/chrome_shell_delegate.h"
 #include "chrome/browser/ui/ash/launcher/app_shortcut_launcher_item_controller.h"
 #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_app_menu_item.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_app_menu_item_browser.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_app_menu_item_tab.h"
+#include "chrome/browser/ui/ash/launcher/chrome_launcher_controller_util.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_types.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"
@@ skipping 413 matching lines @@
   if (!controller)
     return false;
   return controller->IsOpen();
 }
 
 bool ChromeLauncherControllerImpl::IsPlatformApp(ash::ShelfID id) {
   if (!HasShelfIDToAppIDMapping(id))
     return false;
 
   std::string app_id = GetAppIDForShelfID(id);
-  const Extension* extension = GetExtensionForAppID(app_id);
+  const Extension* extension =
+      chrome::util::GetExtensionForAppID(profile_, app_id);
   // An extension can be synced / updated at any time and therefore not be
   // available.
   return extension ? extension->is_platform_app() : false;
 }
 
 void ChromeLauncherControllerImpl::LaunchApp(const std::string& app_id,
                                              ash::LaunchSource source,
                                              int event_flags) {
   launcher_controller_helper_->LaunchApp(app_id, source, event_flags);
 }
@@ skipping 14 matching lines @@
   std::unique_ptr<AppShortcutLauncherItemController> app_controller(
       AppShortcutLauncherItemController::Create(app_id, this));
   if (!app_controller->GetRunningApplications().empty())
     app_controller->Activate(source);
   else
     LaunchApp(app_id, source, event_flags);
 }
 
 extensions::LaunchType ChromeLauncherControllerImpl::GetLaunchType(
     ash::ShelfID id) {
-  const Extension* extension = GetExtensionForAppID(GetAppIDForShelfID(id));
+  const Extension* extension =
+      chrome::util::GetExtensionForAppID(profile_, GetAppIDForShelfID(id));
 
   // An extension can be unloaded/updated/unavailable at any time.
   if (!extension)
     return extensions::LAUNCH_TYPE_DEFAULT;
 
   return extensions::GetLaunchType(extensions::ExtensionPrefs::Get(profile_),
                                    extension);
 }
 
 void ChromeLauncherControllerImpl::SetLauncherItemImage(
@@ skipping 104 matching lines @@
   ash::ShelfItemType type = model_->items()[index].type;
   if (type == ash::TYPE_APP_SHORTCUT || type == ash::TYPE_WINDOWED_APP) {
     AppShortcutLauncherItemController* app_controller =
         static_cast<AppShortcutLauncherItemController*>(controller);
     app_controller->set_refocus_url(url);
   } else {
     NOTREACHED() << "Invalid launcher type";
   }
 }
 
-const Extension* ChromeLauncherControllerImpl::GetExtensionForAppID(
-    const std::string& app_id) const {
-  return extensions::ExtensionRegistry::Get(profile_)->GetExtensionById(
-      app_id, extensions::ExtensionRegistry::EVERYTHING);
-}
-
 ash::ShelfItemDelegate::PerformedAction
 ChromeLauncherControllerImpl::ActivateWindowOrMinimizeIfActive(
     ui::BaseWindow* window,
     bool allow_minimize) {
   // In separated desktop mode we might have to teleport a window back to the
   // current user.
   if (chrome::MultiUserWindowManager::GetMultiProfileMode() ==
       chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_SEPARATED) {
     aura::Window* native_window = window->GetNativeWindow();
     const AccountId& current_account_id =
@@ skipping 109 matching lines @@
 bool ChromeLauncherControllerImpl::ContentCanBeHandledByGmailApp(
     content::WebContents* web_contents) {
   ash::ShelfID id = GetShelfIDForAppID(kGmailAppId);
   if (id) {
     const GURL url = web_contents->GetURL();
     // We need to extend the application matching for the gMail app beyond the
     // manifest file's specification. This is required because of the namespace
     // overlap with the offline app ("/mail/mu/").
     if (!base::MatchPattern(url.path(), "/mail/mu/*") &&
         base::MatchPattern(url.path(), "/mail/*") &&
-        GetExtensionForAppID(kGmailAppId) &&
-        GetExtensionForAppID(kGmailAppId)->OverlapsWithOrigin(url))
+        chrome::util::GetExtensionForAppID(profile_, kGmailAppId) &&
+        chrome::util::GetExtensionForAppID(profile_, kGmailAppId)
+            ->OverlapsWithOrigin(url))
       return true;
   }
   return false;
 }
 
 gfx::Image ChromeLauncherControllerImpl::GetAppListIcon(
     content::WebContents* web_contents) const {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   if (IsIncognito(web_contents))
     return rb.GetImageNamed(IDR_ASH_SHELF_LIST_INCOGNITO_BROWSER);
   favicon::FaviconDriver* favicon_driver =
       favicon::ContentFaviconDriver::FromWebContents(web_contents);
   gfx::Image result = favicon_driver->GetFavicon();
   if (result.IsEmpty())
     return rb.GetImageNamed(IDR_DEFAULT_FAVICON);
   return result;
 }
 
 base::string16 ChromeLauncherControllerImpl::GetAppListTitle(
     content::WebContents* web_contents) const {
   base::string16 title = web_contents->GetTitle();
   if (!title.empty())
     return title;
   WebContentsToAppIDMap::const_iterator iter =
       web_contents_to_app_id_.find(web_contents);
   if (iter != web_contents_to_app_id_.end()) {
     std::string app_id = iter->second;
-    const extensions::Extension* extension = GetExtensionForAppID(app_id);
+    const extensions::Extension* extension =
+        chrome::util::GetExtensionForAppID(profile_, app_id);
     if (extension)
       return base::UTF8ToUTF16(extension->name());
   }
   return l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE);
 }
 
 BrowserShortcutLauncherItemController*
 ChromeLauncherControllerImpl::GetBrowserShortcutLauncherItemController() {
   for (IDToItemControllerMap::iterator i = id_to_item_controller_map_.begin();
        i != id_to_item_controller_map_.end(); ++i) {
@@ skipping 21 matching lines @@
   }
 }
 
 LauncherItemController* ChromeLauncherControllerImpl::GetLauncherItemController(
     const ash::ShelfID id) {
   if (!HasShelfIDToAppIDMapping(id))
     return NULL;
   return id_to_item_controller_map_[id];
 }
 
-bool ChromeLauncherControllerImpl::IsBrowserFromActiveUser(Browser* browser) {
-  // If running multi user mode with separate desktops, we have to check if the
-  // browser is from the active user.
-  if (chrome::MultiUserWindowManager::GetMultiProfileMode() !=
-      chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_SEPARATED)
-    return true;
-  return multi_user_util::IsProfileFromActiveUser(browser->profile());
-}
-
 bool ChromeLauncherControllerImpl::ShelfBoundsChangesProbablyWithUser(
     ash::Shelf* shelf,
     const std::string& user_id) const {
   Profile* other_profile = multi_user_util::GetProfileFromAccountId(
       AccountId::FromUserEmail(user_id));
   if (other_profile == profile_)
     return false;
 
   // Note: The Auto hide state from preferences is not the same as the actual
   // visibility of the shelf. Depending on all the various states (full screen,
@@ skipping 12 matching lines @@
          ash::launcher::GetShelfAlignmentPref(prefs, display) !=
              ash::launcher::GetShelfAlignmentPref(other_prefs, display);
 }
 
 void ChromeLauncherControllerImpl::OnUserProfileReadyToSwitch(
     Profile* profile) {
   if (user_switch_observer_.get())
     user_switch_observer_->OnUserProfileReadyToSwitch(profile);
 }
 
-AppListControllerDelegate::Pinnable ChromeLauncherControllerImpl::GetPinnable(
-    const std::string& app_id) {
-  const base::ListValue* pref =
-      profile_->GetPrefs()->GetList(prefs::kPolicyPinnedLauncherApps);
-  if (!pref)
-    return AppListControllerDelegate::PIN_EDITABLE;
-
-  // Pinned ARC apps policy defines the package name of the apps, that must
-  // be pinned. All the launch activities of any package in policy are pinned.
-  // In turn the input parameter to this function is app_id, which
-  // is 32 chars hash. In case of ARC app this is a hash of
-  // (package name + activity). This means that we must identify the package
-  // from the hash, and check if this package is pinned by policy.
-  const ArcAppListPrefs* const arc_prefs = ArcAppListPrefs::Get(GetProfile());
-  std::string arc_app_packege_name;
-  if (arc_prefs) {
-    std::unique_ptr<ArcAppListPrefs::AppInfo> app_info =
-        arc_prefs->GetApp(app_id);
-    if (app_info)
-      arc_app_packege_name = app_info->package_name;
-  }
-
-  for (size_t index = 0; index < pref->GetSize(); ++index) {
-    const base::DictionaryValue* app = nullptr;
-    std::string app_id_or_package;
-    if (pref->GetDictionary(index, &app) &&
-        app->GetString(ash::launcher::kPinnedAppsPrefAppIDPath,
-                       &app_id_or_package) &&
-        (app_id == app_id_or_package ||
-         arc_app_packege_name == app_id_or_package)) {
-      return AppListControllerDelegate::PIN_FIXED;
-    }
-  }
-  return AppListControllerDelegate::PIN_EDITABLE;
-}
-
 ArcAppDeferredLauncherController*
 ChromeLauncherControllerImpl::GetArcDeferredLauncher() {
   return arc_deferred_launcher_.get();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ash::ShelfDelegate:
 
 void ChromeLauncherControllerImpl::OnShelfCreated(ash::Shelf* shelf) {
   PrefService* prefs = profile_->GetPrefs();
@@ skipping 45 matching lines @@
          id_to_item_controller_map_.end();
 }
 
 const std::string& ChromeLauncherControllerImpl::GetAppIDForShelfID(
     ash::ShelfID id) {
   LauncherItemController* controller = GetLauncherItemController(id);
   return controller ? controller->app_id() : base::EmptyString();
 }
 
 void ChromeLauncherControllerImpl::PinAppWithID(const std::string& app_id) {
-  if (GetPinnable(app_id) == AppListControllerDelegate::PIN_EDITABLE)
+  if (chrome::util::GetPinnable(profile_, app_id) ==
+      AppListControllerDelegate::PIN_EDITABLE)
     DoPinAppWithID(app_id);
   else
     NOTREACHED();
 }
 
 bool ChromeLauncherControllerImpl::IsAppPinned(const std::string& app_id) {
   for (IDToItemControllerMap::const_iterator i =
            id_to_item_controller_map_.begin();
        i != id_to_item_controller_map_.end(); ++i) {
     if (IsPinned(i->first) && i->second->app_id() == app_id)
       return true;
   }
   return false;
 }
 
 void ChromeLauncherControllerImpl::UnpinAppWithID(const std::string& app_id) {
-  if (GetPinnable(app_id) == AppListControllerDelegate::PIN_EDITABLE)
+  if (chrome::util::GetPinnable(profile_, app_id) ==
+      AppListControllerDelegate::PIN_EDITABLE)
     DoUnpinAppWithID(app_id);
   else
     NOTREACHED();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // LauncherAppUpdater::Delegate:
 
 void ChromeLauncherControllerImpl::OnAppInstalled(
     content::BrowserContext* browser_context,
@@ skipping 727 matching lines @@
     if (index == -1)
       continue;
     ash::ShelfItem item = model_->items()[index];
     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.
   }
 }