base/prefs/json_pref_store.cc

   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 "base/prefs/json_pref_store.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/files/file_path.h"
  12 #include "base/files/file_util.h"
  13 #include "base/json/json_file_value_serializer.h"
  14 #include "base/json/json_string_value_serializer.h"
  15 #include "base/memory/ref_counted.h"
  16 #include "base/metrics/histogram.h"
  17 #include "base/prefs/pref_filter.h"
  18 #include "base/sequenced_task_runner.h"
  19 #include "base/strings/string_util.h"
  20 #include "base/task_runner_util.h"
  21 #include "base/threading/sequenced_worker_pool.h"
  22 #include "base/values.h"
  23
  24 // Result returned from internal read tasks.
  25 struct JsonPrefStore::ReadResult {
  26  public:
  27   ReadResult();
  28   ~ReadResult();
  29
  30   scoped_ptr<base::Value> value;
  31   PrefReadError error;
  32   bool no_dir;
  33
  34  private:
  35   DISALLOW_COPY_AND_ASSIGN(ReadResult);
  36 };
  37
  38 JsonPrefStore::ReadResult::ReadResult()
  39     : error(PersistentPrefStore::PREF_READ_ERROR_NONE), no_dir(false) {
  40 }
  41
  42 JsonPrefStore::ReadResult::~ReadResult() {
  43 }
  44
  45 namespace {
  46
  47 // Some extensions we'll tack on to copies of the Preferences files.
  48 const base::FilePath::CharType kBadExtension[] = FILE_PATH_LITERAL("bad");
  49
  50 PersistentPrefStore::PrefReadError HandleReadErrors(
  51     const base::Value* value,
  52     const base::FilePath& path,
  53     int error_code,
  54     const std::string& error_msg) {
  55   if (!value) {
  56     DVLOG(1) << "Error while loading JSON file: " << error_msg
  57              << ", file: " << path.value();
  58     switch (error_code) {
  59       case JSONFileValueSerializer::JSON_ACCESS_DENIED:
  60         return PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED;
  61         break;
  62       case JSONFileValueSerializer::JSON_CANNOT_READ_FILE:
  63         return PersistentPrefStore::PREF_READ_ERROR_FILE_OTHER;
  64         break;
  65       case JSONFileValueSerializer::JSON_FILE_LOCKED:
  66         return PersistentPrefStore::PREF_READ_ERROR_FILE_LOCKED;
  67         break;
  68       case JSONFileValueSerializer::JSON_NO_SUCH_FILE:
  69         return PersistentPrefStore::PREF_READ_ERROR_NO_FILE;
  70         break;
  71       default:
  72         // JSON errors indicate file corruption of some sort.
  73         // Since the file is corrupt, move it to the side and continue with
  74         // empty preferences.  This will result in them losing their settings.
  75         // We keep the old file for possible support and debugging assistance
  76         // as well as to detect if they're seeing these errors repeatedly.
  77         // TODO(erikkay) Instead, use the last known good file.
  78         base::FilePath bad = path.ReplaceExtension(kBadExtension);
  79
  80         // If they've ever had a parse error before, put them in another bucket.
  81         // TODO(erikkay) if we keep this error checking for very long, we may
  82         // want to differentiate between recent and long ago errors.
  83         bool bad_existed = base::PathExists(bad);
  84         base::Move(path, bad);
  85         return bad_existed ? PersistentPrefStore::PREF_READ_ERROR_JSON_REPEAT
  86                            : PersistentPrefStore::PREF_READ_ERROR_JSON_PARSE;
  87     }
  88   } else if (!value->IsType(base::Value::TYPE_DICTIONARY)) {
  89     return PersistentPrefStore::PREF_READ_ERROR_JSON_TYPE;
  90   }
  91   return PersistentPrefStore::PREF_READ_ERROR_NONE;
  92 }
  93
  94 // Records a sample for |size| in the Settings.JsonDataReadSizeKilobytes
  95 // histogram suffixed with the base name of the JSON file under |path|.
  96 void RecordJsonDataSizeHistogram(const base::FilePath& path, size_t size) {
  97   std::string spaceless_basename;
  98   base::ReplaceChars(path.BaseName().MaybeAsASCII(), " ", "_",
  99                      &spaceless_basename);
 100
 101   // The histogram below is an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
 102   // macro adapted to allow for a dynamically suffixed histogram name.
 103   // Note: The factory creates and owns the histogram.
 104   base::HistogramBase* histogram = base::Histogram::FactoryGet(
 105       "Settings.JsonDataReadSizeKilobytes." + spaceless_basename, 1, 10000, 50,
 106       base::HistogramBase::kUmaTargetedHistogramFlag);
 107   histogram->Add(static_cast<int>(size) / 1024);
 108 }
 109
 110 scoped_ptr<JsonPrefStore::ReadResult> ReadPrefsFromDisk(
 111     const base::FilePath& path,
 112     const base::FilePath& alternate_path) {
 113   if (!base::PathExists(path) && !alternate_path.empty() &&
 114       base::PathExists(alternate_path)) {
 115     base::Move(alternate_path, path);
 116   }
 117
 118   int error_code;
 119   std::string error_msg;
 120   scoped_ptr<JsonPrefStore::ReadResult> read_result(
 121       new JsonPrefStore::ReadResult);
 122   JSONFileValueSerializer serializer(path);
 123   read_result->value.reset(serializer.Deserialize(&error_code, &error_msg));
 124   read_result->error =
 125       HandleReadErrors(read_result->value.get(), path, error_code, error_msg);
 126   read_result->no_dir = !base::PathExists(path.DirName());
 127
 128   if (read_result->error == PersistentPrefStore::PREF_READ_ERROR_NONE)
 129     RecordJsonDataSizeHistogram(path, serializer.get_last_read_size());
 130
 131   return read_result.Pass();
 132 }
 133
 134 }  // namespace
 135
 136 // static
 137 scoped_refptr<base::SequencedTaskRunner> JsonPrefStore::GetTaskRunnerForFile(
 138     const base::FilePath& filename,
 139     base::SequencedWorkerPool* worker_pool) {
 140   std::string token("json_pref_store-");
 141   token.append(filename.AsUTF8Unsafe());
 142   return worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
 143       worker_pool->GetNamedSequenceToken(token),
 144       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 145 }
 146
 147 JsonPrefStore::JsonPrefStore(
 148     const base::FilePath& filename,
 149     const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner,
 150     scoped_ptr<PrefFilter> pref_filter)
 151     : path_(filename),
 152       sequenced_task_runner_(sequenced_task_runner),
 153       prefs_(new base::DictionaryValue()),
 154       read_only_(false),
 155       writer_(filename, sequenced_task_runner),
 156       pref_filter_(pref_filter.Pass()),
 157       initialized_(false),
 158       filtering_in_progress_(false),
 159       read_error_(PREF_READ_ERROR_NONE) {
 160   DCHECK(!path_.empty());
 161 }
 162
 163 JsonPrefStore::JsonPrefStore(
 164     const base::FilePath& filename,
 165     const base::FilePath& alternate_filename,
 166     const scoped_refptr<base::SequencedTaskRunner>& sequenced_task_runner,
 167     scoped_ptr<PrefFilter> pref_filter)
 168     : path_(filename),
 169       alternate_path_(alternate_filename),
 170       sequenced_task_runner_(sequenced_task_runner),
 171       prefs_(new base::DictionaryValue()),
 172       read_only_(false),
 173       writer_(filename, sequenced_task_runner),
 174       pref_filter_(pref_filter.Pass()),
 175       initialized_(false),
 176       filtering_in_progress_(false),
 177       read_error_(PREF_READ_ERROR_NONE) {
 178   DCHECK(!path_.empty());
 179 }
 180
 181 bool JsonPrefStore::GetValue(const std::string& key,
 182                              const base::Value** result) const {
 183   DCHECK(CalledOnValidThread());
 184
 185   base::Value* tmp = NULL;
 186   if (!prefs_->Get(key, &tmp))
 187     return false;
 188
 189   if (result)
 190     *result = tmp;
 191   return true;
 192 }
 193
 194 void JsonPrefStore::AddObserver(PrefStore::Observer* observer) {
 195   DCHECK(CalledOnValidThread());
 196
 197   observers_.AddObserver(observer);
 198 }
 199
 200 void JsonPrefStore::RemoveObserver(PrefStore::Observer* observer) {
 201   DCHECK(CalledOnValidThread());
 202
 203   observers_.RemoveObserver(observer);
 204 }
 205
 206 bool JsonPrefStore::HasObservers() const {
 207   DCHECK(CalledOnValidThread());
 208
 209   return observers_.might_have_observers();
 210 }
 211
 212 bool JsonPrefStore::IsInitializationComplete() const {
 213   DCHECK(CalledOnValidThread());
 214
 215   return initialized_;
 216 }
 217
 218 bool JsonPrefStore::GetMutableValue(const std::string& key,
 219                                     base::Value** result) {
 220   DCHECK(CalledOnValidThread());
 221
 222   return prefs_->Get(key, result);
 223 }
 224
 225 void JsonPrefStore::SetValue(const std::string& key, base::Value* value) {
 226   DCHECK(CalledOnValidThread());
 227
 228   DCHECK(value);
 229   scoped_ptr<base::Value> new_value(value);
 230   base::Value* old_value = NULL;
 231   prefs_->Get(key, &old_value);
 232   if (!old_value || !value->Equals(old_value)) {
 233     prefs_->Set(key, new_value.release());
 234     ReportValueChanged(key);
 235   }
 236 }
 237
 238 void JsonPrefStore::SetValueSilently(const std::string& key,
 239                                      base::Value* value) {
 240   DCHECK(CalledOnValidThread());
 241
 242   DCHECK(value);
 243   scoped_ptr<base::Value> new_value(value);
 244   base::Value* old_value = NULL;
 245   prefs_->Get(key, &old_value);
 246   if (!old_value || !value->Equals(old_value)) {
 247     prefs_->Set(key, new_value.release());
 248     if (!read_only_)
 249       writer_.ScheduleWrite(this);
 250   }
 251 }
 252
 253 void JsonPrefStore::RemoveValue(const std::string& key) {
 254   DCHECK(CalledOnValidThread());
 255
 256   if (prefs_->RemovePath(key, NULL))
 257     ReportValueChanged(key);
 258 }
 259
 260 void JsonPrefStore::RemoveValueSilently(const std::string& key) {
 261   DCHECK(CalledOnValidThread());
 262
 263   prefs_->RemovePath(key, NULL);
 264   if (!read_only_)
 265     writer_.ScheduleWrite(this);
 266 }
 267
 268 bool JsonPrefStore::ReadOnly() const {
 269   DCHECK(CalledOnValidThread());
 270
 271   return read_only_;
 272 }
 273
 274 PersistentPrefStore::PrefReadError JsonPrefStore::GetReadError() const {
 275   DCHECK(CalledOnValidThread());
 276
 277   return read_error_;
 278 }
 279
 280 PersistentPrefStore::PrefReadError JsonPrefStore::ReadPrefs() {
 281   DCHECK(CalledOnValidThread());
 282
 283   OnFileRead(ReadPrefsFromDisk(path_, alternate_path_));
 284   return filtering_in_progress_ ? PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE
 285                                 : read_error_;
 286 }
 287
 288 void JsonPrefStore::ReadPrefsAsync(ReadErrorDelegate* error_delegate) {
 289   DCHECK(CalledOnValidThread());
 290
 291   initialized_ = false;
 292   error_delegate_.reset(error_delegate);
 293
 294   // Weakly binds the read task so that it doesn't kick in during shutdown.
 295   base::PostTaskAndReplyWithResult(
 296       sequenced_task_runner_.get(),
 297       FROM_HERE,
 298       base::Bind(&ReadPrefsFromDisk, path_, alternate_path_),
 299       base::Bind(&JsonPrefStore::OnFileRead, AsWeakPtr()));
 300 }
 301
 302 void JsonPrefStore::CommitPendingWrite() {
 303   DCHECK(CalledOnValidThread());
 304
 305   if (writer_.HasPendingWrite() && !read_only_)
 306     writer_.DoScheduledWrite();
 307 }
 308
 309 void JsonPrefStore::ReportValueChanged(const std::string& key) {
 310   DCHECK(CalledOnValidThread());
 311
 312   if (pref_filter_)
 313     pref_filter_->FilterUpdate(key);
 314
 315   FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key));
 316
 317   if (!read_only_)
 318     writer_.ScheduleWrite(this);
 319 }
 320
 321 void JsonPrefStore::RegisterOnNextSuccessfulWriteCallback(
 322     const base::Closure& on_next_successful_write) {
 323   DCHECK(CalledOnValidThread());
 324
 325   writer_.RegisterOnNextSuccessfulWriteCallback(on_next_successful_write);
 326 }
 327
 328 void JsonPrefStore::OnFileRead(scoped_ptr<ReadResult> read_result) {
 329   DCHECK(CalledOnValidThread());
 330
 331   DCHECK(read_result);
 332
 333   scoped_ptr<base::DictionaryValue> unfiltered_prefs(new base::DictionaryValue);
 334
 335   read_error_ = read_result->error;
 336
 337   bool initialization_successful = !read_result->no_dir;
 338
 339   if (initialization_successful) {
 340     switch (read_error_) {
 341       case PREF_READ_ERROR_ACCESS_DENIED:
 342       case PREF_READ_ERROR_FILE_OTHER:
 343       case PREF_READ_ERROR_FILE_LOCKED:
 344       case PREF_READ_ERROR_JSON_TYPE:
 345       case PREF_READ_ERROR_FILE_NOT_SPECIFIED:
 346         read_only_ = true;
 347         break;
 348       case PREF_READ_ERROR_NONE:
 349         DCHECK(read_result->value.get());
 350         unfiltered_prefs.reset(
 351             static_cast<base::DictionaryValue*>(read_result->value.release()));
 352         break;
 353       case PREF_READ_ERROR_NO_FILE:
 354         // If the file just doesn't exist, maybe this is first run.  In any case
 355         // there's no harm in writing out default prefs in this case.
 356         break;
 357       case PREF_READ_ERROR_JSON_PARSE:
 358       case PREF_READ_ERROR_JSON_REPEAT:
 359         break;
 360       case PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE:
 361         // This is a special error code to be returned by ReadPrefs when it
 362         // can't complete synchronously, it should never be returned by the read
 363         // operation itself.
 364         NOTREACHED();
 365         break;
 366       case PREF_READ_ERROR_LEVELDB_IO:
 367       case PREF_READ_ERROR_LEVELDB_CORRUPTION_READ_ONLY:
 368       case PREF_READ_ERROR_LEVELDB_CORRUPTION:
 369         // These are specific to LevelDBPrefStore.
 370         NOTREACHED();
 371       case PREF_READ_ERROR_MAX_ENUM:
 372         NOTREACHED();
 373         break;
 374     }
 375   }
 376
 377   if (pref_filter_) {
 378     filtering_in_progress_ = true;
 379     const PrefFilter::PostFilterOnLoadCallback post_filter_on_load_callback(
 380         base::Bind(
 381             &JsonPrefStore::FinalizeFileRead, AsWeakPtr(),
 382             initialization_successful));
 383     pref_filter_->FilterOnLoad(post_filter_on_load_callback,
 384                                unfiltered_prefs.Pass());
 385   } else {
 386     FinalizeFileRead(initialization_successful, unfiltered_prefs.Pass(), false);
 387   }
 388 }
 389
 390 JsonPrefStore::~JsonPrefStore() {
 391   CommitPendingWrite();
 392 }
 393
 394 bool JsonPrefStore::SerializeData(std::string* output) {
 395   DCHECK(CalledOnValidThread());
 396
 397   if (pref_filter_)
 398     pref_filter_->FilterSerializeData(prefs_.get());
 399
 400   JSONStringValueSerializer serializer(output);
 401   serializer.set_pretty_print(true);
 402   return serializer.Serialize(*prefs_);
 403 }
 404
 405 void JsonPrefStore::FinalizeFileRead(bool initialization_successful,
 406                                      scoped_ptr<base::DictionaryValue> prefs,
 407                                      bool schedule_write) {
 408   DCHECK(CalledOnValidThread());
 409
 410   filtering_in_progress_ = false;
 411
 412   if (!initialization_successful) {
 413     FOR_EACH_OBSERVER(PrefStore::Observer,
 414                       observers_,
 415                       OnInitializationCompleted(false));
 416     return;
 417   }
 418
 419   prefs_ = prefs.Pass();
 420
 421   initialized_ = true;
 422
 423   if (schedule_write && !read_only_)
 424     writer_.ScheduleWrite(this);
 425
 426   if (error_delegate_ && read_error_ != PREF_READ_ERROR_NONE)
 427     error_delegate_->OnError(read_error_);
 428
 429   FOR_EACH_OBSERVER(PrefStore::Observer,
 430                     observers_,
 431                     OnInitializationCompleted(true));
 432
 433   return;
 434 }