Make a JsonPrefStore readable while mid-interception.

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 279 matching lines @@
 }
 
 void JsonPrefStore::RegisterOnNextSuccessfulWriteCallback(
     const base::Closure& on_next_successful_write) {
   writer_.RegisterOnNextSuccessfulWriteCallback(on_next_successful_write);
 }
 
 void JsonPrefStore::OnFileRead(scoped_ptr<base::Value> value,
                                PersistentPrefStore::PrefReadError error,
                                bool no_dir) {
-  scoped_ptr<base::DictionaryValue> unfiltered_prefs(new base::DictionaryValue);
-
   read_error_ = error;
 
   bool initialization_successful = !no_dir;
 
   if (initialization_successful) {
     switch (read_error_) {
       case PREF_READ_ERROR_ACCESS_DENIED:
       case PREF_READ_ERROR_FILE_OTHER:
       case PREF_READ_ERROR_FILE_LOCKED:
       case PREF_READ_ERROR_JSON_TYPE:
       case PREF_READ_ERROR_FILE_NOT_SPECIFIED:
         read_only_ = true;
         break;
       case PREF_READ_ERROR_NONE:
         DCHECK(value.get());
-        unfiltered_prefs.reset(
-            static_cast<base::DictionaryValue*>(value.release()));
+        prefs_.reset(static_cast<base::DictionaryValue*>(value.release()));
         break;
       case PREF_READ_ERROR_NO_FILE:
         // If the file just doesn't exist, maybe this is first run.  In any case
         // there's no harm in writing out default prefs in this case.
         break;
       case PREF_READ_ERROR_JSON_PARSE:
       case PREF_READ_ERROR_JSON_REPEAT:
         break;
       case PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE:
         // This is a special error code to be returned by ReadPrefs when it
         // can't complete synchronously, it should never be returned by the read
         // operation itself.
         NOTREACHED();
         break;
       case PREF_READ_ERROR_LEVELDB_IO:
       case PREF_READ_ERROR_LEVELDB_CORRUPTION_READ_ONLY:
       case PREF_READ_ERROR_LEVELDB_CORRUPTION:
         // These are specific to LevelDBPrefStore.
         NOTREACHED();
       case PREF_READ_ERROR_MAX_ENUM:
         NOTREACHED();
         break;
     }
   }
 
   if (pref_filter_) {
     filtering_in_progress_ = true;
     const PrefFilter::PostFilterOnLoadCallback post_filter_on_load_callback(
         base::Bind(
             &JsonPrefStore::FinalizeFileRead, this, initialization_successful));

[gab, 2014/06/11 21:12:55]

For context for Bernhard:

this CL is okay in the sense that it won't cause issues short term. However it
forces this callback to hold a reference to the JsonPrefStore which we wanted to
get rid of.

This was discussed in lengths @
https://codereview.chromium.org/324493002/diff/40001/base/prefs/json_pref_sto...

Erik will add a TODO for now explaining this so that we can proceed with a very
important change for M37 (allowing the MACs to be in the same JsonPrefStore as
their protected values: https://codereview.chromium.org/324493002) and I will
follow-up with a change to clean this up, restoring the ownership dance of the
|prefs_| and allowing us to drop the refcounting here and on the
FileThreadDeserializer.

-    pref_filter_->FilterOnLoad(post_filter_on_load_callback,
-                               unfiltered_prefs.Pass());
+    pref_filter_->FilterOnLoad(post_filter_on_load_callback, prefs_.get());
   } else {
-    FinalizeFileRead(initialization_successful, unfiltered_prefs.Pass(), false);
+    FinalizeFileRead(initialization_successful, false);
   }
 }
 
 JsonPrefStore::~JsonPrefStore() {
   CommitPendingWrite();
 }
 
 bool JsonPrefStore::SerializeData(std::string* output) {
   if (pref_filter_)
     pref_filter_->FilterSerializeData(prefs_.get());
 
   JSONStringValueSerializer serializer(output);
   serializer.set_pretty_print(true);
   return serializer.Serialize(*prefs_);
 }
 
 void JsonPrefStore::FinalizeFileRead(bool initialization_successful,
-                                     scoped_ptr<base::DictionaryValue> prefs,
                                      bool schedule_write) {
   filtering_in_progress_ = false;
 
   if (!initialization_successful) {
     FOR_EACH_OBSERVER(PrefStore::Observer,
                       observers_,
                       OnInitializationCompleted(false));
     return;
   }
 
-  prefs_ = prefs.Pass();
-
   initialized_ = true;
 
   if (schedule_write && !read_only_)
     writer_.ScheduleWrite(this);
 
   if (error_delegate_ && read_error_ != PREF_READ_ERROR_NONE)
     error_delegate_->OnError(read_error_);
 
   FOR_EACH_OBSERVER(PrefStore::Observer,
                     observers_,
                     OnInitializationCompleted(true));
 
   return;
 }