Enable sync for the settings from the Extension Settings API.

chrome/browser/extensions/extension_settings.h

 // Copyright (c) 2011 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_EXTENSIONS_EXTENSION_SETTINGS_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SETTINGS_H_
 #pragma once
 
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
-#include "chrome/browser/extensions/extension_settings_storage.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/syncable_extension_settings_storage.h"
+#include "chrome/browser/sync/api/syncable_service.h"
 
-// Manages ExtensionSettingsStorage objects for extensions.
-class ExtensionSettings : public base::RefCountedThreadSafe<ExtensionSettings> {
+// Manages ExtensionSettingsStorage objects for extensions, including routing
+// changes from sync to them.
+class ExtensionSettings

[akalin, 2011/09/15 19:56:44]

Say that this lives on the FILE thread, and all methods must be called from
there.

[not at google - send to devlin, 2011/09/16 05:18:59]

Done.

+    : public base::RefCountedThreadSafe<ExtensionSettings>,

[akalin, 2011/09/15 19:56:44]

since this lives on the FILE thread only, shouldn't need to be ref-counted
anymore

[not at google - send to devlin, 2011/09/16 05:18:59]

It seemed easiest to do the RefCountedThreadSafe with DeleteOnFileThread given
the way that the owner of this lives/dies on the UI thread while this has to die
on the FILE thread.

[akalin, 2011/09/16 15:36:40]

See earlier rant about lifetime management.  This class should live completely
on the FILE thread, and any complexity with the owner living on the UI thread
should belong with the owner.

[not at google - send to devlin, 2011/09/19 07:10:46]

See previous comment.

+      public SyncableService {
  public:
   // File path is the base of the extension settings directory.
   // The databases will be at base_path/extension_id.
   explicit ExtensionSettings(const FilePath& base_path);
 
+  // Sets the current ExtensionService, required for GetAllSyncData.
+  // Ownership NOT taken.
+  void SetExtensionService(ExtensionServiceInterface* extension_service);

[akalin, 2011/09/15 19:56:44]

Prefer to make this a constructor arg, since it'll never change

also, prefer const ExtensionServiceInterface* (or even &)

[not at google - send to devlin, 2011/09/16 05:18:59]

Can't make it a ctor argument unfortunately because they're mutually dependent
(an ExtensionService already takes a ExtensionSettings in its ctor).

[akalin, 2011/09/16 15:36:40]

Ugh.  Maybe add a comment?  Although if ExtensionSettings needs access to
ExtensionService, it seems to me that ExtensionService should create the
ExtensionSettings object.

[not at google - send to devlin, 2011/09/19 07:10:46]

Don't need this any more.

+
   // Gets a weak reference to the storage area for a given extension.
   // Must be run on the FILE thread.
   //
   // By default this will be of a cached LEVELDB storage, but on failure to
   // create a leveldb instance will fall back to cached NOOP storage.
-  ExtensionSettingsStorage* GetStorage(const std::string& extension_id);
+  ExtensionSettingsStorage* GetStorage(
+      const std::string& extension_id) const;
 
   // Gets a weak reference to the storage area for a given extension, with a
   // specific type and whether it should be wrapped in a cache.
   //
   // Use this for testing; if the given type fails to be created (e.g. if
   // leveldb creation fails) then a DCHECK will fail.
   ExtensionSettingsStorage* GetStorageForTesting(
       ExtensionSettingsStorage::Type type,
       bool cached,
-      const std::string& extension_id);
+      const std::string& extension_id) const;
+
+  // SyncableService implementation.
+  virtual SyncDataList GetAllSyncData(syncable::ModelType type) const OVERRIDE;
+  virtual SyncError MergeDataAndStartSyncing(
+      syncable::ModelType type,
+      const SyncDataList& initial_sync_data,
+      SyncChangeProcessor* sync_processor) OVERRIDE;
+  virtual SyncError ProcessSyncChanges(
+      const tracked_objects::Location& from_here,
+      const SyncChangeList& change_list) OVERRIDE;
+  virtual void StopSyncing(syncable::ModelType type) OVERRIDE;
 
  private:
   friend class base::RefCountedThreadSafe<ExtensionSettings>;
   virtual ~ExtensionSettings();
 
+  // Gets a weak reference to the storage area for a given extension,
+  // initializing sync with some initial data if sync enabled.
+  //
+  // By default this will be of a cached LEVELDB storage, but on failure to
+  // create a leveldb instance will fall back to cached NOOP storage.
+  SyncableExtensionSettingsStorage* GetOrCreateStorageWithSyncData(
+      const std::string& extension_id, const DictionaryValue& sync_data) const;
+
+  // If a storage area exists in the cache, returns the cached storage area.
+  // Otherwise tries to create one using CreateAndInitStorage.
+  SyncableExtensionSettingsStorage* GetOrCreateAndInitStorage(
+      ExtensionSettingsStorage::Type type,
+      bool cached,
+      const std::string& extension_id,
+      const DictionaryValue& initial_sync_data) const;
+
   // Creates a storage area of a given type, optionally wrapped in a cache.
-  // Returns NULL if creation fails.
-  ExtensionSettingsStorage* CreateStorage(
+  // Returns NULL if creation fails.  Otherwise, adds the new storage area to
+  // the cache and initializes sync if sync is enabled.
+  SyncableExtensionSettingsStorage* CreateAndInitStorage(
+      ExtensionSettingsStorage::Type type,
+      bool cached,
       const std::string& extension_id,
-      ExtensionSettingsStorage::Type type,
-      bool cached);
+      const DictionaryValue& initial_sync_data) const;
+
+  // Appends the sync data from a list of Extensions to a given list.
+  void AppendAllSyncData(
+      SyncDataList* sync_data, const ExtensionList& extensions) const;
 
   // The base file path to create any leveldb databases at.
   const FilePath base_path_;
 
   // A cache of ExtensionSettingsStorage objects that have already been created.
   // Ensure that there is only ever one created per extension.
-  std::map<std::string, ExtensionSettingsStorage*> storage_objs_;
+  mutable
+    std::map<std::string, SyncableExtensionSettingsStorage*> storage_objs_;
+
+  // Current extension service.  Needed in order to list all extensions when
+  // getting all settings for GetAllSyncData().
+  const ExtensionServiceInterface* extension_service_;
+
+  // Current sync processor, if any.
+  SyncChangeProcessor* sync_processor_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionSettings);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SETTINGS_H_