Implement local storage for App List in case app sync is off.

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>
 
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/chromeos/arc/arc_auth_service.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
 #include "chrome/browser/prefs/pref_service_syncable_util.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 #include "chrome/browser/ui/ash/launcher/launcher_controller_helper.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/sync/model/string_ordinal.h"
@@ skipping 235 matching lines @@
     MaybeAddApp(app_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_;
 };
 
+// If sync is running then return position from sync service, otherwise use
+// local copy.
+syncer::StringOrdinal GetPinPosition(
+    app_list::AppListSyncableService* app_service,
+    const std::string& app_id) {
+  DCHECK(app_service);
+  if (app_service->is_active())
+    return app_service->GetPinPosition(app_id);
+
+  const base::DictionaryValue* apps =
+      app_service->profile()->GetPrefs()->GetDictionary(prefs::kShelfPins);
+  DCHECK(apps);
+  std::string position_string;
+  if (!apps->GetString(app_id, &position_string))
+    return syncer::StringOrdinal();
+
+  const syncer::StringOrdinal position(position_string);
+  if (!position.IsValid()) {
+    LOG(ERROR) << "Found wrong pin position " << position_string
+               << " in local copy for " << app_id;
+    return syncer::StringOrdinal();
+  }
+
+  return position;
+}
+
 }  // namespace
 
 const char kPinnedAppsPrefAppIDPath[] = "id";
 const char kPinnedAppsPrefPinnedByPolicy[] = "pinned_by_policy";
 const char kPinnedAppsPlaceholder[] = "AppShelfIDPlaceholder--------";
 
 const char kShelfAutoHideBehaviorAlways[] = "Always";
 const char kShelfAutoHideBehaviorNever[] = "Never";
 
 const char kShelfAlignmentBottom[] = "Bottom";
@@ skipping 17 matching lines @@
                                user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterStringPref(prefs::kShelfAutoHideBehaviorLocal,
                                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);
+  registry->RegisterDictionaryPref(prefs::kShelfPins);
 }
 
 base::DictionaryValue* CreateAppDict(const std::string& app_id) {
   std::unique_ptr<base::DictionaryValue> app_value(new base::DictionaryValue);
   app_value->SetString(kPinnedAppsPrefAppIDPath, app_id);
   return app_value.release();
 }
 
 ShelfAutoHideBehavior GetShelfAutoHideBehaviorPref(PrefService* prefs,
                                                    int64_t display_id) {
@@ skipping 216 matching lines @@
     const PrefService* prefs,
     LauncherControllerHelper* helper,
     const AppTracker& policy_apps) {
   std::vector<std::string> legacy_pins =
       GetPinnedAppsFromPrefsLegacy(prefs, helper);
   DCHECK(!legacy_pins.empty());
 
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(helper->profile());
 
+  // Update pin info in local copy in order to keep it up to date.
+  DictionaryPrefUpdate pref_update(helper->profile()->GetPrefs(),
+                                   prefs::kShelfPins);
+
   syncer::StringOrdinal last_position =
       syncer::StringOrdinal::CreateInitialOrdinal();
   // Convert to sync item record.
   for (const auto& app_id : legacy_pins) {
     DCHECK_NE(kPinnedAppsPlaceholder, app_id);
     app_service->SetPinPosition(app_id, last_position);
+    pref_update->SetString(app_id, last_position.ToInternalValue());
     last_position = last_position.CreateAfter();
   }
 
   // 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())
+    if (GetPinPosition(app_service, 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);
+    pref_update->SetString(app_id, last_position.ToInternalValue());
     last_position = last_position.CreateAfter();
   }
 
   return legacy_pins;
 }
 
