Make a JsonPrefStore readable while mid-interception.

chrome/browser/prefs/tracked/tracked_preferences_migration.cc

 // Copyright 2014 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/prefs/tracked/tracked_preferences_migration.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 29 matching lines @@
   };
 
   ~TrackedPreferencesMigrator();
 
   // Stores the data coming in from the filter identified by |id| into this
   // class and then calls MigrateIfReady();
   void InterceptFilterOnLoad(
       PrefFilterID id,
       const InterceptablePrefFilter::FinalizeFilterOnLoadCallback&
           finalize_filter_on_load,
-      scoped_ptr<base::DictionaryValue> prefs);
+      base::DictionaryValue* prefs);
 
   // Proceeds with migration if both |unprotected_prefs_| and |protected_prefs_|
   // have been set.
   void MigrateIfReady();
 
   const std::set<std::string> unprotected_pref_names_;
   const std::set<std::string> protected_pref_names_;
 
   const base::Callback<void(const std::string& key)> unprotected_store_cleaner_;
   const base::Callback<void(const std::string& key)> protected_store_cleaner_;
   const base::Callback<void(const base::Closure&)>
       register_on_successful_unprotected_store_write_callback_;
   const base::Callback<void(const base::Closure&)>
       register_on_successful_protected_store_write_callback_;
 
   InterceptablePrefFilter::FinalizeFilterOnLoadCallback
       finalize_unprotected_filter_on_load_;
   InterceptablePrefFilter::FinalizeFilterOnLoadCallback
       finalize_protected_filter_on_load_;
 
-  scoped_ptr<base::DictionaryValue> unprotected_prefs_;
-  scoped_ptr<base::DictionaryValue> protected_prefs_;
+  base::DictionaryValue* unprotected_prefs_;
+  base::DictionaryValue* protected_prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(TrackedPreferencesMigrator);
 };
 
 // Invokes |store_cleaner| for every |keys_to_clean|.
 void CleanupPrefStore(
     const base::Callback<void(const std::string& key)>& store_cleaner,
     const std::set<std::string>& keys_to_clean) {
   for (std::set<std::string>::const_iterator it = keys_to_clean.begin();
        it != keys_to_clean.end(); ++it) {
@@ skipping 67 matching lines @@
         register_on_successful_protected_store_write_callback,
     InterceptablePrefFilter* unprotected_pref_filter,
     InterceptablePrefFilter* protected_pref_filter)
     : unprotected_pref_names_(unprotected_pref_names),
       protected_pref_names_(protected_pref_names),
       unprotected_store_cleaner_(unprotected_store_cleaner),
       protected_store_cleaner_(protected_store_cleaner),
       register_on_successful_unprotected_store_write_callback_(
           register_on_successful_unprotected_store_write_callback),
       register_on_successful_protected_store_write_callback_(
-          register_on_successful_protected_store_write_callback) {
+          register_on_successful_protected_store_write_callback),
+      unprotected_prefs_(NULL),
+      protected_prefs_(NULL) {
   // The callbacks bound below will own this TrackedPreferencesMigrator by
   // reference.
   unprotected_pref_filter->InterceptNextFilterOnLoad(
       base::Bind(&TrackedPreferencesMigrator::InterceptFilterOnLoad,
                  this,
                  UNPROTECTED_PREF_FILTER));
   protected_pref_filter->InterceptNextFilterOnLoad(
       base::Bind(&TrackedPreferencesMigrator::InterceptFilterOnLoad,
                  this,
                  PROTECTED_PREF_FILTER));
 }
 
 TrackedPreferencesMigrator::~TrackedPreferencesMigrator() {}
 
 void TrackedPreferencesMigrator::InterceptFilterOnLoad(
     PrefFilterID id,
     const InterceptablePrefFilter::FinalizeFilterOnLoadCallback&
         finalize_filter_on_load,
-    scoped_ptr<base::DictionaryValue> prefs) {
+    base::DictionaryValue* prefs) {
   switch (id) {
     case UNPROTECTED_PREF_FILTER:
       finalize_unprotected_filter_on_load_ = finalize_filter_on_load;
-      unprotected_prefs_ = prefs.Pass();
+      unprotected_prefs_ = prefs;
       break;
     case PROTECTED_PREF_FILTER:
       finalize_protected_filter_on_load_ = finalize_filter_on_load;
-      protected_prefs_ = prefs.Pass();
+      protected_prefs_ = prefs;
       break;
   }
 
   MigrateIfReady();
 }
 
 void TrackedPreferencesMigrator::MigrateIfReady() {
   // Wait for both stores to have been read before proceeding.
   if (!protected_prefs_ || !unprotected_prefs_)
     return;
 
   bool protected_prefs_need_cleanup = false;
   bool unprotected_prefs_altered = false;
   MigratePrefsFromOldToNewStore(unprotected_pref_names_,
-                                protected_prefs_.get(),
-                                unprotected_prefs_.get(),
+                                protected_prefs_,
+                                unprotected_prefs_,
                                 &protected_prefs_need_cleanup,
                                 &unprotected_prefs_altered);
   bool unprotected_prefs_need_cleanup = false;
   bool protected_prefs_altered = false;
   MigratePrefsFromOldToNewStore(protected_pref_names_,
-                                unprotected_prefs_.get(),
-                                protected_prefs_.get(),
+                                unprotected_prefs_,
+                                protected_prefs_,
                                 &unprotected_prefs_need_cleanup,
                                 &protected_prefs_altered);
 
-  // Hand the processed prefs back to their respective filters.
-  finalize_unprotected_filter_on_load_.Run(unprotected_prefs_.Pass(),
-                                           unprotected_prefs_altered);
-  finalize_protected_filter_on_load_.Run(protected_prefs_.Pass(),
-                                         protected_prefs_altered);
+  // Allow preference loading to proceed.
+  unprotected_prefs_ = NULL;
+  protected_prefs_ = NULL;
+  finalize_unprotected_filter_on_load_.Run(unprotected_prefs_altered);
+  finalize_protected_filter_on_load_.Run(protected_prefs_altered);
 
   if (unprotected_prefs_need_cleanup) {
     // Schedule a cleanup of the |protected_pref_names_| from the unprotected
     // prefs once the protected prefs were successfully written to disk (or
     // do it immediately if |!protected_prefs_altered|).
     ScheduleSourcePrefStoreCleanup(
         register_on_successful_protected_store_write_callback_,
         unprotected_store_cleaner_,
         protected_pref_names_,
         protected_prefs_altered);
@@ skipping 29 matching lines @@
       new TrackedPreferencesMigrator(
           unprotected_pref_names,
           protected_pref_names,
           unprotected_store_cleaner,
           protected_store_cleaner,
           register_on_successful_unprotected_store_write_callback,
           register_on_successful_protected_store_write_callback,
           unprotected_pref_filter,
           protected_pref_filter));
 }