Componentize //chrome/browser/prefs/tracked.

components/prefs_tracker/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/prefs_tracker/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/prefs_tracker/dictionary_hash_store_contents.h"
+#include "components/prefs_tracker/pref_hash_store.h"
+#include "components/prefs_tracker/pref_hash_store_transaction.h"
+#include "components/prefs_tracker/pref_names.h"
+#include "components/prefs_tracker/tracked_atomic_preference.h"
+#include "components/prefs_tracker/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[] = {

[gab, 2015/07/23 21:41:16]

These used to move from c/b/prefs/chrome_pref_service_factory.cc to here in
c/b/prefs/tracked/pref_hash_filter.cc upon deprecation, this path is now a lot
more blurry...

[blundell, 2015/07/24 08:26:19]

Could you elaborate a bit? Are you saying more blurry because now that path is
crossing the line from the Chrome embedder into the component?

[Jitu( very slow this week), 2015/07/24 09:09:23]

sorry i couldn't get this. Can you please elaborate more on this.

-    // 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 10 matching lines @@
       report_super_mac_validity_(report_super_mac_validity) {
   DCHECK(pref_hash_store_);
   DCHECK_GE(reporting_ids_count, tracked_preferences.size());
 
   for (size_t i = 0; i < tracked_preferences.size(); ++i) {
     const TrackedPreferenceMetadata& metadata = tracked_preferences[i];
 
     scoped_ptr<TrackedPreference> tracked_preference;
     switch (metadata.strategy) {
       case TRACKING_STRATEGY_ATOMIC:
-        tracked_preference.reset(
-            new TrackedAtomicPreference(metadata.name,
-                                        metadata.reporting_id,
-                                        reporting_ids_count,
-                                        metadata.enforcement_level,
-                                        metadata.value_type,
-                                        delegate));
+        tracked_preference.reset(new TrackedAtomicPreference(
+            metadata.name, metadata.reporting_id, reporting_ids_count,
+            metadata.enforcement_level, metadata.value_type, delegate));
         break;
       case TRACKING_STRATEGY_SPLIT:
-        tracked_preference.reset(
-            new TrackedSplitPreference(metadata.name,
-                                       metadata.reporting_id,
-                                       reporting_ids_count,
-                                       metadata.enforcement_level,
-                                       metadata.value_type,
-                                       delegate));
+        tracked_preference.reset(new TrackedSplitPreference(
+            metadata.name, metadata.reporting_id, reporting_ids_count,
+            metadata.enforcement_level, metadata.value_type, delegate));
         break;
     }
     DCHECK(tracked_preference);
 
-    bool is_new = tracked_paths_.add(metadata.name,
-                                     tracked_preference.Pass()).second;
+    bool is_new =
+        tracked_paths_.add(metadata.name, tracked_preference.Pass()).second;
     DCHECK(is_new);
   }
 }
 
 PrefHashFilter::~PrefHashFilter() {
   // 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,
       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),
-          &internal_value)) {
+  if (!base::StringToInt64(user_prefs->GetString(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);
@@ skipping 56 matching lines @@
     bool prefs_altered) {
   DCHECK(pref_store_contents);
   base::TimeTicks checkpoint = base::TimeTicks::Now();
 
   bool did_reset = false;
   {
     scoped_ptr<PrefHashStoreTransaction> hash_store_transaction(
         pref_hash_store_->BeginTransaction(scoped_ptr<HashStoreContents>(
             new DictionaryHashStoreContents(pref_store_contents.get()))));
 
-    CleanupDeprecatedTrackedPreferences(
-        pref_store_contents.get(), hash_store_transaction.get());
+    CleanupDeprecatedTrackedPreferences(pref_store_contents.get(),
+                                        hash_store_transaction.get());
 
     if (report_super_mac_validity_) {
       UMA_HISTOGRAM_BOOLEAN("Settings.HashesDictionaryTrusted",
                             hash_store_transaction->IsSuperMACValid());
     }
 
     for (TrackedPreferencesMap::const_iterator it = tracked_paths_.begin();
          it != tracked_paths_.end(); ++it) {
       if (it->second->EnforceAndReport(pref_store_contents.get(),
                                        hash_store_transaction.get())) {
@@ skipping 16 matching lines @@
   }
 
   // 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);
 }