src/chrome/browser/extensions/api/storage/sync_storage_backend.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/storage/sync_storage_backend.h"
   6
   7 #include "base/files/file_enumerator.h"
   8 #include "base/logging.h"
   9 #include "chrome/browser/extensions/api/storage/settings_sync_processor.h"
  10 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
  11 #include "chrome/browser/extensions/api/storage/syncable_settings_storage.h"
  12 #include "content/public/browser/browser_thread.h"
  13 #include "sync/api/sync_error_factory.h"
  14
  15 using content::BrowserThread;
  16
  17 namespace extensions {
  18
  19 namespace {
  20
  21 void AddAllSyncData(const std::string& extension_id,
  22                     const base::DictionaryValue& src,
  23                     syncer::ModelType type,
  24                     syncer::SyncDataList* dst) {
  25   for (base::DictionaryValue::Iterator it(src); !it.IsAtEnd(); it.Advance()) {
  26     dst->push_back(settings_sync_util::CreateData(
  27         extension_id, it.key(), it.value(), type));
  28   }
  29 }
  30
  31 }  // namespace
  32
  33 SyncStorageBackend::SyncStorageBackend(
  34     const scoped_refptr<SettingsStorageFactory>& storage_factory,
  35     const base::FilePath& base_path,
  36     const SettingsStorageQuotaEnforcer::Limits& quota,
  37     const scoped_refptr<SettingsObserverList>& observers,
  38     syncer::ModelType sync_type,
  39     const syncer::SyncableService::StartSyncFlare& flare)
  40     : storage_factory_(storage_factory),
  41       base_path_(base_path),
  42       quota_(quota),
  43       observers_(observers),
  44       sync_type_(sync_type),
  45       flare_(flare) {
  46   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  47   DCHECK(sync_type_ == syncer::EXTENSION_SETTINGS ||
  48          sync_type_ == syncer::APP_SETTINGS);
  49 }
  50
  51 SyncStorageBackend::~SyncStorageBackend() {}
  52
  53 ValueStore* SyncStorageBackend::GetStorage(const std::string& extension_id) {
  54   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  55   base::DictionaryValue empty;
  56   return GetOrCreateStorageWithSyncData(extension_id, empty);
  57 }
  58
  59 SyncableSettingsStorage* SyncStorageBackend::GetOrCreateStorageWithSyncData(
  60     const std::string& extension_id,
  61     const base::DictionaryValue& sync_data) const {
  62   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  63
  64   StorageObjMap::iterator maybe_storage = storage_objs_.find(extension_id);
  65   if (maybe_storage != storage_objs_.end()) {
  66     return maybe_storage->second.get();
  67   }
  68
  69   scoped_ptr<SettingsStorageQuotaEnforcer> storage(
  70       new SettingsStorageQuotaEnforcer(
  71           quota_, storage_factory_->Create(base_path_, extension_id)));
  72
  73   // It's fine to create the quota enforcer underneath the sync layer, since
  74   // sync will only go ahead if each underlying storage operation succeeds.
  75   linked_ptr<SyncableSettingsStorage> syncable_storage(
  76       new SyncableSettingsStorage(
  77           observers_, extension_id, storage.release(), sync_type_, flare_));
  78   storage_objs_[extension_id] = syncable_storage;
  79
  80   if (sync_processor_.get()) {
  81     syncer::SyncError error = syncable_storage->StartSyncing(
  82         sync_data, CreateSettingsSyncProcessor(extension_id).Pass());
  83     if (error.IsSet())
  84       syncable_storage.get()->StopSyncing();
  85   }
  86   return syncable_storage.get();
  87 }
  88
  89 void SyncStorageBackend::DeleteStorage(const std::string& extension_id) {
  90   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
  91
  92   // Clear settings when the extension is uninstalled.  Leveldb implementations
  93   // will also delete the database from disk when the object is destroyed as a
  94   // result of being removed from |storage_objs_|.
  95   //
  96   // TODO(kalman): always GetStorage here (rather than only clearing if it
  97   // exists) since the storage area may have been unloaded, but we still want
  98   // to clear the data from disk.
  99   // However, this triggers http://crbug.com/111072.
 100   StorageObjMap::iterator maybe_storage = storage_objs_.find(extension_id);
 101   if (maybe_storage == storage_objs_.end())
 102     return;
 103   maybe_storage->second->Clear();
 104   storage_objs_.erase(extension_id);
 105 }
 106
 107 std::set<std::string> SyncStorageBackend::GetKnownExtensionIDs() const {
 108   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 109   std::set<std::string> result;
 110
 111   // Storage areas can be in-memory as well as on disk. |storage_objs_| will
 112   // contain all that are in-memory.
 113   for (StorageObjMap::iterator it = storage_objs_.begin();
 114        it != storage_objs_.end();
 115        ++it) {
 116     result.insert(it->first);
 117   }
 118
 119   // Leveldb databases are directories inside |base_path_|.
 120   base::FileEnumerator extension_dirs(
 121       base_path_, false, base::FileEnumerator::DIRECTORIES);
 122   while (!extension_dirs.Next().empty()) {
 123     base::FilePath extension_dir = extension_dirs.GetInfo().GetName();
 124     DCHECK(!extension_dir.IsAbsolute());
 125     // Extension IDs are created as std::strings so they *should* be ASCII.
 126     std::string maybe_as_ascii(extension_dir.MaybeAsASCII());
 127     if (!maybe_as_ascii.empty()) {
 128       result.insert(maybe_as_ascii);
 129     }
 130   }
 131
 132   return result;
 133 }
 134
 135 syncer::SyncDataList SyncStorageBackend::GetAllSyncData(syncer::ModelType type)
 136     const {
 137   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 138   // Ignore the type, it's just for sanity checking; assume that whatever base
 139   // path we're constructed with is correct for the sync type.
 140   DCHECK(type == syncer::EXTENSION_SETTINGS || type == syncer::APP_SETTINGS);
 141
 142   // For all extensions, get all their settings.  This has the effect
 143   // of bringing in the entire state of extension settings in memory; sad.
 144   syncer::SyncDataList all_sync_data;
 145   std::set<std::string> known_extension_ids(GetKnownExtensionIDs());
 146
 147   for (std::set<std::string>::const_iterator it = known_extension_ids.begin();
 148        it != known_extension_ids.end();
 149        ++it) {
 150     ValueStore::ReadResult maybe_settings =
 151         GetOrCreateStorageWithSyncData(*it, base::DictionaryValue())->Get();
 152     if (maybe_settings->HasError()) {
 153       LOG(WARNING) << "Failed to get settings for " << *it << ": "
 154                    << maybe_settings->error().message;
 155       continue;
 156     }
 157     AddAllSyncData(*it, maybe_settings->settings(), type, &all_sync_data);
 158   }
 159
 160   return all_sync_data;
 161 }
 162
 163 syncer::SyncMergeResult SyncStorageBackend::MergeDataAndStartSyncing(
 164     syncer::ModelType type,
 165     const syncer::SyncDataList& initial_sync_data,
 166     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
 167     scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
 168   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 169   DCHECK_EQ(sync_type_, type);
 170   DCHECK(!sync_processor_.get());
 171   DCHECK(sync_processor.get());
 172   DCHECK(sync_error_factory.get());
 173
 174   sync_processor_ = sync_processor.Pass();
 175   sync_error_factory_ = sync_error_factory.Pass();
 176
 177   // Group the initial sync data by extension id.
 178   std::map<std::string, linked_ptr<base::DictionaryValue> > grouped_sync_data;
 179   for (syncer::SyncDataList::const_iterator it = initial_sync_data.begin();
 180        it != initial_sync_data.end();
 181        ++it) {
 182     SettingSyncData data(*it);
 183     linked_ptr<base::DictionaryValue> sync_data =
 184         grouped_sync_data[data.extension_id()];
 185     if (!sync_data.get()) {
 186       sync_data =
 187           linked_ptr<base::DictionaryValue>(new base::DictionaryValue());
 188       grouped_sync_data[data.extension_id()] = sync_data;
 189     }
 190     DCHECK(!sync_data->HasKey(data.key())) << "Duplicate settings for "
 191                                            << data.extension_id() << "/"
 192                                            << data.key();
 193     sync_data->SetWithoutPathExpansion(data.key(), data.value().DeepCopy());
 194   }
 195
 196   // Start syncing all existing storage areas.  Any storage areas created in
 197   // the future will start being synced as part of the creation process.
 198   for (StorageObjMap::iterator it = storage_objs_.begin();
 199        it != storage_objs_.end();
 200        ++it) {
 201     std::map<std::string, linked_ptr<base::DictionaryValue> >::iterator
 202         maybe_sync_data = grouped_sync_data.find(it->first);
 203     syncer::SyncError error;
 204     if (maybe_sync_data != grouped_sync_data.end()) {
 205       error = it->second->StartSyncing(
 206           *maybe_sync_data->second,
 207           CreateSettingsSyncProcessor(it->first).Pass());
 208       grouped_sync_data.erase(it->first);
 209     } else {
 210       base::DictionaryValue empty;
 211       error = it->second->StartSyncing(
 212           empty, CreateSettingsSyncProcessor(it->first).Pass());
 213     }
 214     if (error.IsSet())
 215       it->second->StopSyncing();
 216   }
 217
 218   // Eagerly create and init the rest of the storage areas that have sync data.
 219   // Under normal circumstances (i.e. not first-time sync) this will be all of
 220   // them.
 221   for (std::map<std::string, linked_ptr<base::DictionaryValue> >::iterator it =
 222            grouped_sync_data.begin();
 223        it != grouped_sync_data.end();
 224        ++it) {
 225     GetOrCreateStorageWithSyncData(it->first, *it->second);
 226   }
 227
 228   return syncer::SyncMergeResult(type);
 229 }
 230
 231 syncer::SyncError SyncStorageBackend::ProcessSyncChanges(
 232     const tracked_objects::Location& from_here,
 233     const syncer::SyncChangeList& sync_changes) {
 234   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 235   DCHECK(sync_processor_.get());
 236
 237   // Group changes by extension, to pass all changes in a single method call.
 238   std::map<std::string, SettingSyncDataList> grouped_sync_data;
 239   for (syncer::SyncChangeList::const_iterator it = sync_changes.begin();
 240        it != sync_changes.end();
 241        ++it) {
 242     SettingSyncData data(*it);
 243     grouped_sync_data[data.extension_id()].push_back(data);
 244   }
 245
 246   // Create any storage areas that don't exist yet but have sync data.
 247   base::DictionaryValue empty;
 248   for (std::map<std::string, SettingSyncDataList>::iterator it =
 249            grouped_sync_data.begin();
 250        it != grouped_sync_data.end();
 251        ++it) {
 252     SyncableSettingsStorage* storage =
 253         GetOrCreateStorageWithSyncData(it->first, empty);
 254     syncer::SyncError error = storage->ProcessSyncChanges(it->second);
 255     if (error.IsSet())
 256       storage->StopSyncing();
 257   }
 258
 259   return syncer::SyncError();
 260 }
 261
 262 void SyncStorageBackend::StopSyncing(syncer::ModelType type) {
 263   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 264   DCHECK(type == syncer::EXTENSION_SETTINGS || type == syncer::APP_SETTINGS);
 265   DCHECK_EQ(sync_type_, type);
 266
 267   for (StorageObjMap::iterator it = storage_objs_.begin();
 268        it != storage_objs_.end();
 269        ++it) {
 270     // Some storage areas may have already stopped syncing if they had areas
 271     // and syncing was disabled, but StopSyncing is safe to call multiple times.
 272     it->second->StopSyncing();
 273   }
 274
 275   sync_processor_.reset();
 276   sync_error_factory_.reset();
 277 }
 278
 279 scoped_ptr<SettingsSyncProcessor>
 280 SyncStorageBackend::CreateSettingsSyncProcessor(const std::string& extension_id)
 281     const {
 282   CHECK(sync_processor_.get());
 283   return scoped_ptr<SettingsSyncProcessor>(new SettingsSyncProcessor(
 284       extension_id, sync_type_, sync_processor_.get()));
 285 }
 286
 287 }  // namespace extensions