Changes requested by gab for previously committed CLs.

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/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 114 matching lines @@
   }
 
  private:
   virtual ~DictionaryPrefStore() {}
 
   const base::DictionaryValue* dictionary_;
 
   DISALLOW_COPY_AND_ASSIGN(DictionaryPrefStore);
 };
 
-}  // namespace
-
-// TODO(erikwright): Enable this on Chrome OS and Android once MACs are moved
-// out of Local State. This will resolve a race condition on Android and a
-// privacy issue on ChromeOS. http://crbug.com/349158
-const bool ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking =
-#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
-    false;
-#else
-    true;
-#endif
-
 // Waits for a PrefStore to be initialized and then initializes the
 // corresponding PrefHashStore.
 // The observer deletes itself when its work is completed.
-class ProfilePrefStoreManager::InitializeHashStoreObserver
-    : public PrefStore::Observer {
+class InitializeHashStoreObserver : public PrefStore::Observer {
  public:
   // Creates an observer that will initialize |pref_hash_store| with the
   // contents of |pref_store| when the latter is fully loaded.
   InitializeHashStoreObserver(
       const std::vector<PrefHashFilter::TrackedPreferenceMetadata>&
           tracking_configuration,
       size_t reporting_ids_count,
       const scoped_refptr<PrefStore>& pref_store,
       scoped_ptr<PrefHashStoreImpl> pref_hash_store_impl)
       : tracking_configuration_(tracking_configuration),
@@ skipping 10 matching lines @@
  private:
   const std::vector<PrefHashFilter::TrackedPreferenceMetadata>
       tracking_configuration_;
   const size_t reporting_ids_count_;
   scoped_refptr<PrefStore> pref_store_;
   scoped_ptr<PrefHashStoreImpl> pref_hash_store_impl_;
 
   DISALLOW_COPY_AND_ASSIGN(InitializeHashStoreObserver);
 };
 
-ProfilePrefStoreManager::InitializeHashStoreObserver::
-    ~InitializeHashStoreObserver() {}
+InitializeHashStoreObserver::~InitializeHashStoreObserver() {}
 
-void ProfilePrefStoreManager::InitializeHashStoreObserver::OnPrefValueChanged(
-    const std::string& key) {}
+void InitializeHashStoreObserver::OnPrefValueChanged(const std::string& key) {}
 
-void
-ProfilePrefStoreManager::InitializeHashStoreObserver::OnInitializationCompleted(
-    bool succeeded) {
+void InitializeHashStoreObserver::OnInitializationCompleted(bool succeeded) {
   // If we successfully loaded the preferences _and_ the PrefHashStoreImpl
   // hasn't been initialized by someone else in the meantime, initialize it now.
   const PrefHashStoreImpl::StoreVersion pre_update_version =
       pref_hash_store_impl_->GetCurrentVersion();
   if (succeeded && pre_update_version < PrefHashStoreImpl::VERSION_LATEST) {
     PrefHashFilter(pref_hash_store_impl_.PassAs<PrefHashStore>(),
                    tracking_configuration_,
                    reporting_ids_count_).Initialize(*pref_store_);
     UMA_HISTOGRAM_ENUMERATION(
         "Settings.TrackedPreferencesAlternateStoreVersionUpdatedFrom",
         pre_update_version,
         PrefHashStoreImpl::VERSION_LATEST + 1);
   }
   pref_store_->RemoveObserver(this);
   delete this;
 }
 
+}  // namespace
+
+// TODO(erikwright): Enable this on Chrome OS and Android once MACs are moved
+// out of Local State. This will resolve a race condition on Android and a
+// privacy issue on ChromeOS. http://crbug.com/349158
+const bool ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking =
+#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
+    false;
+#else
+    true;
+#endif
+
 ProfilePrefStoreManager::ProfilePrefStoreManager(
     const base::FilePath& profile_path,
     const std::vector<PrefHashFilter::TrackedPreferenceMetadata>&
         tracking_configuration,
     size_t reporting_ids_count,
     const std::string& seed,
     const std::string& device_id,
     PrefService* local_state)
     : profile_path_(profile_path),
       tracking_configuration_(tracking_configuration),
@@ skipping 28 matching lines @@
 
 //  static
 base::Time ProfilePrefStoreManager::GetResetTime(PrefService* pref_service) {
   // It's a bit of a coincidence that this (and ClearResetTime) work(s). The
   // PrefHashFilter attached to the protected pref store will store the reset
   // time directly in the protected pref store without going through the
   // SegregatedPrefStore.
 
   // PrefHashFilter::GetResetTime will read the value through the pref service,
   // and thus through the SegregatedPrefStore. Even though it's not listed as
-  // "protected" it will be read from the protected store prefentially to the
+  // "protected" it will be read from the protected store preferentially to the
   // (NULL) value in the unprotected pref store.
   return PrefHashFilter::GetResetTime(pref_service);
 }
 
 // static
 void ProfilePrefStoreManager::ClearResetTime(PrefService* pref_service) {
   // PrefHashFilter::ClearResetTime will clear the value through the pref
   // service, and thus through the SegregatedPrefStore. Since it's not listed as
   // "protected" it will be migrated from the protected store to the unprotected
   // pref store before being deleted from the latter.
@@ skipping 151 matching lines @@
   DCHECK(kPlatformSupportsPreferenceTracking);
 
   PrefServiceHashStoreContents real_contents(profile_path_.AsUTF8Unsafe(),
                                              local_state_);
   return scoped_ptr<PrefHashStore>(new PrefHashStoreImpl(
       seed_,
       device_id_,
       scoped_ptr<HashStoreContents>(
           new DictionaryHashStoreContents(real_contents))));
 }