Use mojo Shelf interfaces for both mash and classic ash.

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/shelf_widget.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/resources/grit/ash_resources.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.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"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/extensions/gfx_utils.h"
 #include "chrome/browser/defaults.h"
-#include "chrome/browser/extensions/extension_app_icon_loader.h"
 #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_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"
@@ skipping 129 matching lines @@
 void ChromeLauncherControllerUserSwitchObserver::AddUser(Profile* profile) {
   if (chrome::MultiUserWindowManager::GetMultiProfileMode() ==
       chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_SEPARATED)
     chrome::MultiUserWindowManager::GetInstance()->AddUser(profile);
   controller_->AdditionalUserAddedToSession(profile->GetOriginalProfile());
 }
 
 ChromeLauncherControllerImpl::ChromeLauncherControllerImpl(
     Profile* profile,
     ash::ShelfModel* model)
-    : model_(model), profile_(profile), weak_ptr_factory_(this) {
+    : model_(model), weak_ptr_factory_(this) {
   DCHECK(model_);
-  if (!profile_) {
+  if (!profile) {
     // If no profile was passed, we take the currently active profile and use it
     // as the owner of the current desktop.
     // Use the original profile as on chromeos we may get a temporary off the
     // record profile, unless in guest session (where off the record profile is
     // the right one).
-    profile_ = ProfileManager::GetActiveUserProfile();
-    if (!profile_->IsGuestSession() && !profile_->IsSystemProfile())
-      profile_ = profile_->GetOriginalProfile();
+    profile = ProfileManager::GetActiveUserProfile();
+    if (!profile->IsGuestSession() && !profile->IsSystemProfile())
+      profile = profile->GetOriginalProfile();
 
-    app_sync_ui_state_ = AppSyncUIState::Get(profile_);
+    app_sync_ui_state_ = AppSyncUIState::Get(profile);
     if (app_sync_ui_state_)
       app_sync_ui_state_->AddObserver(this);
   }
 
-  if (arc::ArcAuthService::IsAllowedForProfile(profile_)) {
+  if (arc::ArcAuthService::IsAllowedForProfile(profile))
     arc_deferred_launcher_.reset(new ArcAppDeferredLauncherController(this));
-  }
 
   // All profile relevant settings get bound to the current profile.
-  AttachProfile(profile_);
+  AttachProfile(profile);
   model_->AddObserver(this);
 
   // In multi profile mode we might have a window manager. We try to create it
   // here. If the instantiation fails, the manager is not needed.
   chrome::MultiUserWindowManager::CreateInstance();
 
   // On Chrome OS using multi profile we want to switch the content of the shelf
   // with a user change. Note that for unit tests the instance can be NULL.
   if (chrome::MultiUserWindowManager::GetMultiProfileMode() !=
       chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_OFF) {
@@ skipping 73 matching lines @@
 
 void ChromeLauncherControllerImpl::Init() {
   CreateBrowserShortcutLauncherItem();
   UpdateAppLaunchersFromPref();
 
   // TODO(sky): update unit test so that this test isn't necessary.
   if (ash::Shell::HasInstance())
     SetVirtualKeyboardBehaviorFromPrefs();
 
   prefs_observer_ =
-      ash::launcher::ChromeLauncherPrefsObserver::CreateIfNecessary(profile_);
+      ash::launcher::ChromeLauncherPrefsObserver::CreateIfNecessary(profile());
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::CreateAppLauncherItem(
     LauncherItemController* controller,
     const std::string& app_id,
     ash::ShelfItemStatus status) {
   CHECK(controller);
   int index = 0;
   // Panels are inserted on the left so as not to push all existing panels over.
   if (controller->GetShelfItemType() != ash::TYPE_APP_PANEL)
@@ skipping 68 matching lines @@
 void ChromeLauncherControllerImpl::Unpin(ash::ShelfID id) {
   UnpinAndUpdatePrefs(id, true /* update_prefs */);
 }
 
 void ChromeLauncherControllerImpl::UnpinAndUpdatePrefs(ash::ShelfID id,
                                                        bool update_prefs) {
   LauncherItemController* controller = GetLauncherItemController(id);
   CHECK(controller);
 
   if (update_prefs)
-    ash::launcher::RemovePinPosition(profile_, GetAppIDForShelfID(id));
+    ash::launcher::RemovePinPosition(profile(), GetAppIDForShelfID(id));
 
   if (controller->type() == LauncherItemController::TYPE_APP ||
       controller->locked()) {
     UnpinRunningAppInternal(model_->ItemIndexByID(id));
   } else {
     LauncherItemClosed(id);
   }
 }
 
 bool ChromeLauncherControllerImpl::IsPinned(ash::ShelfID id) {
@@ skipping 67 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, profile_);
+  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::LaunchApp(const std::string& app_id,
-                                             ash::LaunchSource source,
-                                             int event_flags) {
-  launcher_controller_helper_->LaunchApp(app_id, source, event_flags);
-}
-
 void ChromeLauncherControllerImpl::ActivateApp(const std::string& app_id,
                                                ash::LaunchSource source,
                                                int event_flags) {
   // If there is an existing non-shortcut controller for this app, open it.
   ash::ShelfID id = GetShelfIDForAppID(app_id);
   if (id) {
     LauncherItemController* controller = GetLauncherItemController(id);
     controller->Activate(source);
     return;
   }
 
   // Create a temporary application launcher item and use it to see if there are
   // running instances.
   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), profile_);
+      GetExtensionForAppID(GetAppIDForShelfID(id), profile());
 
   // An extension can be unloaded/updated/unavailable at any time.
   if (!extension)
     return extensions::LAUNCH_TYPE_DEFAULT;
 
-  return extensions::GetLaunchType(extensions::ExtensionPrefs::Get(profile_),
+  return extensions::GetLaunchType(extensions::ExtensionPrefs::Get(profile()),
                                    extension);
 }
 
 void ChromeLauncherControllerImpl::SetLauncherItemImage(
     ash::ShelfID shelf_id,
     const gfx::ImageSkia& image) {
   int index = model_->ItemIndexByID(shelf_id);
   if (index == -1)
     return;
   ash::ShelfItem item = model_->items()[index];
@@ skipping 11 matching lines @@
   return type == ash::TYPE_WINDOWED_APP;
 }
 
 void ChromeLauncherControllerImpl::SetLaunchType(
     ash::ShelfID id,
     extensions::LaunchType launch_type) {
   LauncherItemController* controller = GetLauncherItemController(id);
   if (!controller)
     return;
 
-  extensions::SetLaunchType(profile_, controller->app_id(), launch_type);
-}
-
-Profile* ChromeLauncherControllerImpl::GetProfile() {
-  return profile_;
+  extensions::SetLaunchType(profile(), controller->app_id(), launch_type);
 }
 
 void ChromeLauncherControllerImpl::UpdateAppState(
     content::WebContents* contents,
     AppState app_state) {
-  std::string app_id = launcher_controller_helper_->GetAppID(contents);
+  std::string app_id = launcher_controller_helper()->GetAppID(contents);
 
   // Check if the gMail app is loaded and it matches the given content.
   // This special treatment is needed to address crbug.com/234268.
   if (app_id.empty() && ContentCanBeHandledByGmailApp(contents))
     app_id = kGmailAppId;
 
   // Check the old |app_id| for a tab. If the contents has changed we need to
   // remove it from the previous app.
   if (web_contents_to_app_id_.find(contents) != web_contents_to_app_id_.end()) {
     std::string last_app_id = web_contents_to_app_id_[contents];
@@ skipping 19 matching lines @@
                        app_state == APP_STATE_ACTIVE)
                           ? ash::STATUS_ACTIVE
                           : GetAppState(app_id));
   }
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::GetShelfIDForWebContents(
     content::WebContents* contents) {
   DCHECK(contents);
 
-  std::string app_id = launcher_controller_helper_->GetAppID(contents);
+  std::string app_id = launcher_controller_helper()->GetAppID(contents);
 
   if (app_id.empty() && ContentCanBeHandledByGmailApp(contents))
     app_id = kGmailAppId;
 
   ash::ShelfID id = GetShelfIDForAppID(app_id);
 
   if (app_id.empty() || !id) {
     int browser_index = model_->GetItemIndexForType(ash::TYPE_BROWSER_SHORTCUT);
     return model_->items()[browser_index].id;
   }
@@ skipping 26 matching lines @@
 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 =
-        multi_user_util::GetAccountIdFromProfile(GetProfile());
+        multi_user_util::GetAccountIdFromProfile(profile());
     chrome::MultiUserWindowManager* manager =
         chrome::MultiUserWindowManager::GetInstance();
     if (!manager->IsWindowOnDesktopOfUser(native_window, current_account_id)) {
       ash::MultiProfileUMA::RecordTeleportAction(
           ash::MultiProfileUMA::TELEPORT_WINDOW_RETURN_BY_LAUNCHER);
       manager->ShowWindowForUser(native_window, current_account_id);
       window->Activate();
       return ash::ShelfItemDelegate::kExistingWindowActivated;
     }
   }
@@ skipping 98 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, profile_) &&
-        GetExtensionForAppID(kGmailAppId, profile_)->OverlapsWithOrigin(url))
+        GetExtensionForAppID(kGmailAppId, profile()) &&
+        GetExtensionForAppID(kGmailAppId, profile())->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, profile_);
+        GetExtensionForAppID(app_id, profile());
     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 11 matching lines @@
     const ash::ShelfID id) {
   if (!HasShelfIDToAppIDMapping(id))
     return NULL;
   return id_to_item_controller_map_[id];
 }
 
 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_)
