Componentize //chrome/browser/prefs/tracked.

components/user_prefs/tracked/pref_hash_filter.cc

 // Copyright 2013 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/pref_hash_filter.h"
+#include "components/user_prefs/tracked/pref_hash_filter.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/pref_store.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
-#include "chrome/browser/prefs/tracked/dictionary_hash_store_contents.h"
-#include "chrome/browser/prefs/tracked/pref_hash_store.h"
-#include "chrome/browser/prefs/tracked/pref_hash_store_transaction.h"
-#include "chrome/browser/prefs/tracked/tracked_atomic_preference.h"
-#include "chrome/browser/prefs/tracked/tracked_split_preference.h"
-#include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
+#include "components/user_prefs/tracked/dictionary_hash_store_contents.h"
+#include "components/user_prefs/tracked/pref_hash_store.h"
+#include "components/user_prefs/tracked/pref_hash_store_transaction.h"
+#include "components/user_prefs/tracked/pref_names.h"
+#include "components/user_prefs/tracked/tracked_atomic_preference.h"
+#include "components/user_prefs/tracked/tracked_split_preference.h"
 
 namespace {
 
 void CleanupDeprecatedTrackedPreferences(
     base::DictionaryValue* pref_store_contents,
     PrefHashStoreTransaction* hash_store_transaction) {
   // Add deprecated previously tracked preferences below for them to be cleaned
   // up from both the pref files and the hash store.
   static const char* const kDeprecatedTrackedPreferences[] = {
-    // TODO(grt): Remove in M44+.
-    "safebrowsing.incident_report_sent",
-    // TODO(mad): Remove in M48+.
-    "software_reporter.prompt_reason",
+      // TODO(grt): Remove in M44+.
+      "safebrowsing.incident_report_sent",
+      // TODO(mad): Remove in M48+.
+      "software_reporter.prompt_reason",
   };
 
   for (size_t i = 0; i < arraysize(kDeprecatedTrackedPreferences); ++i) {
     const char* key = kDeprecatedTrackedPreferences[i];
     pref_store_contents->Remove(key, NULL);
     hash_store_transaction->ClearHash(key);
   }
 }
 
 }  // namespace
@@ skipping 47 matching lines @@
   // Ensure new values for all |changed_paths_| have been flushed to
   // |pref_hash_store_| already.
   DCHECK(changed_paths_.empty());
 }
 
 // static
 void PrefHashFilter::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   // See GetResetTime for why this is a StringPref and not Int64Pref.
   registry->RegisterStringPref(
-      prefs::kPreferenceResetTime,
+      user_prefs::kPreferenceResetTime,
       base::Int64ToString(base::Time().ToInternalValue()));
 }
 
 // static
 base::Time PrefHashFilter::GetResetTime(PrefService* user_prefs) {
   // Provide our own implementation (identical to the PrefService::GetInt64) in
   // order to ensure it remains consistent with the way we store this value
   // (which we do via a PrefStore, preventing us from reusing
   // PrefService::SetInt64).
   int64 internal_value = base::Time().ToInternalValue();
   if (!base::StringToInt64(
-          user_prefs->GetString(prefs::kPreferenceResetTime),
+          user_prefs->GetString(user_prefs::kPreferenceResetTime),
           &internal_value)) {
     // Somehow the value stored on disk is not a valid int64.
     NOTREACHED();
     return base::Time();
   }
   return base::Time::FromInternalValue(internal_value);
 }
 
 // static
 void PrefHashFilter::ClearResetTime(PrefService* user_prefs) {
-  user_prefs->ClearPref(prefs::kPreferenceResetTime);
+  user_prefs->ClearPref(user_prefs::kPreferenceResetTime);
 }
 
 void PrefHashFilter::Initialize(base::DictionaryValue* pref_store_contents) {
   scoped_ptr<PrefHashStoreTransaction> hash_store_transaction(
       pref_hash_store_->BeginTransaction(scoped_ptr<HashStoreContents>(
           new DictionaryHashStoreContents(pref_store_contents))));
   for (TrackedPreferencesMap::const_iterator it = tracked_paths_.begin();
        it != tracked_paths_.end(); ++it) {
     const std::string& initialized_path = it->first;
     const TrackedPreference* initialized_preference = it->second;
@@ skipping 67 matching lines @@
                                        hash_store_transaction.get())) {
         did_reset = true;
         prefs_altered = true;
       }
     }
     if (hash_store_transaction->StampSuperMac())
       prefs_altered = true;
   }
 
   if (did_reset) {
-    pref_store_contents->Set(prefs::kPreferenceResetTime,
+    pref_store_contents->Set(user_prefs::kPreferenceResetTime,
                              new base::StringValue(base::Int64ToString(
                                  base::Time::Now().ToInternalValue())));
-    FilterUpdate(prefs::kPreferenceResetTime);
+    FilterUpdate(user_prefs::kPreferenceResetTime);
 
     if (!on_reset_on_load_.is_null())
       on_reset_on_load_.Run();
   }
 
   // TODO(gab): Remove this histogram by Feb 21 2014; after sufficient timing
   // data has been gathered from the wild to be confident this doesn't
   // significantly affect startup.
   UMA_HISTOGRAM_TIMES("Settings.FilterOnLoadTime",
                       base::TimeTicks::Now() - checkpoint);
 
   post_filter_on_load_callback.Run(pref_store_contents.Pass(), prefs_altered);
 }