Pin apps from prefs on the mash shelf.

chrome/browser/ui/ash/launcher/chrome_launcher_controller.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.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 27 matching lines @@
 #include "chrome/browser/ui/ash/chrome_launcher_prefs.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/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_types.h"
-#include "chrome/browser/ui/ash/launcher/launcher_app_tab_helper.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/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_commands.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"
@@ skipping 51 matching lines @@
 using extensions::Extension;
 using extensions::UnloadedExtensionInfo;
 using extension_misc::kGmailAppId;
 using content::WebContents;
 
 // static
 ChromeLauncherController* ChromeLauncherController::instance_ = NULL;
 
 namespace {
 
-// This will be used as placeholder in the list of the pinned applciatons.
-// Note that this is NOT a valid extension identifier so that pre M31 versions
-// will ignore it.
-const char kAppShelfIdPlaceholder[] = "AppShelfIDPlaceholder--------";
-
 int64_t GetDisplayIDForShelf(ash::Shelf* shelf) {
   aura::Window* root_window =
       shelf->shelf_widget()->GetNativeWindow()->GetRootWindow();
   display::Display display =
       display::Screen::GetScreen()->GetDisplayNearestWindow(root_window);
   DCHECK(display.is_valid());
   return display.id();
 }
 
 // If prefs have synced and no user-set value exists at |local_path|, the value
@@ skipping 61 matching lines @@
         // Only pinned by policy, which is not part of user-pinned
         if (app_id == app_id_)
           return false;
       }
     }
   }
   // Default, user added new pins
   return true;
 }
 
-void update_pinned_apps(const std::string& app_id,
-                        bool valid_for_current_user,
-                        std::vector<std::string>* pinned_apps,
-                        bool* chrome_icon_added,
-                        bool* app_list_icon_added) {
-  if (app_id == extension_misc::kChromeAppId) {
-    *chrome_icon_added = true;
-    pinned_apps->push_back(extension_misc::kChromeAppId);
-  } else if (app_id == kAppShelfIdPlaceholder) {
-    *app_list_icon_added = true;
-    pinned_apps->push_back(kAppShelfIdPlaceholder);
-  } else if (valid_for_current_user) {
-    // Note: In multi profile scenarios we only want to show pinnable apps
-    // here which is correct. Running applications from the other users will
-    // continue to run. So no need for multi profile modifications.
-    pinned_apps->push_back(app_id);
-  }
-}
-
 const char* const kPinProhibitedExtensionIds[] = {
 #if defined(OS_CHROMEOS)
     "cnbgggchhmkkdmeppjobngjoejnihlei",  // Arc Support
 #endif
 };
 
 const size_t kPinProhibitedExtensionIdsLength =
     arraysize(kPinProhibitedExtensionIds);
 
 }  // namespace
@@ skipping 652 matching lines @@
             if (!IsAppForUserPinned(controller->app_id(),
                                     pinned_apps_pref.get(),
                                     policy_pinned_apps_pref))
               app_value->SetBoolean(ash::kPinnedAppsPrefPinnedByPolicy, true);
             updater->Append(app_value);
           }
         }
       } else if (model_->items()[i].type == ash::TYPE_BROWSER_SHORTCUT) {
         PersistChromeItemIndex(i);
       } else if (model_->items()[i].type == ash::TYPE_APP_LIST) {
-        base::DictionaryValue* app_value = ash::CreateAppDict(
-            kAppShelfIdPlaceholder);
+        base::DictionaryValue* app_value =
+            ash::CreateAppDict(ash::kPinnedAppsPlaceholder);
         if (app_value)
           updater->Append(app_value);
       }
     }
   }
   pref_change_registrar_.Add(
       prefs::kPinnedLauncherApps,
       base::Bind(&ChromeLauncherController::UpdateAppLaunchersFromPref,
                  base::Unretained(this)));
 }
 
 ash::ShelfModel* ChromeLauncherController::model() {
   return model_;
 }
 
 Profile* ChromeLauncherController::profile() {
   return profile_;
 }
 
 void ChromeLauncherController::UpdateAppState(content::WebContents* contents,
                                               AppState app_state) {
-  std::string app_id = app_tab_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 18 matching lines @@
     SetItemStatus(id, (app_state == APP_STATE_WINDOW_ACTIVE ||
                        app_state == APP_STATE_ACTIVE) ? ash::STATUS_ACTIVE :
                                                         GetAppState(app_id));
   }
 }
 
 ash::ShelfID ChromeLauncherController::GetShelfIDForWebContents(
     content::WebContents* contents) {
   DCHECK(contents);
 
-  std::string app_id = app_tab_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 328 matching lines @@
 }
 
 ash::ShelfID ChromeLauncherController::CreateAppShortcutLauncherItem(
     const std::string& app_id,
     int index) {
   return CreateAppShortcutLauncherItemWithType(app_id,
                                                index,
                                                ash::TYPE_APP_SHORTCUT);
 }
 