+  if (!other_profile || 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,
   // no window on desktop, multi user, ..) the shelf could be shown - or not.
-  PrefService* prefs = profile_->GetPrefs();
+  PrefService* prefs = profile()->GetPrefs();
   PrefService* other_prefs = other_profile->GetPrefs();
   const int64_t display = GetDisplayIDForShelf(shelf);
   const bool currently_shown =
       ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER ==
       ash::launcher::GetShelfAutoHideBehaviorPref(prefs, display);
   const bool other_shown =
       ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER ==
       ash::launcher::GetShelfAutoHideBehaviorPref(other_prefs, display);
 
   return currently_shown != other_shown ||
          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);
 }
 
 ArcAppDeferredLauncherController*
 ChromeLauncherControllerImpl::GetArcDeferredLauncher() {
   return arc_deferred_launcher_.get();
 }
 
+void ChromeLauncherControllerImpl::AttachProfile(Profile* profile) {
+  // The base class implementation updates the helper and app icon loaders.
+  ChromeLauncherController::AttachProfile(profile);
+
+  pref_change_registrar_.Init(profile->GetPrefs());
+  pref_change_registrar_.Add(
+      prefs::kPolicyPinnedLauncherApps,
+      base::Bind(&ChromeLauncherControllerImpl::UpdateAppLaunchersFromPref,
+                 base::Unretained(this)));
+  // Handling of prefs::kArcEnabled change should be called deferred to avoid
+  // race condition when OnAppUninstalledPrepared for Arc apps is called after
+  // UpdateAppLaunchersFromPref.
+  pref_change_registrar_.Add(
+      prefs::kArcEnabled,
+      base::Bind(
+          &ChromeLauncherControllerImpl::ScheduleUpdateAppLaunchersFromPref,
+          base::Unretained(this)));
+  pref_change_registrar_.Add(
+      prefs::kShelfAlignmentLocal,
+      base::Bind(&ChromeLauncherController::SetShelfAlignmentFromPrefs,
+                 base::Unretained(this)));
+  pref_change_registrar_.Add(
+      prefs::kShelfAutoHideBehaviorLocal,
+      base::Bind(&ChromeLauncherController::SetShelfAutoHideBehaviorFromPrefs,
+                 base::Unretained(this)));
+  pref_change_registrar_.Add(
+      prefs::kShelfPreferences,
+      base::Bind(&ChromeLauncherController::SetShelfBehaviorsFromPrefs,
+                 base::Unretained(this)));
+  pref_change_registrar_.Add(
+      prefs::kTouchVirtualKeyboardEnabled,
+      base::Bind(
+          &ChromeLauncherControllerImpl::SetVirtualKeyboardBehaviorFromPrefs,
+          base::Unretained(this)));
+
+  std::unique_ptr<LauncherAppUpdater> extension_app_updater(
+      new LauncherExtensionAppUpdater(this, profile));
+  app_updaters_.push_back(std::move(extension_app_updater));
+
+  if (arc::ArcAuthService::IsAllowedForProfile(profile)) {
+    std::unique_ptr<LauncherAppUpdater> arc_app_updater(
+        new LauncherArcAppUpdater(this, profile));
+    app_updaters_.push_back(std::move(arc_app_updater));
+  }
+
+  app_list::AppListSyncableService* app_service =
+      app_list::AppListSyncableServiceFactory::GetForProfile(profile);
+  if (app_service)
+    app_service->AddObserverAndStart(this);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ash::ShelfDelegate:
 
-void ChromeLauncherControllerImpl::OnShelfCreated(ash::WmShelf* shelf) {
-  PrefService* prefs = profile_->GetPrefs();
-  const int64_t display = GetDisplayIDForShelf(shelf);
-
-  shelf->SetAutoHideBehavior(
-      ash::launcher::GetShelfAutoHideBehaviorPref(prefs, display));
-
-  if (ash::ShelfWidget::ShelfAlignmentAllowed())
-    shelf->SetAlignment(ash::launcher::GetShelfAlignmentPref(prefs, display));
-}
-
-void ChromeLauncherControllerImpl::OnShelfDestroyed(ash::WmShelf* shelf) {}
-
-void ChromeLauncherControllerImpl::OnShelfAlignmentChanged(
-    ash::WmShelf* shelf) {
-  ash::launcher::SetShelfAlignmentPref(
-      profile_->GetPrefs(), GetDisplayIDForShelf(shelf), shelf->alignment());
-}
-
-void ChromeLauncherControllerImpl::OnShelfAutoHideBehaviorChanged(
-    ash::WmShelf* shelf) {
-  ash::launcher::SetShelfAutoHideBehaviorPref(profile_->GetPrefs(),
-                                              GetDisplayIDForShelf(shelf),
-                                              shelf->auto_hide_behavior());
-}
-
-void ChromeLauncherControllerImpl::OnShelfAutoHideStateChanged(
-    ash::WmShelf* shelf) {}
-
-void ChromeLauncherControllerImpl::OnShelfVisibilityStateChanged(
-    ash::WmShelf* shelf) {}
-
 ash::ShelfID ChromeLauncherControllerImpl::GetShelfIDForAppID(
     const std::string& app_id) {
   // Get shelf id for app_id and empty launch_id.
   return GetShelfIDForAppIDAndLaunchID(app_id, "");
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::GetShelfIDForAppIDAndLaunchID(
     const std::string& app_id,
     const std::string& launch_id) {
   const std::string shelf_app_id =
@@ skipping 18 matching lines @@
 
 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) {
   const std::string shelf_app_id =
       ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(app_id);
-  if (GetPinnableForAppID(shelf_app_id, profile_) ==
+  if (GetPinnableForAppID(shelf_app_id, profile()) ==
       AppListControllerDelegate::PIN_EDITABLE)
     DoPinAppWithID(shelf_app_id);
   else
     NOTREACHED();
 }
 
 bool ChromeLauncherControllerImpl::IsAppPinned(const std::string& app_id) {
   const std::string shelf_app_id =
       ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(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() == shelf_app_id)
       return true;
   }
   return false;
 }
 
 void ChromeLauncherControllerImpl::UnpinAppWithID(const std::string& app_id) {
   const std::string shelf_app_id =
       ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(app_id);
-  if (GetPinnableForAppID(shelf_app_id, profile_) ==
+  if (GetPinnableForAppID(shelf_app_id, profile()) ==
       AppListControllerDelegate::PIN_EDITABLE)
     DoUnpinAppWithID(shelf_app_id, true /* update_prefs */);
   else
     NOTREACHED();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // LauncherAppUpdater::Delegate:
 
 void ChromeLauncherControllerImpl::OnAppInstalled(
@@ skipping 22 matching lines @@
 void ChromeLauncherControllerImpl::OnAppUninstalledPrepared(
     content::BrowserContext* browser_context,
     const std::string& app_id) {
   // Since we might have windowed apps of this type which might have
   // outstanding locks which needs to be removed.
   const Profile* profile = Profile::FromBrowserContext(browser_context);
   if (GetShelfIDForAppID(app_id))
     CloseWindowedAppsFromRemovedExtension(app_id, profile);
 
   if (IsAppPinned(app_id)) {
-    if (profile == profile_) {
+    if (profile == this->profile()) {
       // Some apps may be removed locally. Don't remove pin position from sync
       // model. When needed, it is automatically deleted on app list model
       // update.
       DoUnpinAppWithID(app_id, false /* update_prefs */);
     }
     AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(app_id);
     if (app_icon_loader)
       app_icon_loader->ClearImage(app_id);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeLauncherControllerImpl protected:
 
 ash::ShelfID ChromeLauncherControllerImpl::CreateAppShortcutLauncherItem(
     const std::string& app_id,
     int index) {
   return CreateAppShortcutLauncherItemWithType(app_id, index,
                                                ash::TYPE_APP_SHORTCUT);
 }
 
-void ChromeLauncherControllerImpl::SetLauncherControllerHelperForTest(
-    LauncherControllerHelper* helper) {
-  launcher_controller_helper_.reset(helper);
-}
-
-void ChromeLauncherControllerImpl::SetAppIconLoadersForTest(
-    std::vector<std::unique_ptr<AppIconLoader>>& loaders) {
-  app_icon_loaders_.clear();
-  for (auto& loader : loaders)
-    app_icon_loaders_.push_back(std::move(loader));
-}
-
 const std::string& ChromeLauncherControllerImpl::GetAppIdFromShelfIdForTest(
     ash::ShelfID id) {
   return id_to_item_controller_map_[id]->app_id();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeLauncherControllerImpl private:
 
 void ChromeLauncherControllerImpl::RememberUnpinnedRunningApplicationOrder() {
   RunningAppListIds list;
   for (int i = 0; i < model_->item_count(); i++) {
     ash::ShelfItemType type = model_->items()[i].type;
     if (type == ash::TYPE_WINDOWED_APP || type == ash::TYPE_PLATFORM_APP)
       list.push_back(GetAppIDForShelfID(model_->items()[i].id));
   }
   const std::string user_email =
-      multi_user_util::GetAccountIdFromProfile(profile_).GetUserEmail();
+      multi_user_util::GetAccountIdFromProfile(profile()).GetUserEmail();
   last_used_running_application_order_[user_email] = list;
 }
 
 void ChromeLauncherControllerImpl::RestoreUnpinnedRunningApplicationOrder(
     const std::string& user_id) {
   const RunningAppListIdMap::iterator app_id_list =
       last_used_running_application_order_.find(user_id);
   if (app_id_list == last_used_running_application_order_.end())
     return;
 
@@ skipping 123 matching lines @@
 
   for (int i = index + 1; i < max_index; ++i) {
     const ash::ShelfID shelf_id_after = model_->items()[i].id;
     if (IsPinned(shelf_id_after)) {
       const std::string app_id_after = GetAppIDForShelfID(shelf_id_after);
       DCHECK(!app_id_after.empty());
       app_ids_after.push_back(app_id_after);
     }
   }
 
-  ash::launcher::SetPinPosition(profile_, app_id, app_id_before, app_ids_after);
+  ash::launcher::SetPinPosition(profile(), app_id, app_id_before,
+                                app_ids_after);
 }
 
 void ChromeLauncherControllerImpl::OnSyncModelUpdated() {
   UpdateAppLaunchersFromPref();
 }
 
 void ChromeLauncherControllerImpl::ScheduleUpdateAppLaunchersFromPref() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&ChromeLauncherControllerImpl::UpdateAppLaunchersFromPref,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ChromeLauncherControllerImpl::UpdateAppLaunchersFromPref() {
   // There are various functions which will trigger a |SyncPinPosition| call
   // like a direct call to |DoPinAppWithID|, or an indirect call to the menu
   // model which will use weights to re-arrange the icons to new positions.
   // Since this function is meant to synchronize the "is state" with the
   // "sync state", it makes no sense to store any changes by this function back
   // into the pref state. Therefore we tell |persistPinnedState| to ignore any
   // invocations while we are running.
   base::AutoReset<bool> auto_reset(&ignore_persist_pinned_state_change_, true);
   const std::vector<std::string> pinned_apps =
-      ash::launcher::GetPinnedAppsFromPrefs(profile_->GetPrefs(),
-                                            launcher_controller_helper_.get());
+      ash::launcher::GetPinnedAppsFromPrefs(profile()->GetPrefs(),
+                                            launcher_controller_helper());
 
   int index = 0;
   // Skip app list items if it exists.
   if (model_->items()[0].type == ash::TYPE_APP_LIST)
     ++index;
 
   // Apply pins in two steps. At the first step, go through the list of apps to
   // pin, move existing pin to current position specified by |index| or create
   // the new pin at that position.
   for (const auto& pref_app_id : pinned_apps) {
     // Filter out apps that may be mapped wrongly.
     // TODO(khmel):  b/31703859 is to refactore shelf mapping.
     const std::string shelf_app_id =
         ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(pref_app_id);
     if (shelf_app_id != pref_app_id)
       continue;
 
     // Update apps icon if applicable.
-    OnAppUpdated(profile_, pref_app_id);
+    OnAppUpdated(profile(), pref_app_id);
 
     // Find existing pin or app from the right of current |index|.
     int app_index = index;
     for (; app_index < model_->item_count(); ++app_index) {
       const ash::ShelfItem& item = model_->items()[app_index];
       const IDToItemControllerMap::iterator it =
           id_to_item_controller_map_.find(item.id);
       if (it != id_to_item_controller_map_.end() &&
           it->second->app_id() == pref_app_id) {
         break;
@@ skipping 35 matching lines @@
         controller->type() == LauncherItemController::TYPE_APP) {
       UnpinRunningAppInternal(index);
       // Note, item can be moved to the right due weighting in shelf model.
       DCHECK_GE(model_->ItemIndexByID(item.id), index);
     } else {
       LauncherItemClosed(item.id);
     }
   }
 }
 
-void ChromeLauncherControllerImpl::SetShelfAutoHideBehaviorFromPrefs() {
-  for (ash::WmWindow* window : ash::WmShell::Get()->GetAllRootWindows()) {
-    ash::WmShelf* shelf = ash::WmShelf::ForWindow(window);
-    // TODO(jamescook): This check should not be necessary, but otherwise this
-    // tries to set autohide state on a secondary display during login before
-    // the ShelfView is created, which is not allowed.
-    if (shelf->IsShelfInitialized()) {
-      shelf->SetAutoHideBehavior(ash::launcher::GetShelfAutoHideBehaviorPref(
-          profile_->GetPrefs(), GetDisplayIDForShelf(shelf)));
-    }
-  }
-}
-
-void ChromeLauncherControllerImpl::SetShelfAlignmentFromPrefs() {
-  if (!ash::ShelfWidget::ShelfAlignmentAllowed())
-    return;
-
-  for (ash::WmWindow* window : ash::WmShell::Get()->GetAllRootWindows()) {
-    ash::WmShelf* shelf = ash::WmShelf::ForWindow(window);
-    // TODO(jamescook): This check should not be necessary, but otherwise this
-    // tries to set the alignment on a secondary display during login before the
-    // ShelfLockingManager and ShelfView are created, which is not allowed.
-    if (shelf->IsShelfInitialized()) {
-      shelf->SetAlignment(ash::launcher::GetShelfAlignmentPref(
-          profile_->GetPrefs(), GetDisplayIDForShelf(shelf)));
-    }
-  }
-}
-
-void ChromeLauncherControllerImpl::SetShelfBehaviorsFromPrefs() {
-  SetShelfAutoHideBehaviorFromPrefs();
-  SetShelfAlignmentFromPrefs();
-}
-
 void ChromeLauncherControllerImpl::SetVirtualKeyboardBehaviorFromPrefs() {
-  const PrefService* service = profile_->GetPrefs();
+  const PrefService* service = profile()->GetPrefs();
   const bool was_enabled = keyboard::IsKeyboardEnabled();
   if (!service->HasPrefPath(prefs::kTouchVirtualKeyboardEnabled)) {
     keyboard::SetKeyboardShowOverride(keyboard::KEYBOARD_SHOW_OVERRIDE_NONE);
   } else {
     const bool enable =
         service->GetBoolean(prefs::kTouchVirtualKeyboardEnabled);
     keyboard::SetKeyboardShowOverride(
         enable ? keyboard::KEYBOARD_SHOW_OVERRIDE_ENABLED
                : keyboard::KEYBOARD_SHOW_OVERRIDE_DISABLED);
   }
@@ skipping 137 matching lines @@
 
 void ChromeLauncherControllerImpl::SetShelfItemDelegate(
     ash::ShelfID id,
     ash::ShelfItemDelegate* item_delegate) {
   DCHECK_GT(id, 0);
   DCHECK(item_delegate);
   model_->SetShelfItemDelegate(
       id, std::unique_ptr<ash::ShelfItemDelegate>(item_delegate));
 }
 
-void ChromeLauncherControllerImpl::AttachProfile(Profile* profile) {
-  profile_ = profile;
-  // Either add the profile to the list of known profiles and make it the active
-  // one for some functions of LauncherControllerHelper or create a new one.
-  if (!launcher_controller_helper_.get())
-    launcher_controller_helper_.reset(new LauncherControllerHelper(profile_));
-  else
-    launcher_controller_helper_->SetCurrentUser(profile_);
-  // TODO(skuhne): The AppIconLoaderImpl has the same problem. Each loaded
-  // image is associated with a profile (its loader requires the profile).
-  // Since icon size changes are possible, the icon could be requested to be
-  // reloaded. However - having it not multi profile aware would cause problems
-  // if the icon cache gets deleted upon user switch.
-  std::unique_ptr<AppIconLoader> extension_app_icon_loader(
-      new extensions::ExtensionAppIconLoader(
-          profile_, extension_misc::EXTENSION_ICON_SMALL, this));
-  app_icon_loaders_.push_back(std::move(extension_app_icon_loader));
-
-  if (arc::ArcAuthService::IsAllowedForProfile(profile_)) {
-    std::unique_ptr<AppIconLoader> arc_app_icon_loader(new ArcAppIconLoader(
-        profile_, extension_misc::EXTENSION_ICON_SMALL, this));
-    app_icon_loaders_.push_back(std::move(arc_app_icon_loader));
-  }
-
-  pref_change_registrar_.Init(profile_->GetPrefs());
-  pref_change_registrar_.Add(
-      prefs::kPolicyPinnedLauncherApps,
-      base::Bind(&ChromeLauncherControllerImpl::UpdateAppLaunchersFromPref,
-                 base::Unretained(this)));
-  // Handling of prefs::kArcEnabled change should be called deferred to avoid
-  // race condition when OnAppUninstalledPrepared for Arc apps is called after
-  // UpdateAppLaunchersFromPref.
-  pref_change_registrar_.Add(
-      prefs::kArcEnabled,
-      base::Bind(
-          &ChromeLauncherControllerImpl::ScheduleUpdateAppLaunchersFromPref,
-          base::Unretained(this)));
-  pref_change_registrar_.Add(
-      prefs::kShelfAlignmentLocal,
-      base::Bind(&ChromeLauncherControllerImpl::SetShelfAlignmentFromPrefs,
-                 base::Unretained(this)));
-  pref_change_registrar_.Add(
-      prefs::kShelfAutoHideBehaviorLocal,
-      base::Bind(
-          &ChromeLauncherControllerImpl::SetShelfAutoHideBehaviorFromPrefs,
-          base::Unretained(this)));
-  pref_change_registrar_.Add(
-      prefs::kShelfPreferences,
-      base::Bind(&ChromeLauncherControllerImpl::SetShelfBehaviorsFromPrefs,
-                 base::Unretained(this)));
-  pref_change_registrar_.Add(
-      prefs::kTouchVirtualKeyboardEnabled,
-      base::Bind(
-          &ChromeLauncherControllerImpl::SetVirtualKeyboardBehaviorFromPrefs,
-          base::Unretained(this)));
-
-  std::unique_ptr<LauncherAppUpdater> extension_app_updater(
-      new LauncherExtensionAppUpdater(this, profile_));
-  app_updaters_.push_back(std::move(extension_app_updater));
-
-  if (arc::ArcAuthService::IsAllowedForProfile(profile_)) {
-    std::unique_ptr<LauncherAppUpdater> arc_app_updater(
-        new LauncherArcAppUpdater(this, profile_));
-    app_updaters_.push_back(std::move(arc_app_updater));
-  }
-
-  app_list::AppListSyncableService* app_service =
-      app_list::AppListSyncableServiceFactory::GetForProfile(profile_);
-  if (app_service)
-    app_service->AddObserverAndStart(this);
-}
-
-void ChromeLauncherControllerImpl::SetProfileForTest(Profile* profile) {
-  profile_ = profile;
-}
-
 void ChromeLauncherControllerImpl::ReleaseProfile() {
   if (app_sync_ui_state_)
     app_sync_ui_state_->RemoveObserver(this);
 
   app_updaters_.clear();
 
   prefs_observer_.reset();
 
   pref_change_registrar_.RemoveAll();
 
   app_list::AppListSyncableService* app_service =
-      app_list::AppListSyncableServiceFactory::GetForProfile(profile_);
+      app_list::AppListSyncableServiceFactory::GetForProfile(profile());
   if (app_service)
     app_service->RemoveObserver(this);
 }
 
-AppIconLoader* ChromeLauncherControllerImpl::GetAppIconLoaderForApp(
-    const std::string& app_id) {
-  for (const auto& app_icon_loader : app_icon_loaders_) {
-    if (app_icon_loader->CanLoadImageForApp(app_id))
-      return app_icon_loader.get();
-  }
-
-  return nullptr;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // ash::ShelfModelObserver:
 
 void ChromeLauncherControllerImpl::ShelfItemAdded(int index) {
 }
 
 void ChromeLauncherControllerImpl::ShelfItemRemoved(int index,
                                                     ash::ShelfID id) {
   // TODO(skuhne): This fixes crbug.com/429870, but it does not answer why we
   // get into this state in the first place.
@@ skipping 74 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.
   }
 }