Merge 284507 "Invoke the StartSyncFlare for prefs when performin..."

chrome/browser/prefs/profile_pref_store_manager.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/profile_pref_store_manager.h"
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/persistent_pref_store.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "chrome/browser/prefs/pref_hash_store_impl.h"
 #include "chrome/browser/prefs/tracked/pref_service_hash_store_contents.h"
 #include "chrome/browser/prefs/tracked/segregated_pref_store.h"
@@ skipping 56 matching lines @@
   return PrefHashFilter::GetResetTime(pref_service);
 }
 
 // static
 void ProfilePrefStoreManager::ClearResetTime(PrefService* pref_service) {
   PrefHashFilter::ClearResetTime(pref_service);
 }
 
 PersistentPrefStore* ProfilePrefStoreManager::CreateProfilePrefStore(
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
+    const base::Closure& on_reset_on_load,
     TrackedPreferenceValidationDelegate* validation_delegate) {
   scoped_ptr<PrefFilter> pref_filter;
   if (!kPlatformSupportsPreferenceTracking) {
     return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
                              io_task_runner,
                              scoped_ptr<PrefFilter>());
   }
 
   std::vector<PrefHashFilter::TrackedPreferenceMetadata>
       unprotected_configuration;
@@ skipping 10 matching lines @@
       protected_pref_names.insert(it->name);
     } else {
       unprotected_configuration.push_back(*it);
       unprotected_pref_names.insert(it->name);
     }
   }
 
   scoped_ptr<PrefHashFilter> unprotected_pref_hash_filter(
       new PrefHashFilter(GetPrefHashStore(false),
                          unprotected_configuration,
+                         base::Closure(),
                          validation_delegate,
                          reporting_ids_count_,
                          false));
   scoped_ptr<PrefHashFilter> protected_pref_hash_filter(
       new PrefHashFilter(GetPrefHashStore(true),
                          protected_configuration,
+                         on_reset_on_load,
                          validation_delegate,
                          reporting_ids_count_,
                          true));
 
   PrefHashFilter* raw_unprotected_pref_hash_filter =
       unprotected_pref_hash_filter.get();
   PrefHashFilter* raw_protected_pref_hash_filter =
       protected_pref_hash_filter.get();
 
   scoped_refptr<JsonPrefStore> unprotected_pref_store(
@@ skipping 38 matching lines @@
     return false;
 
   const base::DictionaryValue* to_serialize = &master_prefs;
   scoped_ptr<base::DictionaryValue> copy;
 
   if (kPlatformSupportsPreferenceTracking) {
     copy.reset(master_prefs.DeepCopy());
     to_serialize = copy.get();
     PrefHashFilter(GetPrefHashStore(false),
                    tracking_configuration_,
+                   base::Closure(),
                    NULL,
                    reporting_ids_count_,
                    false).Initialize(copy.get());
   }
 
   // This will write out to a single combined file which will be immediately
   // migrated to two files on load.
   JSONFileValueSerializer serializer(
       GetPrefFilePathFromProfilePath(profile_path_));
 
@@ skipping 14 matching lines @@
   scoped_ptr<PrefFilter> pref_filter;
   if (kPlatformSupportsPreferenceTracking) {
     scoped_ptr<PrefHashStoreImpl> pref_hash_store_impl(
         new PrefHashStoreImpl(seed_, device_id_, true));
     pref_hash_store_impl->set_legacy_hash_store_contents(
         scoped_ptr<HashStoreContents>(new PrefServiceHashStoreContents(
             profile_path_.AsUTF8Unsafe(), local_state_)));
     pref_filter.reset(
         new PrefHashFilter(pref_hash_store_impl.PassAs<PrefHashStore>(),
                            tracking_configuration_,
+                           base::Closure(),
                            NULL,
                            reporting_ids_count_,
                            false));
   }
   return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
                            io_task_runner,
                            pref_filter.Pass());
 }
 
 scoped_ptr<PrefHashStore> ProfilePrefStoreManager::GetPrefHashStore(
     bool use_super_mac) {
   DCHECK(kPlatformSupportsPreferenceTracking);
 
   return scoped_ptr<PrefHashStore>(new PrefHashStoreImpl(
       seed_,
       device_id_,
       use_super_mac));
 }