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

chrome/browser/ui/app_list/app_list_syncable_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_APP_LIST_APP_LIST_SYNCABLE_SERVICE_H_
 #define CHROME_BROWSER_UI_APP_LIST_APP_LIST_SYNCABLE_SERVICE_H_
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "build/build_config.h"
 #include "chrome/browser/apps/drive/drive_app_uninstall_sync_service.h"
 #include "chrome/browser/sync/glue/sync_start_util.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/sync/model/string_ordinal.h"
 #include "components/sync/model/sync_change.h"
 #include "components/sync/model/sync_change_processor.h"
 #include "components/sync/model/sync_error_factory.h"
 #include "components/sync/model/syncable_service.h"
 #include "components/sync/protocol/app_list_specifics.pb.h"
 
 #if defined(OS_CHROMEOS)
 class ArcAppModelBuilder;
 #endif
 
 class DriveAppProvider;
 class ExtensionAppModelBuilder;
 class Profile;
 
 namespace extensions {
 class ExtensionSystem;
 }
 
 namespace sync_pb {
 class AppListSpecifics;
 }
 
+namespace user_prefs {
+class PrefRegistrySyncable;
+}
+
 namespace app_list {
 
 class AppListFolderItem;
 class AppListItem;
 class AppListModel;
 
 // Keyed Service that owns, stores, and syncs an AppListModel for a profile.
 class AppListSyncableService : public syncer::SyncableService,
                                public KeyedService,
                                public DriveAppUninstallSyncService {
@@ skipping 22 matching lines @@
   };
 
   using SyncItemMap = std::map<std::string, std::unique_ptr<SyncItem>>;
 
   // Populates the model when |extension_system| is ready.
   AppListSyncableService(Profile* profile,
                          extensions::ExtensionSystem* extension_system);
 
   ~AppListSyncableService() override;
 
+  // Registers prefs to support local storage.
+  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
+
   // Adds |item| to |sync_items_| and |model_|. If a sync item already exists,
   // updates the existing sync item instead.
   void AddItem(std::unique_ptr<AppListItem> app_item);
 
   // Removes sync item matching |id|.
   void RemoveItem(const std::string& id);
 
   // Removes sync item matching |id| after item uninstall.
   void RemoveUninstalledItem(const std::string& id);
 
   // Called when properties of an item may have changed, e.g. default/oem state.
   void UpdateItem(AppListItem* app_item);
 
   // Returns the existing sync item matching |id| or NULL.
   const SyncItem* GetSyncItem(const std::string& id) const;
 
   // Sets the name of the folder for OEM apps.
   void SetOemFolderName(const std::string& name);
 
   // Returns optional pin position for the app specified by |app_id|. If app is
   // not synced or does not have associated pin position then empty ordinal is
   // returned.
   syncer::StringOrdinal GetPinPosition(const std::string& app_id);
 
   // Sets pin position and how it is pinned for the app specified by |app_id|.
   // Empty |item_pin_ordinal| indicates that the app has no pin.
   void SetPinPosition(const std::string& app_id,
                       const syncer::StringOrdinal& item_pin_ordinal);
 
-  // Gets the app list model, building it if it doesn't yet exist.
+  // Gets the app list model.
   AppListModel* GetModel();
 
+  // Returns true if this service was initialized.
+  bool IsInited() const;

[stevenjb, 2016/10/25 16:21:32]

IsInitialized()

+
   // Registers new observers and makes sure that service is started.
   void AddObserverAndStart(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   Profile* profile() { return profile_; }
   size_t GetNumSyncItemsForTest();
   const std::string& GetOemFolderNameForTest() const {
     return oem_folder_name_;
   }
   void ResetDriveAppProviderForTest();
@@ skipping 96 matching lines @@
   std::string FindOrCreateOemFolder();
 
   // Gets the location for the OEM folder. Called when the folder is first
   // created.
   syncer::StringOrdinal GetOemFolderPos();
 
   // Returns true if an extension matching |id| exists and was installed by
   // an OEM (extension->was_installed_by_oem() is true).
   bool AppIsOem(const std::string& id);
 
+  // Initializes sync items from the local storage while sync service is not
+  // enabled.
+  void InitFromLocalStorage();
+
   // Helper that notifies observers that sync model has been updated.
   void NotifyObserversSyncUpdated();
 
+  // Handles model update start/finish.
+  void HandleUpdateStarted();
+  void HandleUpdateFinished();
+
+  // Returns true if extension service is ready.
+  bool IsExtensionServiceReady() const;
+
   Profile* profile_;
   extensions::ExtensionSystem* extension_system_;
   std::unique_ptr<AppListModel> model_;
   std::unique_ptr<ModelObserver> model_observer_;
   std::unique_ptr<ExtensionAppModelBuilder> apps_builder_;
 #if defined(OS_CHROMEOS)
   std::unique_ptr<ArcAppModelBuilder> arc_apps_builder_;
 #endif
   std::unique_ptr<syncer::SyncChangeProcessor> sync_processor_;
   std::unique_ptr<syncer::SyncErrorFactory> sync_error_handler_;
   SyncItemMap sync_items_;
   syncer::SyncableService::StartSyncFlare flare_;
   bool initial_sync_data_processed_;
   bool first_app_list_sync_;
   std::string oem_folder_name_;
 
   // List of observers.
   base::ObserverList<Observer> observer_list_;
 
   // Provides integration with Drive apps.
   std::unique_ptr<DriveAppProvider> drive_app_provider_;
 
+  base::WeakPtrFactory<AppListSyncableService> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(AppListSyncableService);
 };
 
 }  // namespace app_list
 
 #endif  // CHROME_BROWSER_UI_APP_LIST_APP_LIST_SYNCABLE_SERVICE_H_