Expand the JsonPrefStore's interface to allow for an alternate filename to be specified.

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 19 matching lines @@
  public:
   FileThreadDeserializer(JsonPrefStore* delegate,
                          base::SequencedTaskRunner* sequenced_task_runner)
       : no_dir_(false),
         error_(PersistentPrefStore::PREF_READ_ERROR_NONE),
         delegate_(delegate),
         sequenced_task_runner_(sequenced_task_runner),
         origin_loop_proxy_(base::MessageLoopProxy::current()) {
   }
 
-  void Start(const base::FilePath& path) {
+  void Start(const base::FilePath& path,
+             const base::FilePath& alternate_path) {
     DCHECK(origin_loop_proxy_->BelongsToCurrentThread());
     // TODO(gab): This should use PostTaskAndReplyWithResult instead of using
     // the |error_| member to pass data across tasks.
     sequenced_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&FileThreadDeserializer::ReadFileAndReport,
-                   this, path));
+                   this, path, alternate_path));
   }
 
   // Deserializes JSON on the sequenced task runner.
-  void ReadFileAndReport(const base::FilePath& path) {
+  void ReadFileAndReport(const base::FilePath& path,
+                         const base::FilePath& alternate_path) {
     DCHECK(sequenced_task_runner_->RunsTasksOnCurrentThread());
 
-    value_.reset(DoReading(path, &error_, &no_dir_));
+    value_.reset(DoReading(path, alternate_path, &error_, &no_dir_));
 
     origin_loop_proxy_->PostTask(
         FROM_HERE,
         base::Bind(&FileThreadDeserializer::ReportOnOriginThread, this));
   }
 
   // Reports deserialization result on the origin thread.
   void ReportOnOriginThread() {
     DCHECK(origin_loop_proxy_->BelongsToCurrentThread());
     delegate_->OnFileRead(value_.Pass(), error_, no_dir_);
   }
 
   static base::Value* DoReading(const base::FilePath& path,
+                                const base::FilePath& alternate_path,
                                 PersistentPrefStore::PrefReadError* error,
                                 bool* no_dir) {
+    if (!base::PathExists(path) && !alternate_path.empty() &&
+        base::PathExists(alternate_path)) {
+      base::Move(alternate_path, path);
+    }
+
     int error_code;
     std::string error_msg;
     JSONFileValueSerializer serializer(path);
     base::Value* value = serializer.Deserialize(&error_code, &error_msg);
     HandleErrors(value, path, error_code, error_msg, error);
     *no_dir = !base::PathExists(path.DirName());
     return value;
   }
 
   static void HandleErrors(const base::Value* value,
@@ skipping 80 matching lines @@
       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) {
 }
 
+JsonPrefStore::JsonPrefStore(const base::FilePath& filename,
+                             const base::FilePath& alternate_filename,
+                             base::SequencedTaskRunner* sequenced_task_runner,
+                             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),
+      pref_filter_(pref_filter.Pass()),
+      initialized_(false),
+      filtering_in_progress_(false),
+      read_error_(PREF_READ_ERROR_NONE) {
+}
+
 bool JsonPrefStore::GetValue(const std::string& key,
                              const base::Value** result) const {
   base::Value* tmp = NULL;
   if (!prefs_->Get(key, &tmp))
     return false;
 
   if (result)
     *result = tmp;
   return true;
 }
@@ skipping 65 matching lines @@
 PersistentPrefStore::PrefReadError JsonPrefStore::ReadPrefs() {
   if (path_.empty()) {
     OnFileRead(
         scoped_ptr<base::Value>(), PREF_READ_ERROR_FILE_NOT_SPECIFIED, false);
     return PREF_READ_ERROR_FILE_NOT_SPECIFIED;
   }
 
   PrefReadError error;
   bool no_dir;
   scoped_ptr<base::Value> value(
-      FileThreadDeserializer::DoReading(path_, &error, &no_dir));
+      FileThreadDeserializer::DoReading(path_, alternate_path_, &error,
+                                        &no_dir));
   OnFileRead(value.Pass(), error, no_dir);
   return filtering_in_progress_ ? PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE :
                                   error;
 }
 
 void JsonPrefStore::ReadPrefsAsync(ReadErrorDelegate* error_delegate) {
   initialized_ = false;
   error_delegate_.reset(error_delegate);
   if (path_.empty()) {
     OnFileRead(
         scoped_ptr<base::Value>(), PREF_READ_ERROR_FILE_NOT_SPECIFIED, false);
     return;
   }
 
   // Start async reading of the preferences file. It will delete itself
   // in the end.
   scoped_refptr<FileThreadDeserializer> deserializer(
       new FileThreadDeserializer(this, sequenced_task_runner_.get()));
-  deserializer->Start(path_);
+  deserializer->Start(path_, alternate_path_);
 }
 
 void JsonPrefStore::CommitPendingWrite() {
   if (writer_.HasPendingWrite() && !read_only_)
     writer_.DoScheduledWrite();
 }
 
 void JsonPrefStore::ReportValueChanged(const std::string& key) {
   if (pref_filter_)
     pref_filter_->FilterUpdate(key);
@@ skipping 102 matching lines @@
 
   if (error_delegate_ && read_error_ != PREF_READ_ERROR_NONE)
     error_delegate_->OnError(read_error_);
 
   FOR_EACH_OBSERVER(PrefStore::Observer,
                     observers_,
                     OnInitializationCompleted(true));
 
   return;
 }