Home | History | Annotate | Download | only in storage 
      1 // Copyright (c) 2012 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/syncable_settings_storage.h"
      6 
      7 #include "base/strings/stringprintf.h"
      8 #include "chrome/browser/extensions/api/storage/settings_sync_processor.h"
      9 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
     10 #include "content/public/browser/browser_thread.h"
     11 #include "extensions/browser/api/storage/settings_namespace.h"
     12 #include "sync/api/sync_data.h"
     13 #include "sync/protocol/extension_setting_specifics.pb.h"
     14 
     15 namespace extensions {
     16 
     17 using content::BrowserThread;
     18 
     19 SyncableSettingsStorage::SyncableSettingsStorage(
     20     const scoped_refptr<ObserverListThreadSafe<SettingsObserver> >&
     21         observers,
     22     const std::string& extension_id,
     23     ValueStore* delegate,
     24     syncer::ModelType sync_type,
     25     const syncer::SyncableService::StartSyncFlare& flare)
     26     : observers_(observers),
     27       extension_id_(extension_id),
     28       delegate_(delegate),
     29       sync_type_(sync_type),
     30       flare_(flare) {
     31   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     32 }
     33 
     34 SyncableSettingsStorage::~SyncableSettingsStorage() {
     35   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     36 }
     37 
     38 size_t SyncableSettingsStorage::GetBytesInUse(const std::string& key) {
     39   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     40   return delegate_->GetBytesInUse(key);
     41 }
     42 
     43 size_t SyncableSettingsStorage::GetBytesInUse(
     44     const std::vector<std::string>& keys) {
     45   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     46   return delegate_->GetBytesInUse(keys);
     47 }
     48 
     49 size_t SyncableSettingsStorage::GetBytesInUse() {
     50   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     51   return delegate_->GetBytesInUse();
     52 }
     53 
     54 ValueStore::ReadResult SyncableSettingsStorage::Get(
     55     const std::string& key) {
     56   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     57   return delegate_->Get(key);
     58 }
     59 
     60 ValueStore::ReadResult SyncableSettingsStorage::Get(
     61     const std::vector<std::string>& keys) {
     62   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     63   return delegate_->Get(keys);
     64 }
     65 
     66 ValueStore::ReadResult SyncableSettingsStorage::Get() {
     67   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     68   return delegate_->Get();
     69 }
     70 
     71 ValueStore::WriteResult SyncableSettingsStorage::Set(
     72     WriteOptions options, const std::string& key, const base::Value& value) {
     73   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     74   WriteResult result = delegate_->Set(options, key, value);
     75   if (result->HasError()) {
     76     return result.Pass();
     77   }
     78   SyncResultIfEnabled(result);
     79   return result.Pass();
     80 }
     81 
     82 ValueStore::WriteResult SyncableSettingsStorage::Set(
     83     WriteOptions options, const base::DictionaryValue& values) {
     84   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     85   WriteResult result = delegate_->Set(options, values);
     86   if (result->HasError()) {
     87     return result.Pass();
     88   }
     89   SyncResultIfEnabled(result);
     90   return result.Pass();
     91 }
     92 
     93 ValueStore::WriteResult SyncableSettingsStorage::Remove(
     94     const std::string& key) {
     95   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     96   WriteResult result = delegate_->Remove(key);
     97   if (result->HasError()) {
     98     return result.Pass();
     99   }
    100   SyncResultIfEnabled(result);
    101   return result.Pass();
    102 }
    103 
    104 ValueStore::WriteResult SyncableSettingsStorage::Remove(
    105     const std::vector<std::string>& keys) {
    106   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
    107   WriteResult result = delegate_->Remove(keys);
    108   if (result->HasError()) {
    109     return result.Pass();
    110   }
    111   SyncResultIfEnabled(result);
    112   return result.Pass();
    113 }
    114 
    115 ValueStore::WriteResult SyncableSettingsStorage::Clear() {
    116   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
    117   WriteResult result = delegate_->Clear();
    118   if (result->HasError()) {
    119     return result.Pass();
    120   }
    121   SyncResultIfEnabled(result);
    122   return result.Pass();
    123 }
    124 
    125 bool SyncableSettingsStorage::Restore() {
    126   // If we're syncing, stop - we don't want to push the deletion of any data.
    127   // At next startup, when we start up the sync service, we'll get back any
    128   // data which was stored intact on Sync.
    129   // TODO (rdevlin.cronin): Investigate if there's a way we can trigger
    130   // MergeDataAndStartSyncing() to immediately get back any data we can,
    131   // and continue syncing.
    132   StopSyncing();
    133   return delegate_->Restore();
    134 }
    135 
    136 bool SyncableSettingsStorage::RestoreKey(const std::string& key) {
    137   // If we're syncing, stop - we don't want to push the deletion of any data.
    138   // At next startup, when we start up the sync service, we'll get back any
    139   // data which was stored intact on Sync.
    140   // TODO (rdevlin.cronin): Investigate if there's a way we can trigger
    141   // MergeDataAndStartSyncing() to immediately get back any data we can,
    142   // and continue syncing.
    143   StopSyncing();
    144   return delegate_->RestoreKey(key);
    145 }
    146 
    147 void SyncableSettingsStorage::SyncResultIfEnabled(
    148     const ValueStore::WriteResult& result) {
    149   if (result->changes().empty())
    150     return;
    151 
    152   if (sync_processor_.get()) {
    153     syncer::SyncError error = sync_processor_->SendChanges(result->changes());
    154     if (error.IsSet())
    155       StopSyncing();
    156   } else {
    157     // Tell sync to try and start soon, because syncable changes to sync_type_
    158     // have started happening. This will cause sync to call us back
    159     // asynchronously via StartSyncing(...) as soon as possible.
    160     flare_.Run(sync_type_);
    161   }
    162 }
    163 
    164 // Sync-related methods.
    165 
    166 syncer::SyncError SyncableSettingsStorage::StartSyncing(
    167     const base::DictionaryValue& sync_state,
    168     scoped_ptr<SettingsSyncProcessor> sync_processor) {
    169   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
    170   DCHECK(!sync_processor_.get());
    171 
    172   sync_processor_ = sync_processor.Pass();
    173   sync_processor_->Init(sync_state);
    174 
    175   ReadResult maybe_settings = delegate_->Get();
    176   if (maybe_settings->HasError()) {
    177     return syncer::SyncError(
    178         FROM_HERE,
    179         syncer::SyncError::DATATYPE_ERROR,
    180         base::StringPrintf("Failed to get settings: %s",
    181             maybe_settings->error().message.c_str()),
    182         sync_processor_->type());
    183   }
    184 
    185   const base::DictionaryValue& settings = maybe_settings->settings();
    186   return sync_state.empty() ?
    187       SendLocalSettingsToSync(settings) :
    188       OverwriteLocalSettingsWithSync(sync_state, settings);
    189 }
    190 
    191 syncer::SyncError SyncableSettingsStorage::SendLocalSettingsToSync(
    192     const base::DictionaryValue& settings) {
    193   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
    194 
    195   ValueStoreChangeList changes;
    196   for (base::DictionaryValue::Iterator i(settings); !i.IsAtEnd(); i.Advance()) {
    197     changes.push_back(ValueStoreChange(i.key(), NULL, i.value().DeepCopy()));
    198   }
    199 
    200   if (changes.empty())
    201     return syncer::SyncError();
    202 
    203   syncer::SyncError error = sync_processor_->SendChanges(changes);
    204   if (error.IsSet())
    205     StopSyncing();
    206 
    207   return error;
    208 }
    209 
    210 syncer::SyncError SyncableSettingsStorage::OverwriteLocalSettingsWithSync(
    211     const base::DictionaryValue& sync_state,
    212     const base::DictionaryValue& settings) {
    213   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
    214   // Treat this as a list of changes to sync and use ProcessSyncChanges.
    215   // This gives notifications etc for free.
    216   scoped_ptr<base::DictionaryValue> new_sync_state(sync_state.DeepCopy());
    217 
    218   SettingSyncDataList changes;
    219   for (base::DictionaryValue::Iterator it(settings);
    220        !it.IsAtEnd(); it.Advance()) {
    221     scoped_ptr<base::Value> sync_value;
    222     if (new_sync_state->RemoveWithoutPathExpansion(it.key(), &sync_value)) {
    223       if (sync_value->Equals(&it.value())) {
    224         // Sync and local values are the same, no changes to send.
    225       } else {
    226         // Sync value is different, update local setting with new value.
    227         changes.push_back(
    228             SettingSyncData(
    229                 syncer::SyncChange::ACTION_UPDATE,
    230                 extension_id_,
    231                 it.key(),
    232                 sync_value.Pass()));
    233       }
    234     } else {
    235       // Not synced, delete local setting.
    236       changes.push_back(
    237           SettingSyncData(
    238               syncer::SyncChange::ACTION_DELETE,
    239               extension_id_,
    240               it.key(),
    241               scoped_ptr<base::Value>(new base::DictionaryValue())));
    242     }
    243   }
    244 
    245   // Add all new settings to local settings.
    246   while (!new_sync_state->empty()) {
    247     base::DictionaryValue::Iterator first_entry(*new_sync_state);
    248     std::string key = first_entry.key();
    249     scoped_ptr<base::Value> value;
    250     CHECK(new_sync_state->RemoveWithoutPathExpansion(key, &value));
    251     changes.push_back(
    252         SettingSyncData(
    253             syncer::SyncChange::ACTION_ADD,
    254             extension_id_,
    255             key,
    256             value.Pass()));
    257   }
    258 
    259   if (changes.empty())
    260     return syncer::SyncError();
    261 
    262   return ProcessSyncChanges(changes);
    263 }
    264 
    265 void SyncableSettingsStorage::StopSyncing() {
    266   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
    267   sync_processor_.reset();
    268 }
    269 
    270 syncer::SyncError SyncableSettingsStorage::ProcessSyncChanges(
    271     const SettingSyncDataList& sync_changes) {
    272   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
    273   DCHECK(!sync_changes.empty()) << "No sync changes for " << extension_id_;
    274 
    275   if (!sync_processor_.get()) {
    276     return syncer::SyncError(
    277         FROM_HERE,
    278         syncer::SyncError::DATATYPE_ERROR,
    279         std::string("Sync is inactive for ") + extension_id_,
    280         syncer::UNSPECIFIED);
    281   }
    282 
    283   std::vector<syncer::SyncError> errors;
    284   ValueStoreChangeList changes;
    285 
    286   for (SettingSyncDataList::const_iterator it = sync_changes.begin();
    287       it != sync_changes.end(); ++it) {
    288     DCHECK_EQ(extension_id_, it->extension_id());
    289 
    290     const std::string& key = it->key();
    291     const base::Value& value = it->value();
    292 
    293     scoped_ptr<base::Value> current_value;
    294     {
    295       ReadResult maybe_settings = Get(it->key());
    296       if (maybe_settings->HasError()) {
    297         errors.push_back(syncer::SyncError(
    298             FROM_HERE,
    299             syncer::SyncError::DATATYPE_ERROR,
    300             base::StringPrintf("Error getting current sync state for %s/%s: %s",
    301                 extension_id_.c_str(), key.c_str(),
    302                 maybe_settings->error().message.c_str()),
    303             sync_processor_->type()));
    304         continue;
    305       }
    306       maybe_settings->settings().RemoveWithoutPathExpansion(key,
    307                                                             &current_value);
    308     }
    309 
    310     syncer::SyncError error;
    311 
    312     switch (it->change_type()) {
    313       case syncer::SyncChange::ACTION_ADD:
    314         if (!current_value.get()) {
    315           error = OnSyncAdd(key, value.DeepCopy(), &changes);
    316         } else {
    317           // Already a value; hopefully a local change has beaten sync in a
    318           // race and it's not a bug, so pretend it's an update.
    319           LOG(WARNING) << "Got add from sync for existing setting " <<
    320               extension_id_ << "/" << key;
    321           error = OnSyncUpdate(
    322               key, current_value.release(), value.DeepCopy(), &changes);
    323         }
    324         break;
    325 
    326       case syncer::SyncChange::ACTION_UPDATE:
    327         if (current_value.get()) {
    328           error = OnSyncUpdate(
    329               key, current_value.release(), value.DeepCopy(), &changes);
    330         } else {
    331           // Similarly, pretend it's an add.
    332           LOG(WARNING) << "Got update from sync for nonexistent setting" <<
    333               extension_id_ << "/" << key;
    334           error = OnSyncAdd(key, value.DeepCopy(), &changes);
    335         }
    336         break;
    337 
    338       case syncer::SyncChange::ACTION_DELETE:
    339         if (current_value.get()) {
    340           error = OnSyncDelete(key, current_value.release(), &changes);
    341         } else {
    342           // Similarly, ignore it.
    343           LOG(WARNING) << "Got delete from sync for nonexistent setting " <<
    344               extension_id_ << "/" << key;
    345         }
    346         break;
    347 
    348       default:
    349         NOTREACHED();
    350     }
    351 
    352     if (error.IsSet()) {
    353       errors.push_back(error);
    354     }
    355   }
    356 
    357   sync_processor_->NotifyChanges(changes);
    358 
    359   observers_->Notify(
    360       &SettingsObserver::OnSettingsChanged,
    361       extension_id_,
    362       settings_namespace::SYNC,
    363       ValueStoreChange::ToJson(changes));
    364 
    365   // TODO(kalman): Something sensible with multiple errors.
    366   return errors.empty() ? syncer::SyncError() : errors[0];
    367 }
    368 
    369 syncer::SyncError SyncableSettingsStorage::OnSyncAdd(
    370     const std::string& key,
    371     base::Value* new_value,
    372     ValueStoreChangeList* changes) {
    373   DCHECK(new_value);
    374   WriteResult result = delegate_->Set(IGNORE_QUOTA, key, *new_value);
    375   if (result->HasError()) {
    376     return syncer::SyncError(
    377         FROM_HERE,
    378         syncer::SyncError::DATATYPE_ERROR,
    379         base::StringPrintf("Error pushing sync add to local settings: %s",
    380             result->error().message.c_str()),
    381         sync_processor_->type());
    382   }
    383   changes->push_back(ValueStoreChange(key, NULL, new_value));
    384   return syncer::SyncError();
    385 }
    386 
    387 syncer::SyncError SyncableSettingsStorage::OnSyncUpdate(
    388     const std::string& key,
    389     base::Value* old_value,
    390     base::Value* new_value,
    391     ValueStoreChangeList* changes) {
    392   DCHECK(old_value);
    393   DCHECK(new_value);
    394   WriteResult result = delegate_->Set(IGNORE_QUOTA, key, *new_value);
    395   if (result->HasError()) {
    396     return syncer::SyncError(
    397         FROM_HERE,
    398         syncer::SyncError::DATATYPE_ERROR,
    399         base::StringPrintf("Error pushing sync update to local settings: %s",
    400             result->error().message.c_str()),
    401         sync_processor_->type());
    402   }
    403   changes->push_back(ValueStoreChange(key, old_value, new_value));
    404   return syncer::SyncError();
    405 }
    406 
    407 syncer::SyncError SyncableSettingsStorage::OnSyncDelete(
    408     const std::string& key,
    409     base::Value* old_value,
    410     ValueStoreChangeList* changes) {
    411   DCHECK(old_value);
    412   WriteResult result = delegate_->Remove(key);
    413   if (result->HasError()) {
    414     return syncer::SyncError(
    415         FROM_HERE,
    416         syncer::SyncError::DATATYPE_ERROR,
    417         base::StringPrintf("Error pushing sync remove to local settings: %s",
    418             result->error().message.c_str()),
    419         sync_processor_->type());
    420   }
    421   changes->push_back(ValueStoreChange(key, old_value, NULL));
    422   return syncer::SyncError();
    423 }
    424 
    425 }  // namespace extensions
    426