+void SavePinnedAppsInLocalCopy(Profile* profile,
+                               const std::vector<PinInfo>& pins) {
+  DictionaryPrefUpdate pref_update(profile->GetPrefs(), prefs::kShelfPins);
+  pref_update->Clear();
+  for (const auto pin : pins) {
+    pref_update->SetString(pin.app_id, pin.item_ordinal.ToInternalValue());
+  }
+}
+
 std::vector<std::string> GetPinnedAppsFromPrefs(
     const PrefService* prefs,
     LauncherControllerHelper* helper) {
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(helper->profile());
   // Some unit tests may not have it.
   if (!app_service)
     return std::vector<std::string>();
 
   std::vector<PinInfo> pin_infos;
 
   AppTracker policy_apps;
   GetAppsPinnedByPolicy(prefs, helper, &policy_apps);
 
+  const base::DictionaryValue* apps_in_local_copy =
+      helper->profile()->GetPrefs()->GetDictionary(prefs::kShelfPins);
+  DCHECK(apps_in_local_copy);
+
   // 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;
+  // In case sync is not started, first run is detected by absence of local
+  // pins copy.
+  bool first_run = apps_in_local_copy->empty();
 
-  for (const auto& sync_peer : app_service->sync_items()) {
-    if (!sync_peer.second->item_pin_ordinal.IsValid())
-      continue;
+  if (app_service->is_active()) {
+    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;
+      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(sync_peer.first, sync_peer.second->item_pin_ordinal));
     }
+  } else {
+    // If sync is not active, use information from local copy.
+    for (base::DictionaryValue::Iterator app(*apps_in_local_copy);
+         !app.IsAtEnd(); app.Advance()) {
+      // Don't include apps that currently do not exist on device.
+      if (app.key() != extension_misc::kChromeAppId &&
+          !helper->IsValidIDForCurrentUser(app.key())) {
+        continue;
+      }
 
-    pin_infos.push_back(
-        PinInfo(sync_peer.first, sync_peer.second->item_pin_ordinal));
+      std::string position_string;
+      app.value().GetAsString(&position_string);
+      const syncer::StringOrdinal position(position_string);
+      if (!position.IsValid()) {
+        NOTREACHED();
+        continue;
+      }

[stevenjb, 2016/10/14 20:27:25]

This should just be:
DCHECK(position.IsValid());

DCHECK / NOTREACHED should only be for situations that are logically impossible
and serve primarily to document the code, and secondarily to catch bugs early if
the logic is somehow incorrect.

If it is logically possible but an error for this to occur, use LOG(ERROR)
instead of NOTREACHED().

[khmel, 2016/10/17 21:10:57]

Yes, I agree with your point of view, thanks for explanation.

+
+      pin_infos.push_back(PinInfo(app.key(), position));
+    }
   }
 
   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())
+    if (GetPinPosition(app_service, app_id).IsValid())
       continue;
 
     // Now move it to the front.
     pin_infos.insert(pin_infos.begin(), PinInfo(app_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()) {
+  if (!GetPinPosition(app_service, extension_misc::kChromeAppId).IsValid()) {
     pin_infos.insert(pin_infos.begin(),
                      PinInfo(extension_misc::kChromeAppId, front_position));
     app_service->SetPinPosition(extension_misc::kChromeAppId, front_position);
   }
 
   if (helper->IsValidIDForCurrentUser(ArcSupportHost::kHostAppId)) {
-    if (!app_service->GetSyncItem(ArcSupportHost::kHostAppId)) {
+    // TODO(khmel) Find the better way to initial pin PlayStore item when sync
+    // is off.

[stevenjb, 2016/10/14 20:27:24]

'find a way' ? It looks like we currently don't handle inserting the play store
item if app list sync is disabled?

[khmel, 2016/10/17 21:10:57]

With new approach this is not required.

+    if (app_service->is_active() &&
+        !app_service->GetSyncItem(ArcSupportHost::kHostAppId)) {
       const syncer::StringOrdinal arc_host_position =
           GetLastPinPosition(helper->profile());
       pin_infos.insert(pin_infos.begin(),
                        PinInfo(ArcSupportHost::kHostAppId, 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;
 
+  // Sync current pins with local copy if required.
+  if (app_service->is_active())
+    SavePinnedAppsInLocalCopy(helper->profile(), pin_infos);
+
   return pins;
 }
 
 void RemovePinPosition(Profile* profile, const std::string& app_id) {
   DCHECK(profile);
   DCHECK(!app_id.empty());
+
+  // Remove pin info from local copy in order to keep it up to date.
+  DictionaryPrefUpdate pref_update(profile->GetPrefs(), prefs::kShelfPins);
+  pref_update->Remove(app_id, nullptr);
+
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(profile);
   app_service->SetPinPosition(app_id, syncer::StringOrdinal());
 }
 
 void SetPinPosition(Profile* profile,
                     const std::string& app_id,
                     const std::string& app_id_before,
                     const std::vector<std::string>& app_ids_after) {
   DCHECK(profile);
   DCHECK(!app_id.empty());
   DCHECK_NE(app_id, app_id_before);
 
   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);
+                            : GetPinPosition(app_service, app_id_before);
   syncer::StringOrdinal position_after;
   for (const auto& app_id_after : app_ids_after) {
     DCHECK_NE(app_id_after, app_id);
     DCHECK_NE(app_id_after, app_id_before);
-    syncer::StringOrdinal position = app_service->GetPinPosition(app_id_after);
+    syncer::StringOrdinal position = GetPinPosition(app_service, app_id_after);
     DCHECK(position.IsValid());
     if (!position.IsValid()) {
       LOG(ERROR) << "Sync pin position was not found for " << app_id_after;
       continue;
     }
     if (!position_before.IsValid() || !position.Equals(position_before)) {
       position_after = position;
       break;
     }
   }
 
   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();
+
+  // Update pin info in local copy in order to keep it up to date.
+  DictionaryPrefUpdate pref_update(profile->GetPrefs(), prefs::kShelfPins);
+  pref_update->SetString(app_id, pin_position.ToInternalValue());
+
   app_service->SetPinPosition(app_id, pin_position);
 }
 
 }  // namespace launcher
 }  // namespace ash