Add AppLauncherId wrapper for items shown in shelf

chrome/browser/ui/ash/chrome_launcher_prefs.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/chrome_launcher_prefs.h"
 
 #include <stddef.h>
 
 #include <set>
 
@@ skipping 23 matching lines @@
 
 namespace {
 
 // App ID of default pinned apps.
 const char* kDefaultPinnedApps[] = {
     extension_misc::kGmailAppId, extension_misc::kGoogleDocAppId,
     extension_misc::kYoutubeAppId, ArcSupportHost::kHostAppId};
 
 base::ListValue* CreateDefaultPinnedAppsList() {
   std::unique_ptr<base::ListValue> apps(new base::ListValue);
-  for (size_t i = 0; i < arraysize(kDefaultPinnedApps); ++i)
-    apps->Append(CreateAppDict(kDefaultPinnedApps[i]));
+  for (size_t i = 0; i < arraysize(kDefaultPinnedApps); ++i) {
+    AppLauncherId* app_launcher_id = new AppLauncherId(kDefaultPinnedApps[i]);
+    apps->Append(CreateAppDict(app_launcher_id));

[stevenjb, 2016/09/21 16:06:40]

This is leaky!

Just do:
apps->Append(CreateAppDict(AppLauncherId(kDefaultPinnedApps[i])))

(And use const& in CreateAppDict).

[Andra Paraschiv, 2016/09/22 09:23:41]

Done.

+  }
 
   return apps.release();
 }
 
 // Returns the preference value for the display with the given |display_id|.
 // The pref value is stored in |local_path| and |path|, but the pref service may
 // have per-display preferences and the value can be specified by policy.
 // Here is the priority:
 //  * A value managed by policy. This is a single value that applies to all
 //    displays.
@@ skipping 143 matching lines @@
 // copied to |local_path|.
 void PropagatePrefToLocalIfNotSet(
     syncable_prefs::PrefServiceSyncable* pref_service,
     const char* local_path,
     const char* synced_path) {
   if (!pref_service->FindPreference(local_path)->HasUserSetting())
     pref_service->SetString(local_path, pref_service->GetString(synced_path));
 }
 
 struct PinInfo {
-  PinInfo(const std::string& app_id, const syncer::StringOrdinal& item_ordinal)
-      : app_id(app_id), item_ordinal(item_ordinal) {}
+  PinInfo(AppLauncherId* app_launcher_id,
+          const syncer::StringOrdinal& item_ordinal)
+      : app_launcher_id(app_launcher_id->GetAppLauncherID()),
+        item_ordinal(item_ordinal) {}
 
-  std::string app_id;
+  std::string app_launcher_id;

[stevenjb, 2016/09/21 16:06:40]

This should be an AppLauncherId. Only use the string version when necessary,
e.g. when storing the pref.

[Andra Paraschiv, 2016/09/22 09:23:41]

If we change it to AppLauncherId, we should add an assignment operator overload
function for AppLauncherId class and make app_launcher_id string attribute (from
the AppLauncherId class) non-const. Should we include these changes too? 

[stevenjb, 2016/09/27 16:42:36]

I'm not exactly sure what you are asking, but we should be able to store and
copy AppLauncherId.

   syncer::StringOrdinal item_ordinal;
 };
 
 struct ComparePinInfo {
   bool operator()(const PinInfo& pin1, const PinInfo& pin2) {
     return pin1.item_ordinal.LessThan(pin2.item_ordinal);
   }
 };
 
 // Helper class to keep apps in order of appearance and to provide fast way
 // to check if app exists in the list.
 class AppTracker {
  public:
-  bool HasApp(const std::string& app_id) const {
-    return app_set_.find(app_id) != app_set_.end();
+  bool HasApp(AppLauncherId* app_launcher_id) const {
+    return app_set_.find(app_launcher_id->GetAppLauncherID()) != app_set_.end();
   }
 
-  void AddApp(const std::string& app_id) {
-    if (HasApp(app_id))
+  void AddApp(AppLauncherId* app_launcher_id) {
+    if (HasApp(app_launcher_id))
       return;
-    app_list_.push_back(app_id);
-    app_set_.insert(app_id);
+    app_list_.push_back(app_launcher_id->GetAppLauncherID());
+    app_set_.insert(app_launcher_id->GetAppLauncherID());
   }
 
-  void MaybeAddApp(const std::string& app_id,
+  void MaybeAddApp(AppLauncherId* app_launcher_id,
                    const LauncherControllerHelper* helper) {
-    DCHECK_NE(kPinnedAppsPlaceholder, app_id);
-    if (!helper->IsValidIDForCurrentUser(app_id))
+    DCHECK_NE(kPinnedAppsPlaceholder, app_launcher_id->GetAppLauncherID());
+    if (!helper->IsValidIDForCurrentUser(app_launcher_id->GetAppLauncherID()))
       return;
-    AddApp(app_id);
+    AddApp(app_launcher_id);
   }
 
   void MaybeAddAppFromPref(const base::DictionaryValue* app_pref,
                            const LauncherControllerHelper* helper) {
     std::string app_id;
     if (!app_pref->GetString(kPinnedAppsPrefAppIDPath, &app_id)) {
       LOG(ERROR) << "Cannot get app id from app pref entry.";
       return;
     }
 
     if (app_id == kPinnedAppsPlaceholder)
       return;
 
     bool pinned_by_policy = false;
     if (app_pref->GetBoolean(kPinnedAppsPrefPinnedByPolicy,
                              &pinned_by_policy) &&
         pinned_by_policy) {
       return;
     }
 
-    MaybeAddApp(app_id, helper);
+    AppLauncherId* app_launcher_id = new AppLauncherId(app_id);
+    MaybeAddApp(app_launcher_id, helper);
   }
 
   const std::vector<std::string>& app_list() const { return app_list_; }
 
  private:
   std::vector<std::string> app_list_;
   std::set<std::string> app_set_;
 };
 
 }  // namespace
@@ skipping 28 matching lines @@
                                std::string());
   registry->RegisterStringPref(prefs::kShelfAlignment,
                                kShelfAlignmentBottom,
                                user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterStringPref(prefs::kShelfAlignmentLocal, std::string());
   registry->RegisterDictionaryPref(prefs::kShelfPreferences);
   registry->RegisterIntegerPref(prefs::kLogoutDialogDurationMs, 20000);
   registry->RegisterBooleanPref(prefs::kShowLogoutButtonInTray, false);
 }
 
-base::DictionaryValue* CreateAppDict(const std::string& app_id) {
+base::DictionaryValue* CreateAppDict(AppLauncherId* app_launcher_id) {
   std::unique_ptr<base::DictionaryValue> app_value(new base::DictionaryValue);
-  app_value->SetString(kPinnedAppsPrefAppIDPath, app_id);
+  app_value->SetString(kPinnedAppsPrefAppIDPath,
+                       app_launcher_id->GetAppLauncherID());
   return app_value.release();
 }
 
 ShelfAutoHideBehavior GetShelfAutoHideBehaviorPref(PrefService* prefs,
                                                    int64_t display_id) {
   DCHECK_GE(display_id, 0);
 
   // Don't show the shelf in app mode.
   if (chrome::IsRunningInAppMode())
     return SHELF_AUTO_HIDE_ALWAYS_HIDDEN;
@@ skipping 76 matching lines @@
       if (!arc_app_list_pref)
         continue;
 
       // We are dealing with package name, not with 32 characters ID.
       const std::string& arc_package = app_id;
       const std::vector<std::string> activities = GetActivitiesForPackage(
           arc_package, all_arc_app_ids, *arc_app_list_pref);
       for (const auto& activity : activities) {
         const std::string arc_app_id =
             ArcAppListPrefs::GetAppId(arc_package, activity);
-        apps->MaybeAddApp(arc_app_id, helper);
+        AppLauncherId* app_launcher_id = new AppLauncherId(arc_app_id);
+        apps->MaybeAddApp(app_launcher_id, helper);
       }
     } else {
-      apps->MaybeAddApp(app_id, helper);
+      AppLauncherId* app_launcher_id = new AppLauncherId(app_id);
+      apps->MaybeAddApp(app_launcher_id, helper);
     }
   }
 }
 
 std::vector<std::string> GetPinnedAppsFromPrefsLegacy(
     const PrefService* prefs,
     const LauncherControllerHelper* helper) {
   // 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(!helper->IsValidIDForCurrentUser(kPinnedAppsPlaceholder));
 
   const auto* pinned_apps = prefs->GetList(prefs::kPinnedLauncherApps);
 
   // Get the sanitized preference value for the index of the Chrome app icon.
   const size_t chrome_icon_index = std::max<size_t>(
       0, std::min<size_t>(pinned_apps->GetSize(),
                           prefs->GetInteger(prefs::kShelfChromeIconIndex)));
 
   // Check if Chrome is in either of the the preferences lists.
+  AppLauncherId* chrome_app_launcher_id =
+      new AppLauncherId(extension_misc::kChromeAppId);
   std::unique_ptr<base::Value> chrome_app(
-      CreateAppDict(extension_misc::kChromeAppId));
+      CreateAppDict(chrome_app_launcher_id));
 
   AppTracker apps;
   GetAppsPinnedByPolicy(prefs, helper, &apps);
 
   std::string app_id;
   for (size_t i = 0; i < pinned_apps->GetSize(); ++i) {
     // We need to position the chrome icon relative to its place in the pinned
     // preference list - even if an item of that list isn't shown yet.
-    if (i == chrome_icon_index)
-      apps.AddApp(extension_misc::kChromeAppId);
+    if (i == chrome_icon_index) {
+      AppLauncherId* chrome_app_launcher_id =
+          new AppLauncherId(extension_misc::kChromeAppId);
+      apps.AddApp(chrome_app_launcher_id);
+    }
     const base::DictionaryValue* app_pref = nullptr;
     if (!pinned_apps->GetDictionary(i, &app_pref)) {
       LOG(ERROR) << "There is no dictionary for app entry.";
       continue;
     }
     apps.MaybeAddAppFromPref(app_pref, helper);
   }
 
   // If not added yet, the chrome item will be the last item in the list.
-  apps.AddApp(extension_misc::kChromeAppId);
+  apps.AddApp(chrome_app_launcher_id);
   return apps.app_list();
 }
 
 // static
 std::unique_ptr<ChromeLauncherPrefsObserver>
 ChromeLauncherPrefsObserver::CreateIfNecessary(Profile* profile) {
   syncable_prefs::PrefServiceSyncable* prefs =
       PrefServiceSyncableFromProfile(profile);
   if (!prefs->FindPreference(prefs::kShelfAlignmentLocal)->HasUserSetting() ||
       !prefs->FindPreference(prefs::kShelfAutoHideBehaviorLocal)
@@ skipping 123 matching lines @@
     if (!sync_peer.second->item_pin_ordinal.IsValid())
       continue;
 
     first_run = false;
     // Don't include apps that currently do not exist on device.
     if (sync_peer.first != extension_misc::kChromeAppId &&
         !helper->IsValidIDForCurrentUser(sync_peer.first)) {
       continue;
     }
 
+    AppLauncherId* app_launcher_id = new AppLauncherId(sync_peer.first);
     pin_infos.push_back(
-        PinInfo(sync_peer.first, sync_peer.second->item_pin_ordinal));
+        PinInfo(app_launcher_id, sync_peer.second->item_pin_ordinal));
   }
 
   if (first_run) {
     // We need to import legacy pins model and convert it to sync based
     // model.
     return ImportLegacyPinnedApps(prefs, helper, policy_apps);
   }
 
   // Sort pins according their ordinals.
   std::sort(pin_infos.begin(), pin_infos.end(), ComparePinInfo());
 
   // Pinned by policy apps appear first, if they were not shown before.
   syncer::StringOrdinal front_position = GetFirstPinPosition(helper->profile());
   std::vector<std::string>::const_reverse_iterator it;
   for (it = policy_apps.app_list().rbegin();
        it != policy_apps.app_list().rend(); ++it) {
     const std::string& app_id = *it;
     if (app_id == kPinnedAppsPlaceholder)
       continue;
 
     // Check if we already processed current app.
     if (app_service->GetPinPosition(app_id).IsValid())
       continue;
 
     // Now move it to the front.
-    pin_infos.insert(pin_infos.begin(), PinInfo(app_id, front_position));
+    AppLauncherId* app_launcher_id = new AppLauncherId(app_id);
+    pin_infos.insert(pin_infos.begin(),
+                     PinInfo(app_launcher_id, front_position));
     app_service->SetPinPosition(app_id, front_position);
     front_position = front_position.CreateBefore();
   }
 
   // Now insert Chrome browser app if needed.
   if (!app_service->GetPinPosition(extension_misc::kChromeAppId).IsValid()) {
+    AppLauncherId* chrome_app_launcher_id =
+        new AppLauncherId(extension_misc::kChromeAppId);
     pin_infos.insert(pin_infos.begin(),
-                     PinInfo(extension_misc::kChromeAppId, front_position));
+                     PinInfo(chrome_app_launcher_id, front_position));
     app_service->SetPinPosition(extension_misc::kChromeAppId, front_position);
   }
 
   if (helper->IsValidIDForCurrentUser(ArcSupportHost::kHostAppId)) {
     if (!app_service->GetSyncItem(ArcSupportHost::kHostAppId)) {
       const syncer::StringOrdinal arc_host_position =
           GetLastPinPosition(helper->profile());
+      AppLauncherId* app_launcher_id =
+          new AppLauncherId(ArcSupportHost::kHostAppId);
       pin_infos.insert(pin_infos.begin(),
-                       PinInfo(ArcSupportHost::kHostAppId, arc_host_position));
+                       PinInfo(app_launcher_id, arc_host_position));
       app_service->SetPinPosition(ArcSupportHost::kHostAppId,
                                   arc_host_position);
     }
   }
 
   // Convert to string array.
   std::vector<std::string> pins(pin_infos.size());
   for (size_t i = 0; i < pin_infos.size(); ++i)
