Fix import legacy, pref based pins.

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 219 matching lines @@
   }
 
   void AddApp(const AppLauncherId& app_launcher_id) {
     if (HasApp(app_launcher_id))
       return;
     app_list_.push_back(app_launcher_id);
     app_set_.insert(app_launcher_id);
   }
 
   void MaybeAddApp(const AppLauncherId& app_launcher_id,
-                   const LauncherControllerHelper* helper) {
+                   const LauncherControllerHelper* helper,
+                   bool check_for_valid_app) {
     DCHECK_NE(kPinnedAppsPlaceholder, app_launcher_id.ToString());
-    if (!helper->IsValidIDForCurrentUser(app_launcher_id.ToString()))
+    if (check_for_valid_app &&
+        !helper->IsValidIDForCurrentUser(app_launcher_id.ToString())) {
       return;
+    }
     AddApp(app_launcher_id);
   }
 
   void MaybeAddAppFromPref(const base::DictionaryValue* app_pref,
-                           const LauncherControllerHelper* helper) {
+                           const LauncherControllerHelper* helper,
+                           bool check_for_valid_app) {
     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(AppLauncherId(app_id), helper);
+    MaybeAddApp(AppLauncherId(app_id), helper, check_for_valid_app);
   }
 
   const std::vector<AppLauncherId>& app_list() const { return app_list_; }
 
  private:
   std::vector<AppLauncherId> app_list_;
   std::set<AppLauncherId> app_set_;
 };
 
 }  // namespace
