Implement lossy pref behavior for JsonPrefStore.

base/prefs/json_pref_store.cc

 // Copyright (c) 2012 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 "base/prefs/json_pref_store.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 132 matching lines @@
   token.append(filename.AsUTF8Unsafe());
   return worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
       worker_pool->GetNamedSequenceToken(token),
       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 }
 
 JsonPrefStore::JsonPrefStore(
     const base::FilePath& filename,
     const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner,
     scoped_ptr<PrefFilter> pref_filter)
-    : path_(filename),
-      sequenced_task_runner_(sequenced_task_runner),
-      prefs_(new base::DictionaryValue()),
-      read_only_(false),
-      writer_(filename, sequenced_task_runner),
-      pref_filter_(pref_filter.Pass()),
-      initialized_(false),
-      filtering_in_progress_(false),
-      read_error_(PREF_READ_ERROR_NONE),
-      write_count_histogram_(writer_.commit_interval(), path_) {
-  DCHECK(!path_.empty());
+    : JsonPrefStore(filename,
+                    base::FilePath(),
+                    sequenced_task_runner,
+                    pref_filter.Pass()) {
 }
 
 JsonPrefStore::JsonPrefStore(
     const base::FilePath& filename,
     const base::FilePath& alternate_filename,
     const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner,
     scoped_ptr<PrefFilter> pref_filter)
+    : JsonPrefStore(
+          filename,
+          alternate_filename,
+          sequenced_task_runner,
+          scoped_ptr<base::ImportantFileWriter>(
+              new base::ImportantFileWriterImpl(filename,
+                                                sequenced_task_runner)),
+          pref_filter.Pass()) {
+}
+
+JsonPrefStore::JsonPrefStore(
+    const base::FilePath& filename,
+    const base::FilePath& alternate_filename,
+    const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner,
+    scoped_ptr<base::ImportantFileWriter> file_writer,
+    scoped_ptr<PrefFilter> pref_filter)
     : path_(filename),
       alternate_path_(alternate_filename),
       sequenced_task_runner_(sequenced_task_runner),
       prefs_(new base::DictionaryValue()),
       read_only_(false),
-      writer_(filename, sequenced_task_runner),
+      writer_(file_writer.Pass()),
       pref_filter_(pref_filter.Pass()),
       initialized_(false),
       filtering_in_progress_(false),
       read_error_(PREF_READ_ERROR_NONE),
-      write_count_histogram_(writer_.commit_interval(), path_) {
+      write_count_histogram_(writer_->CommitInterval(), path_) {
   DCHECK(!path_.empty());
 }
 
 bool JsonPrefStore::GetValue(const std::string& key,
                              const base::Value** result) const {
   DCHECK(CalledOnValidThread());
 
   base::Value* tmp = NULL;
   if (!prefs_->Get(key, &tmp))
     return false;
@@ skipping 53 matching lines @@
                                      base::Value* value,
                                      uint32 flags) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(value);
   scoped_ptr<base::Value> new_value(value);
   base::Value* old_value = NULL;
   prefs_->Get(key, &old_value);
   if (!old_value || !value->Equals(old_value)) {
     prefs_->Set(key, new_value.release());
-    if (!read_only_)
-      writer_.ScheduleWrite(this);
+    ScheduleWrite(flags);
   }
 }
 
 void JsonPrefStore::RemoveValue(const std::string& key, uint32 flags) {
   DCHECK(CalledOnValidThread());
 
   if (prefs_->RemovePath(key, NULL))
     ReportValueChanged(key, flags);
 }
 
 void JsonPrefStore::RemoveValueSilently(const std::string& key, uint32 flags) {
   DCHECK(CalledOnValidThread());
 
   prefs_->RemovePath(key, NULL);
-  if (!read_only_)
-    writer_.ScheduleWrite(this);
+  ScheduleWrite(flags);
 }
 
 bool JsonPrefStore::ReadOnly() const {
   DCHECK(CalledOnValidThread());
 
   return read_only_;
 }
 
 PersistentPrefStore::PrefReadError JsonPrefStore::GetReadError() const {
   DCHECK(CalledOnValidThread());
@@ skipping 19 matching lines @@
   base::PostTaskAndReplyWithResult(
       sequenced_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ReadPrefsFromDisk, path_, alternate_path_),
       base::Bind(&JsonPrefStore::OnFileRead, AsWeakPtr()));
 }
 
 void JsonPrefStore::CommitPendingWrite() {
   DCHECK(CalledOnValidThread());
 
-  if (writer_.HasPendingWrite() && !read_only_)
-    writer_.DoScheduledWrite();
+  // Schedule a write for any lossy writes that are outstanding to ensure that
+  // they get flushed when this function is called.
+  if (pending_lossy_write_)
+    writer_->ScheduleWrite(this);
+
+  if (writer_->HasPendingWrite() && !read_only_)
+    writer_->DoScheduledWrite();
 }
 
 void JsonPrefStore::ReportValueChanged(const std::string& key, uint32 flags) {
   DCHECK(CalledOnValidThread());
 
   if (pref_filter_)
     pref_filter_->FilterUpdate(key);
 
   FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key));
 