-    pins[i] = pin_infos[i].app_id;
+    pins[i] = pin_infos[i].app_launcher_id;
 
   return pins;
 }
 
-void RemovePinPosition(Profile* profile, const std::string& app_id) {
+void RemovePinPosition(Profile* profile, AppLauncherId* app_launcher_id) {
   DCHECK(profile);
-  DCHECK(!app_id.empty());
+  const std::string launcher_id = app_launcher_id->GetAppLauncherID();
+  DCHECK(!launcher_id.empty());
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(profile);
-  app_service->SetPinPosition(app_id, syncer::StringOrdinal());
+  app_service->SetPinPosition(launcher_id, syncer::StringOrdinal());
 }
 
 void SetPinPosition(Profile* profile,
-                    const std::string& app_id,
-                    const std::string& app_id_before,
-                    const std::string& app_id_after) {
+                    AppLauncherId* app_launcher_id,
+                    AppLauncherId* app_launcher_id_before,
+                    AppLauncherId* app_launcher_id_after) {
   DCHECK(profile);
-  DCHECK(!app_id.empty());
-  DCHECK_NE(app_id, app_id_before);
-  DCHECK_NE(app_id, app_id_after);
-  DCHECK(app_id_before.empty() || app_id_before != app_id_after);
+  const std::string launcher_id = app_launcher_id->GetAppLauncherID();
+  DCHECK(!launcher_id.empty());
+  const std::string launcher_id_before =
+      app_launcher_id_before->GetAppLauncherID();
+  DCHECK_NE(launcher_id, launcher_id_before);
+  const std::string launcher_id_after =
+      app_launcher_id_after->GetAppLauncherID();
+  DCHECK_NE(launcher_id, launcher_id_after);
+  DCHECK(launcher_id_before.empty() || launcher_id_before != launcher_id_after);
 
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(profile);
   // Some unit tests may not have this service.
   if (!app_service)
     return;
 
   syncer::StringOrdinal position_before =
-      app_id_before.empty() ? syncer::StringOrdinal()
-                            : app_service->GetPinPosition(app_id_before);
+      launcher_id_before.empty()
+          ? syncer::StringOrdinal()
+          : app_service->GetPinPosition(launcher_id_before);
   syncer::StringOrdinal position_after =
-      app_id_after.empty() ? syncer::StringOrdinal()
-                           : app_service->GetPinPosition(app_id_after);
+      launcher_id_after.empty()
+          ? syncer::StringOrdinal()
+          : app_service->GetPinPosition(launcher_id_after);
 
   syncer::StringOrdinal pin_position;
   if (position_before.IsValid() && position_after.IsValid())
     pin_position = position_before.CreateBetween(position_after);
   else if (position_before.IsValid())
     pin_position = position_before.CreateAfter();
   else if (position_after.IsValid())
     pin_position = position_after.CreateBefore();
   else
     pin_position = syncer::StringOrdinal::CreateInitialOrdinal();
-  app_service->SetPinPosition(app_id, pin_position);
+  app_service->SetPinPosition(launcher_id, pin_position);
 }
 
+AppLauncherId::AppLauncherId(const std::string& app_id)
+    : app_launcher_id_(app_id) {}
+
+AppLauncherId::~AppLauncherId() {}
+
 }  // namespace launcher
 }  // namespace ash