@@ skipping 116 matching lines @@
   if (display_id == display::Screen::GetScreen()->GetPrimaryDisplay().id()) {
     // See comment in |kShelfAlignment| as to why we consider two prefs.
     prefs->SetString(prefs::kShelfAlignmentLocal, value);
     prefs->SetString(prefs::kShelfAlignment, value);
   }
 }
 
 // Helper that extracts app list from policy preferences.
 void GetAppsPinnedByPolicy(const PrefService* prefs,
                            const LauncherControllerHelper* helper,
+                           bool check_for_valid_app,
                            AppTracker* apps) {
   DCHECK(apps);
   DCHECK(apps->app_list().empty());
 
   const auto* policy_apps = prefs->GetList(prefs::kPolicyPinnedLauncherApps);
   if (!policy_apps)
     return;
 
   // Obtain here all ids of ARC apps because it takes linear time, and getting
   // them in the loop bellow would lead to quadratic complexity.
@@ skipping 14 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(AppLauncherId(arc_app_id), helper);
+        apps->MaybeAddApp(AppLauncherId(arc_app_id), helper,
+                          check_for_valid_app);
       }
     } else {
-      apps->MaybeAddApp(AppLauncherId(app_id), helper);
+      apps->MaybeAddApp(AppLauncherId(app_id), helper, check_for_valid_app);
     }
   }
 }
 
 std::vector<AppLauncherId> GetPinnedAppsFromPrefsLegacy(
     const PrefService* prefs,
-    const LauncherControllerHelper* helper) {
+    const LauncherControllerHelper* helper,
+    bool check_for_valid_app) {
   // 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.
   std::unique_ptr<base::Value> chrome_app(
       CreateAppDict(AppLauncherId(extension_misc::kChromeAppId)));
 
   AppTracker apps;
-  GetAppsPinnedByPolicy(prefs, helper, &apps);
+  GetAppsPinnedByPolicy(prefs, helper, check_for_valid_app, &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(AppLauncherId(extension_misc::kChromeAppId));
     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);
+    apps.MaybeAddAppFromPref(app_pref, helper, check_for_valid_app);
   }
 
   // If not added yet, the chrome item will be the last item in the list.
   apps.AddApp(AppLauncherId(extension_misc::kChromeAppId));
   return apps.app_list();
 }
 
 // static
 std::unique_ptr<ChromeLauncherPrefsObserver>
 ChromeLauncherPrefsObserver::CreateIfNecessary(Profile* profile) {
@@ skipping 64 matching lines @@
       position = sync_peer.second->item_pin_ordinal;
     }
   }
 
   return position.IsValid() ? position.CreateAfter()
                             : syncer::StringOrdinal::CreateInitialOrdinal();
 }
 
 std::vector<AppLauncherId> ImportLegacyPinnedApps(
     const PrefService* prefs,
-    LauncherControllerHelper* helper,
-    const AppTracker& policy_apps) {
-  std::vector<AppLauncherId> legacy_pins =
-      GetPinnedAppsFromPrefsLegacy(prefs, helper);
-  DCHECK(!legacy_pins.empty());
+    LauncherControllerHelper* helper) {
+  std::vector<AppLauncherId> legacy_pins_all =
+      GetPinnedAppsFromPrefsLegacy(prefs, helper, false);
+  DCHECK(!legacy_pins_all.empty());
 
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(helper->profile());
 
+  std::vector<AppLauncherId> legacy_pins_valid;
   syncer::StringOrdinal last_position =
       syncer::StringOrdinal::CreateInitialOrdinal();
   // Convert to sync item record.
-  for (const auto& app_launcher_id : legacy_pins) {
+  for (const auto& app_launcher_id : legacy_pins_all) {
     DCHECK_NE(kPinnedAppsPlaceholder, app_launcher_id.ToString());
     app_service->SetPinPosition(app_launcher_id.ToString(), last_position);
     last_position = last_position.CreateAfter();
+    if (helper->IsValidIDForCurrentUser(app_launcher_id.ToString()))
+      legacy_pins_valid.push_back(app_launcher_id);
   }
 
   // Now process default apps.
   for (size_t i = 0; i < arraysize(kDefaultPinnedApps); ++i) {
     const std::string& app_id = kDefaultPinnedApps[i];
     // Check if it is already imported.
     if (app_service->GetPinPosition(app_id).IsValid())
       continue;
     // Check if it is present but not in legacy pin.
     if (helper->IsValidIDForCurrentUser(app_id))
       continue;
     app_service->SetPinPosition(app_id, last_position);
     last_position = last_position.CreateAfter();
   }
 
-  return legacy_pins;
+  return legacy_pins_valid;
 }
 
 std::vector<AppLauncherId> GetPinnedAppsFromPrefs(
     const PrefService* prefs,
     LauncherControllerHelper* helper) {
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(helper->profile());
   // Some unit tests may not have it or service may not be initialized.
   if (!app_service || !app_service->IsInitialized())
     return std::vector<AppLauncherId>();
 
   std::vector<PinInfo> pin_infos;
 
-  AppTracker policy_apps;
-  GetAppsPinnedByPolicy(prefs, helper, &policy_apps);
-
   // Empty pins indicates that sync based pin model is used for the first
   // time. In normal workflow we have at least Chrome browser pin info.
   bool first_run = true;
 
   for (const auto& sync_peer : app_service->sync_items()) {
     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;
     }
 
     pin_infos.push_back(PinInfo(AppLauncherId(sync_peer.first),
                                 sync_peer.second->item_pin_ordinal));
   }
 
   if (first_run) {
+    // Return default apps in case profile is not synced yet.
+    sync_preferences::PrefServiceSyncable* const pref_service_syncable =
+        PrefServiceSyncableFromProfile(helper->profile());
+    if (!pref_service_syncable->IsSyncing())
+      return GetPinnedAppsFromPrefsLegacy(prefs, helper, true);
+
     // We need to import legacy pins model and convert it to sync based
     // model.
-    return ImportLegacyPinnedApps(prefs, helper, policy_apps);
+    return ImportLegacyPinnedApps(prefs, helper);
   }
 
   // Sort pins according their ordinals.
   std::sort(pin_infos.begin(), pin_infos.end(), ComparePinInfo());
 
+  AppTracker policy_apps;
+  GetAppsPinnedByPolicy(prefs, helper, true, &policy_apps);
+
   // Pinned by policy apps appear first, if they were not shown before.
   syncer::StringOrdinal front_position = GetFirstPinPosition(helper->profile());
   std::vector<AppLauncherId>::const_reverse_iterator it;
   for (it = policy_apps.app_list().rbegin();
        it != policy_apps.app_list().rend(); ++it) {
     const std::string& app_launcher_id_str = (*it).ToString();
     if (app_launcher_id_str == kPinnedAppsPlaceholder)
       continue;
 
     // Check if we already processed current app.
@@ skipping 91 matching lines @@
     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_launcher_id_str, pin_position);
 }
 
 }  // namespace launcher
 }  // namespace ash