-void ChromeLauncherController::SetAppTabHelperForTest(AppTabHelper* helper) {
-  app_tab_helper_.reset(helper);
+void ChromeLauncherController::SetLauncherControllerHelperForTest(
+    LauncherControllerHelper* helper) {
+  launcher_controller_helper_.reset(helper);
 }
 
 void ChromeLauncherController::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& ChromeLauncherController::GetAppIdFromShelfIdForTest(
@@ skipping 191 matching lines @@
 
 void ChromeLauncherController::UpdateAppLaunchersFromPref() {
   // There are various functions which will trigger a |PersistPinnedState| 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);
-  std::vector<std::string> pinned_apps = GetListOfPinnedAppsAndBrowser();
+  std::vector<std::string> pinned_apps = ash::GetPinnedAppsFromPrefs(
+      profile_->GetPrefs(), launcher_controller_helper_.get());
 
   int index = 0;
   int max_index = model_->item_count();
 
   // When one of the two special items cannot be moved (and we do not know where
   // yet), we remember the current location in one of these variables.
   int chrome_index = -1;
   int app_list_index = -1;
 
   // Walk the model and |pinned_apps| from the pref lockstep, adding and
   // removing items as necessary. NB: This code uses plain old indexing instead
   // of iterators because of model mutations as part of the loop.
   std::vector<std::string>::const_iterator pref_app_id(pinned_apps.begin());
   for (; index < max_index && pref_app_id != pinned_apps.end(); ++index) {
     // Check if we have an item which we need to handle.
     if (*pref_app_id == extension_misc::kChromeAppId ||
-        *pref_app_id == kAppShelfIdPlaceholder ||
+        *pref_app_id == ash::kPinnedAppsPlaceholder ||
         IsAppPinned(*pref_app_id)) {
       for (; index < max_index; ++index) {
         const ash::ShelfItem& item(model_->items()[index]);
         bool is_app_list = item.type == ash::TYPE_APP_LIST;
         bool is_chrome = item.type == ash::TYPE_BROWSER_SHORTCUT;
         if (item.type != ash::TYPE_APP_SHORTCUT && !is_app_list && !is_chrome)
           continue;
         LauncherItemController* controller = GetLauncherItemController(item.id);
-        if ((kAppShelfIdPlaceholder == *pref_app_id && is_app_list) ||
+        if ((ash::kPinnedAppsPlaceholder == *pref_app_id && is_app_list) ||
             (extension_misc::kChromeAppId == *pref_app_id && is_chrome) ||
             (controller && controller->app_id() == *pref_app_id)) {
           // Check if an item needs to be moved here.
           MoveChromeOrApplistToFinalPosition(
               is_chrome, is_app_list, index, &chrome_index, &app_list_index);
           ++pref_app_id;
           break;
         } else {
           if (is_chrome || is_app_list) {
             // We cannot delete any of these shortcuts. As such we remember
@@ skipping 65 matching lines @@
       else if (item.type == ash::TYPE_APP_LIST)
         app_list_index = index;
       ++index;
     }
   }
 
   // Append unprocessed items from the pref to the end of the model.
   for (; pref_app_id != pinned_apps.end(); ++pref_app_id) {
     // All items but the chrome and / or app list shortcut needs to be added.
     bool is_chrome = *pref_app_id == extension_misc::kChromeAppId;
-    bool is_app_list = *pref_app_id == kAppShelfIdPlaceholder;
+    bool is_app_list = *pref_app_id == ash::kPinnedAppsPlaceholder;
     // Coming here we know the next item which can be finalized, either the
     // chrome item or the app launcher. The final position is the end of the
     // list. The menu model will make sure that the item is grouped according
     // to its weight (which we do not know here).
     if (!is_chrome && !is_app_list) {
       DoPinAppWithID(*pref_app_id);
       int target_index = FindInsertionPoint(false);
       ash::ShelfID id = GetShelfIDForAppID(*pref_app_id);
       int source_index = model_->ItemIndexByID(id);
       if (source_index != target_index)
@@ skipping 154 matching lines @@
   id_to_item_controller_map_[id]->set_shelf_id(id);
   // ShelfItemDelegateManager owns BrowserShortcutLauncherItemController.
   SetShelfItemDelegate(id, id_to_item_controller_map_[id]);
   return id;
 }
 
 void ChromeLauncherController::PersistChromeItemIndex(int index) {
   profile_->GetPrefs()->SetInteger(prefs::kShelfChromeIconIndex, index);
 }
 
-int ChromeLauncherController::GetChromeIconIndexFromPref() const {
-  size_t index = profile_->GetPrefs()->GetInteger(prefs::kShelfChromeIconIndex);
-  const base::ListValue* pinned_apps_pref =
-      profile_->GetPrefs()->GetList(prefs::kPinnedLauncherApps);
-  return std::max(static_cast<size_t>(0),
-                  std::min(pinned_apps_pref->GetSize(), index));
-}
-
 void ChromeLauncherController::MoveChromeOrApplistToFinalPosition(
     bool is_chrome,
     bool is_app_list,
     int target_index,
     int* chrome_index,
     int* app_list_index) {
   if (is_chrome && *chrome_index != -1) {
     model_->Move(*chrome_index, target_index);
     if (*app_list_index != -1 &&
         *chrome_index < *app_list_index &&
@@ skipping 25 matching lines @@
         type == ash::TYPE_BROWSER_SHORTCUT) {
       return i;
     }
   }
   return 0;
 }
 
 int ChromeLauncherController::GetChromeIconIndexForCreation() {
   // We get the list of pinned apps as they currently would get pinned.
   // Within this list the chrome icon will be the correct location.
-  std::vector<std::string> pinned_apps = GetListOfPinnedAppsAndBrowser();
+  std::vector<std::string> pinned_apps = ash::GetPinnedAppsFromPrefs(
+      profile_->GetPrefs(), launcher_controller_helper_.get());
 
   std::vector<std::string>::iterator it =
       std::find(pinned_apps.begin(),
                 pinned_apps.end(),
                 std::string(extension_misc::kChromeAppId));
   DCHECK(it != pinned_apps.end());
   int index = it - pinned_apps.begin();
 
   // We should do here a comparison between the is state and the "want to be"
   // state since some apps might be able to pin but are not yet. Instead - for
   // the time being we clamp against the amount of known items and wait for the
   // next |UpdateAppLaunchersFromPref()| call to correct it - it will come since
   // the pinning will be done then.
   return std::min(model_->item_count(), index);
 }
 
-std::vector<std::string>
-ChromeLauncherController::GetListOfPinnedAppsAndBrowser() {
-  // Adding the app list item to the list of items requires that the ID is not
-  // a valid and known ID for the extension system. The ID was constructed that
-  // way - but just to make sure...
-  DCHECK(!app_tab_helper_->IsValidIDForCurrentUser(kAppShelfIdPlaceholder));
-
-  std::vector<std::string> pinned_apps;
-
-  // Get the new incarnation of the list.
-  const base::ListValue* pinned_apps_pref =
-      profile_->GetPrefs()->GetList(prefs::kPinnedLauncherApps);
-
-  const base::ListValue* policy_pinned_apps_pref =
-      profile_->GetPrefs()->GetList(prefs::kPolicyPinnedLauncherApps);
-
-  // Keep track of the addition of the chrome and the app list icon.
-  bool chrome_icon_added = false;
-  bool app_list_icon_added = false;
-  size_t chrome_icon_index = GetChromeIconIndexFromPref();
-
-  // See if the chrome string is already in the pinned list and remove it if
-  // needed.
-  base::Value* chrome_app = ash::CreateAppDict(extension_misc::kChromeAppId);
-  if (chrome_app) {
-    chrome_icon_added = pinned_apps_pref->Find(*chrome_app) !=
-        pinned_apps_pref->end();
-    delete chrome_app;
-  }
-
-  if (policy_pinned_apps_pref) {
-    for (size_t index = 0; index < policy_pinned_apps_pref->GetSize();
-         ++index) {
-      const base::DictionaryValue* app = NULL;
-      std::string app_id;
-      if (policy_pinned_apps_pref->GetDictionary(index, &app) &&
-          app->GetString(ash::kPinnedAppsPrefAppIDPath, &app_id) &&
-          (std::find(pinned_apps.begin(), pinned_apps.end(), app_id) ==
-           pinned_apps.end()))
-        update_pinned_apps(
-            app_id, app_tab_helper_->IsValidIDForCurrentUser(app_id),
-            &pinned_apps, &chrome_icon_added, &app_list_icon_added);
-    }
-  }
-
-  for (size_t index = 0; index < pinned_apps_pref->GetSize(); ++index) {
-    // We need to position the chrome icon relative to it's place in the pinned
-    // preference list - even if an item of that list isn't shown yet.
-    if (index == chrome_icon_index && !chrome_icon_added) {
-      pinned_apps.push_back(extension_misc::kChromeAppId);
-      chrome_icon_added = true;
-    }
-    const base::DictionaryValue* app = NULL;
-    std::string app_id;
-    if (pinned_apps_pref->GetDictionary(index, &app) &&
-        app->GetString(ash::kPinnedAppsPrefAppIDPath, &app_id) &&
-        (std::find(pinned_apps.begin(), pinned_apps.end(), app_id) ==
-             pinned_apps.end())) {
-      bool pinned_by_policy;
-      if (app->GetBoolean(ash::kPinnedAppsPrefPinnedByPolicy,
-                          &pinned_by_policy) &&
-          pinned_by_policy) {
-        continue;
-      }
-      update_pinned_apps(
-          app_id, app_tab_helper_->IsValidIDForCurrentUser(app_id),
-          &pinned_apps, &chrome_icon_added, &app_list_icon_added);
-    }
-  }
-
-  // If not added yet, the chrome item will be the last item in the list.
-  if (!chrome_icon_added)
-    pinned_apps.push_back(extension_misc::kChromeAppId);
-
-  // If not added yet, add the app list item either at the end or at the
-  // beginning - depending on the shelf layout.
-  if (!app_list_icon_added) {
-    pinned_apps.insert(pinned_apps.begin(), kAppShelfIdPlaceholder);
-  }
-  return pinned_apps;
-}
-
 bool ChromeLauncherController::IsIncognito(
     const content::WebContents* web_contents) const {
   const Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   return profile->IsOffTheRecord() && !profile->IsGuestSession() &&
          !profile->IsSystemProfile();
 }
 
 void ChromeLauncherController::CloseWindowedAppsFromRemovedExtension(
     const std::string& app_id,
@@ skipping 27 matching lines @@
   DCHECK_GT(id, 0);
   DCHECK(item_delegate);
   DCHECK(item_delegate_manager_);
   item_delegate_manager_->SetShelfItemDelegate(
       id, std::unique_ptr<ash::ShelfItemDelegate>(item_delegate));
 }
 
 void ChromeLauncherController::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 AppTabHelper or create a new one.
-  if (!app_tab_helper_.get())
-    app_tab_helper_.reset(new LauncherAppTabHelper(profile_));
+  // one for some functions of LauncherControllerHelper or create a new one.
+  if (!launcher_controller_helper_.get())
+    launcher_controller_helper_.reset(new LauncherControllerHelper(profile_));
   else
-    app_tab_helper_->SetCurrentUser(profile_);
+    launcher_controller_helper_->SetCurrentUser(profile_);
   // TODO(skuhne): The AppIconLoaderImpl has the same problem. Each loaded
-  // image is associated with a profile (it's loader requires the profile).
+  // 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 defined(OS_CHROMEOS)
   std::unique_ptr<AppIconLoader> arc_app_icon_loader(new ArcAppIconLoader(
@@ skipping 54 matching lines @@
 
 AppIconLoader* ChromeLauncherController::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;
 }