-  if (!read_only_)
-    writer_.ScheduleWrite(this);
+  ScheduleWrite(flags);
 }
 
 void JsonPrefStore::RegisterOnNextSuccessfulWriteCallback(
     const base::Closure& on_next_successful_write) {
   DCHECK(CalledOnValidThread());
 
-  writer_.RegisterOnNextSuccessfulWriteCallback(on_next_successful_write);
+  writer_->RegisterOnNextSuccessfulWriteCallback(on_next_successful_write);
 }
 
 void JsonPrefStore::OnFileRead(scoped_ptr<ReadResult> read_result) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(read_result);
 
   scoped_ptr<base::DictionaryValue> unfiltered_prefs(new base::DictionaryValue);
 
   read_error_ = read_result->error;
@@ skipping 51 matching lines @@
   }
 }
 
 JsonPrefStore::~JsonPrefStore() {
   CommitPendingWrite();
 }
 
 bool JsonPrefStore::SerializeData(std::string* output) {
   DCHECK(CalledOnValidThread());
 
+  pending_lossy_write_ = false;
+
   write_count_histogram_.RecordWriteOccured();
 
   if (pref_filter_)
     pref_filter_->FilterSerializeData(prefs_.get());
 
   JSONStringValueSerializer serializer(output);
   // Not pretty-printing prefs shrinks pref file size by ~30%. To obtain
   // readable prefs for debugging purposes, you can dump your prefs into any
   // command-line or online JSON pretty printing tool.
   serializer.set_pretty_print(false);
@@ skipping 11 matching lines @@
     FOR_EACH_OBSERVER(PrefStore::Observer,
                       observers_,
                       OnInitializationCompleted(false));
     return;
   }
 
   prefs_ = prefs.Pass();
 
   initialized_ = true;
 
-  if (schedule_write && !read_only_)
-    writer_.ScheduleWrite(this);
+  if (schedule_write)
+    ScheduleWrite(DEFAULT_PREF_WRITE_FLAGS);
 
   if (error_delegate_ && read_error_ != PREF_READ_ERROR_NONE)
     error_delegate_->OnError(read_error_);
 
   FOR_EACH_OBSERVER(PrefStore::Observer,
                     observers_,
                     OnInitializationCompleted(true));
 
   return;
 }
 
+void JsonPrefStore::ScheduleWrite(uint32 flags) {
+  if (read_only_)
+    return;
+
+  if (flags & LOSSY_PREF_WRITE_FLAG)
+    pending_lossy_write_ = true;
+  else
+    writer_->ScheduleWrite(this);
+}
+
 // NOTE: This value should NOT be changed without renaming the histogram
 // otherwise it will create incompatible buckets.
 const int32_t
     JsonPrefStore::WriteCountHistogram::kHistogramWriteReportIntervalMins = 5;
 
 JsonPrefStore::WriteCountHistogram::WriteCountHistogram(
     const base::TimeDelta& commit_interval,
     const base::FilePath& path)
     : WriteCountHistogram(commit_interval,
                           path,
@@ skipping 67 matching lines @@
   DCHECK_EQ(31, num_buckets);
 
   // The histogram below is an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
   // macro adapted to allow for a dynamically suffixed histogram name.
   // Note: The factory creates and owns the histogram.
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
       histogram_name, min_value, max_value, num_buckets,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   return histogram;
 }