Extension settings API: force through changes that come from sync (ignoring

chrome/browser/extensions/settings/settings_leveldb_storage.cc

 // 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.
 
 #include "chrome/browser/extensions/settings/settings_leveldb_storage.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 146 matching lines @@
 
   if (!it->status().ok()) {
     LOG(ERROR) << "DB iteration failed: " << it->status().ToString();
     return ReadResult(kGenericOnFailureMessage);
   }
 
   return ReadResult(settings.release());
 }
 
 SettingsStorage::WriteResult SettingsLeveldbStorage::Set(
-    const std::string& key, const Value& value) {
+    WriteOptions options, const std::string& key, const Value& value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DictionaryValue settings;
   settings.SetWithoutPathExpansion(key, value.DeepCopy());
-  return Set(settings);
+  return Set(options, settings);
 }
 
 SettingsStorage::WriteResult SettingsLeveldbStorage::Set(
-    const DictionaryValue& settings) {
+    WriteOptions options, const DictionaryValue& settings) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::string value_as_json;
   leveldb::WriteBatch batch;
-  scoped_ptr<SettingChangeList> changes(
-      new SettingChangeList());
+  scoped_ptr<SettingChangeList> changes(new SettingChangeList());
 
   for (DictionaryValue::Iterator it(settings); it.HasNext(); it.Advance()) {
     scoped_ptr<Value> old_value;
     if (!ReadFromDb(leveldb::ReadOptions(), it.key(), &old_value)) {
       return WriteResult(kGenericOnFailureMessage);
     }
 
     if (!old_value.get() || !old_value->Equals(&it.value())) {
       changes->push_back(
           SettingChange(
               it.key(), old_value.release(), it.value().DeepCopy()));
       base::JSONWriter::Write(&it.value(), false, &value_as_json);
       batch.Put(it.key(), value_as_json);
     }
   }
 
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
   if (!status.ok()) {
     LOG(WARNING) << "DB batch write failed: " << status.ToString();
     return WriteResult(kGenericOnFailureMessage);
   }
 
   return WriteResult(changes.release());
 }
 
 SettingsStorage::WriteResult SettingsLeveldbStorage::Remove(
-    const std::string& key) {
+    WriteOptions options, const std::string& key) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   std::vector<std::string> keys;
   keys.push_back(key);
-  return Remove(keys);
+  return Remove(options, keys);
 }
 
 SettingsStorage::WriteResult SettingsLeveldbStorage::Remove(
-    const std::vector<std::string>& keys) {
+    WriteOptions options, const std::vector<std::string>& keys) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   leveldb::WriteBatch batch;
   scoped_ptr<SettingChangeList> changes(
       new SettingChangeList());
 
   for (std::vector<std::string>::const_iterator it = keys.begin();
       it != keys.end(); ++it) {
     scoped_ptr<Value> old_value;
     if (!ReadFromDb(leveldb::ReadOptions(), *it, &old_value)) {
       return WriteResult(kGenericOnFailureMessage);
     }
 
     if (old_value.get()) {
       changes->push_back(
           SettingChange(*it, old_value.release(), NULL));
       batch.Delete(*it);
     }
   }
 
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
   if (!status.ok() && !status.IsNotFound()) {
     LOG(WARNING) << "DB batch delete failed: " << status.ToString();
     return WriteResult(kGenericOnFailureMessage);
   }
 
   return WriteResult(changes.release());
 }
 
-SettingsStorage::WriteResult SettingsLeveldbStorage::Clear() {
+SettingsStorage::WriteResult SettingsLeveldbStorage::Clear(
+    WriteOptions options) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  leveldb::ReadOptions options;
+  leveldb::ReadOptions read_options;
   // All interaction with the db is done on the same thread, so snapshotting
   // isn't strictly necessary.  This is just defensive.
   leveldb::WriteBatch batch;
   scoped_ptr<SettingChangeList> changes(
       new SettingChangeList());
 
   ScopedSnapshot snapshot(db_.get());
-  options.snapshot = snapshot.get();
-  scoped_ptr<leveldb::Iterator> it(db_->NewIterator(options));
+  read_options.snapshot = snapshot.get();
+  scoped_ptr<leveldb::Iterator> it(db_->NewIterator(read_options));
   for (it->SeekToFirst(); it->Valid(); it->Next()) {
     const std::string key = it->key().ToString();
     const std::string old_value_json = it->value().ToString();
     Value* old_value =
         base::JSONReader().JsonToValue(old_value_json, false, false);
     if (old_value) {
       changes->push_back(SettingChange(key, old_value, NULL));
     } else {
       LOG(ERROR) << "Invalid JSON in database: " << old_value_json;
     }
@@ skipping 51 matching lines @@
   it->SeekToFirst();
   bool is_empty = !it->Valid();
   if (!it->status().ok()) {
     LOG(ERROR) << "Checking DB emptiness failed: " << it->status().ToString();
     return false;
   }
   return is_empty;
 }
 
 }  // namespace extensions