Putting histogram names of tracked prefs in tracked_preference_histogram_name file.

chrome/browser/prefs/tracked/pref_hash_browsertest.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 <string>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/prefs/chrome_pref_service_factory.h"
 #include "chrome/browser/prefs/profile_pref_store_manager.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/search_engines/default_search_manager.h"
+#include "components/user_prefs/tracked/pref_names.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/common/extension.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/chromeos_switches.h"
 #endif
 
 namespace {
 
 // Extension ID of chrome/test/data/extensions/good.crx
@@ skipping 202 matching lines @@
     const char kNumTrackedPrefFilename[] = "NumTrackedPrefs";
 
     base::FilePath num_tracked_prefs_file;
     ASSERT_TRUE(
         PathService::Get(chrome::DIR_USER_DATA, &num_tracked_prefs_file));
     num_tracked_prefs_file =
         num_tracked_prefs_file.AppendASCII(kNumTrackedPrefFilename);
 
     if (IsPRETest()) {
       num_tracked_prefs_ = GetTrackedPrefHistogramCount(
-          "Settings.TrackedPreferenceNullInitialized", ALLOW_ANY);
+          user_tracked_prefs::kTrackedPreferenceNullInitialized, ALLOW_ANY);
       EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM,
                 num_tracked_prefs_ > 0);
 
       // Split tracked prefs are reported as Unchanged not as NullInitialized
       // when an empty dictionary is encountered on first run (this should only
       // hit for pref #5 in the current design).
       int num_split_tracked_prefs = GetTrackedPrefHistogramCount(
-          "Settings.TrackedPreferenceUnchanged", BEGIN_ALLOW_SINGLE_BUCKET + 5);
+          user_tracked_prefs::kTrackedPreferenceUnchanged,
+          BEGIN_ALLOW_SINGLE_BUCKET + 5);
       EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM ? 1 : 0,
                 num_split_tracked_prefs);
 
       num_tracked_prefs_ += num_split_tracked_prefs;
 
       std::string num_tracked_prefs_str = base::IntToString(num_tracked_prefs_);
       EXPECT_EQ(static_cast<int>(num_tracked_prefs_str.size()),
                 base::WriteFile(num_tracked_prefs_file,
                                 num_tracked_prefs_str.c_str(),
                                 num_tracked_prefs_str.size()));
@@ skipping 91 matching lines @@
 
   void AttackPreferencesOnDisk(
       base::DictionaryValue* unprotected_preferences,
       base::DictionaryValue* protected_preferences) override {
     // No attack.
   }
 
   void VerifyReactionToPrefAttack() override {
     // Expect all prefs to be reported as Unchanged with no resets.
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM
-                  ? num_tracked_prefs() : 0,
+                  ? num_tracked_prefs()
+                  : 0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceUnchanged", ALLOW_ANY));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceWantedReset", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceReset",
-                                           ALLOW_NONE));
+                  user_tracked_prefs::kTrackedPreferenceUnchanged, ALLOW_ANY));
+    EXPECT_EQ(
+        0, GetTrackedPrefHistogramCount(
+               user_tracked_prefs::kTrackedPreferenceWantedReset, ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceReset, ALLOW_NONE));
 
     // Nothing else should have triggered.
     EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceChanged",
-                                           ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceCleared",
-                                           ALLOW_NONE));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceChanged, ALLOW_NONE));
     EXPECT_EQ(0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceInitialized", ALLOW_NONE));
+                  user_tracked_prefs::kTrackedPreferenceCleared, ALLOW_NONE));
+    EXPECT_EQ(
+        0, GetTrackedPrefHistogramCount(
+               user_tracked_prefs::kTrackedPreferenceInitialized, ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceTrustedInitialized,
+                     ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceNullInitialized,
+                     ALLOW_NONE));
     EXPECT_EQ(0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceTrustedInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceNullInitialized", ALLOW_NONE));
-    EXPECT_EQ(
-        0,
-        GetTrackedPrefHistogramCount(
-            "Settings.TrackedPreferenceMigratedLegacyDeviceId", ALLOW_NONE));
+                  user_tracked_prefs::kTrackedPreferenceMigratedLegacyDeviceId,
+                  ALLOW_NONE));
   }
 };
 
 PREF_HASH_BROWSER_TEST(PrefHashBrowserTestUnchangedDefault, UnchangedDefault);
 
 // Augments PrefHashBrowserTestUnchangedDefault to confirm that nothing is reset
 // when nothing is tampered with, even if Chrome itself wrote custom prefs in
 // its last run.
 class PrefHashBrowserTestUnchangedCustom
     : public PrefHashBrowserTestUnchangedDefault {
@@ skipping 36 matching lines @@
     // it.
     EXPECT_TRUE(selected_prefs);
     EXPECT_TRUE(selected_prefs->Remove(prefs::kHomePage, NULL));
   }
 
   void VerifyReactionToPrefAttack() override {
     // The clearance of homepage should have been noticed (as pref #2 being
     // cleared), but shouldn't have triggered a reset (as there is nothing we
     // can do when the pref is already gone).
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM ? 1 : 0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceCleared",
-                                           BEGIN_ALLOW_SINGLE_BUCKET + 2));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceCleared,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 2));
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM
-                  ? num_tracked_prefs() - 1 : 0,
+                  ? num_tracked_prefs() - 1
+                  : 0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceUnchanged", ALLOW_ANY));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceWantedReset", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceReset",
-                                           ALLOW_NONE));
+                  user_tracked_prefs::kTrackedPreferenceUnchanged, ALLOW_ANY));
+    EXPECT_EQ(
+        0, GetTrackedPrefHistogramCount(
+               user_tracked_prefs::kTrackedPreferenceWantedReset, ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceReset, ALLOW_NONE));
 
     // Nothing else should have triggered.
     EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceChanged",
-                                           ALLOW_NONE));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceChanged, ALLOW_NONE));
+    EXPECT_EQ(
+        0, GetTrackedPrefHistogramCount(
+               user_tracked_prefs::kTrackedPreferenceInitialized, ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceTrustedInitialized,
+                     ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceNullInitialized,
+                     ALLOW_NONE));
     EXPECT_EQ(0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceTrustedInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceNullInitialized", ALLOW_NONE));
-    EXPECT_EQ(
-        0,
-        GetTrackedPrefHistogramCount(
-            "Settings.TrackedPreferenceMigratedLegacyDeviceId", ALLOW_NONE));
+                  user_tracked_prefs::kTrackedPreferenceMigratedLegacyDeviceId,
+                  ALLOW_NONE));
   }
 };
 
 PREF_HASH_BROWSER_TEST(PrefHashBrowserTestClearedAtomic, ClearedAtomic);
 
 // Verifies that clearing the MACs results in untrusted Initialized pings for
 // non-null protected prefs.
 class PrefHashBrowserTestUntrustedInitialized : public PrefHashBrowserTestBase {
  public:
   void SetupPreferences() override {
@@ skipping 24 matching lines @@
       base::DictionaryValue* unprotected_preferences,
       base::DictionaryValue* protected_preferences) override {
     EXPECT_TRUE(unprotected_preferences->Remove("protection.macs", NULL));
     if (protected_preferences)
       EXPECT_TRUE(protected_preferences->Remove("protection.macs", NULL));
   }
 
   void VerifyReactionToPrefAttack() override {
     // Preferences that are NULL by default will be NullInitialized.
     int num_null_values = GetTrackedPrefHistogramCount(
-        "Settings.TrackedPreferenceNullInitialized", ALLOW_ANY);
+        user_tracked_prefs::kTrackedPreferenceNullInitialized, ALLOW_ANY);
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM,
               num_null_values > 0);
     if (num_null_values > 0) {
       // This test requires that at least 3 prefs be non-null (extensions, DSE,
       // and 1 atomic pref explictly set for this test above).
       EXPECT_GE(num_tracked_prefs() - num_null_values, 3);
     }
 
     // Expect all non-null prefs to be reported as Initialized (with
     // accompanying resets or wanted resets based on the current protection
     // level).
-    EXPECT_EQ(num_tracked_prefs() - num_null_values,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceInitialized", ALLOW_ANY));
+    EXPECT_EQ(
+        num_tracked_prefs() - num_null_values,
+        GetTrackedPrefHistogramCount(
+            user_tracked_prefs::kTrackedPreferenceInitialized, ALLOW_ANY));
 
     int num_protected_prefs = 0;
     // A switch statement falling through each protection level in decreasing
     // levels of protection to add expectations for each level which augments
     // the previous one.
     switch (protection_level_) {
       case PROTECTION_ENABLED_ALL:
         // Falls through.
       case PROTECTION_ENABLED_EXTENSIONS:
         ++num_protected_prefs;
         // Falls through.
       case PROTECTION_ENABLED_DSE:
         ++num_protected_prefs;
         // Falls through.
       case PROTECTION_ENABLED_BASIC:
         num_protected_prefs += num_tracked_prefs() - num_null_values - 2;
         // Falls through.
       case PROTECTION_DISABLED_FOR_GROUP:
         // No protection. Falls through.
       case PROTECTION_DISABLED_ON_PLATFORM:
         // No protection.
         break;
     }
 
-    EXPECT_EQ(num_tracked_prefs() - num_null_values - num_protected_prefs,
+    EXPECT_EQ(
+        num_tracked_prefs() - num_null_values - num_protected_prefs,
+        GetTrackedPrefHistogramCount(
+            user_tracked_prefs::kTrackedPreferenceWantedReset, ALLOW_ANY));
+    EXPECT_EQ(num_protected_prefs,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceWantedReset", ALLOW_ANY));
-    EXPECT_EQ(num_protected_prefs,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceReset",
-                                           ALLOW_ANY));
+                  user_tracked_prefs::kTrackedPreferenceReset, ALLOW_ANY));
 
     // Explicitly verify the result of reported resets.
 
     DefaultSearchManager default_search_manager(
         profile()->GetPrefs(), DefaultSearchManager::ObserverCallback());
     DefaultSearchManager::Source dse_source =
         static_cast<DefaultSearchManager::Source>(-1);
     default_search_manager.GetDefaultSearchEngine(&dse_source);
     EXPECT_EQ(protection_level_ < PROTECTION_ENABLED_DSE
                   ? DefaultSearchManager::FROM_USER
                   : DefaultSearchManager::FROM_FALLBACK,
               dse_source);
 
     EXPECT_EQ(protection_level_ < PROTECTION_ENABLED_BASIC,
               profile()->GetPrefs()->GetInteger(prefs::kRestoreOnStartup) ==
                   SessionStartupPref::URLS);
 
     // Nothing else should have triggered.
     EXPECT_EQ(0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceUnchanged", ALLOW_NONE));
+                  user_tracked_prefs::kTrackedPreferenceUnchanged, ALLOW_NONE));
     EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceChanged",
-                                           ALLOW_NONE));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceChanged, ALLOW_NONE));
     EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceCleared",
-                                           ALLOW_NONE));
-    EXPECT_EQ(
-        0,
-        GetTrackedPrefHistogramCount(
-            "Settings.TrackedPreferenceMigratedLegacyDeviceId", ALLOW_NONE));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceCleared, ALLOW_NONE));
+    EXPECT_EQ(0,
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceMigratedLegacyDeviceId,
+                  ALLOW_NONE));
   }
 };
 
 PREF_HASH_BROWSER_TEST(PrefHashBrowserTestUntrustedInitialized,
                        UntrustedInitialized);
 
 // Verifies that changing an atomic pref results in it being reported (and reset
 // if the protection level allows it).
 class PrefHashBrowserTestChangedAtomic : public PrefHashBrowserTestBase {
  public:
@@ skipping 19 matching lines @@
     EXPECT_TRUE(
         selected_prefs->GetList(prefs::kURLsToRestoreOnStartup, &startup_urls));
     EXPECT_TRUE(startup_urls);
     EXPECT_EQ(1U, startup_urls->GetSize());
     startup_urls->AppendString("http://example.org");
   }
 
   void VerifyReactionToPrefAttack() override {
     // Expect a single Changed event for tracked pref #4 (startup URLs).
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM ? 1 : 0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceChanged",
-                                           BEGIN_ALLOW_SINGLE_BUCKET + 4));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceChanged,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 4));
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM
-                  ? num_tracked_prefs() - 1 : 0,
+                  ? num_tracked_prefs() - 1
+                  : 0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceUnchanged", ALLOW_ANY));
+                  user_tracked_prefs::kTrackedPreferenceUnchanged, ALLOW_ANY));
 
-    EXPECT_EQ(
-        (protection_level_ > PROTECTION_DISABLED_ON_PLATFORM &&
-         protection_level_ < PROTECTION_ENABLED_BASIC) ? 1 : 0,
-        GetTrackedPrefHistogramCount("Settings.TrackedPreferenceWantedReset",
-                                     BEGIN_ALLOW_SINGLE_BUCKET + 4));
+    EXPECT_EQ((protection_level_ > PROTECTION_DISABLED_ON_PLATFORM &&
+               protection_level_ < PROTECTION_ENABLED_BASIC)
+                  ? 1
+                  : 0,
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceWantedReset,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 4));
     EXPECT_EQ(protection_level_ >= PROTECTION_ENABLED_BASIC ? 1 : 0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceReset",
-                                           BEGIN_ALLOW_SINGLE_BUCKET + 4));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceReset,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 4));
 
 // TODO(gab): This doesn't work on OS_CHROMEOS because we fail to attack
 // Preferences.
 #if !defined(OS_CHROMEOS)
     // Explicitly verify the result of reported resets.
     EXPECT_EQ(protection_level_ >= PROTECTION_ENABLED_BASIC ? 0U : 2U,
               profile()
                   ->GetPrefs()
                   ->GetList(prefs::kURLsToRestoreOnStartup)
                   ->GetSize());
 #endif
 
     // Nothing else should have triggered.
     EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceCleared",
-                                           ALLOW_NONE));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceCleared, ALLOW_NONE));
+    EXPECT_EQ(
+        0, GetTrackedPrefHistogramCount(
+               user_tracked_prefs::kTrackedPreferenceInitialized, ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceTrustedInitialized,
+                     ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceNullInitialized,
+                     ALLOW_NONE));
     EXPECT_EQ(0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceTrustedInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceNullInitialized", ALLOW_NONE));
-    EXPECT_EQ(
-        0,
-        GetTrackedPrefHistogramCount(
-            "Settings.TrackedPreferenceMigratedLegacyDeviceId", ALLOW_NONE));
+                  user_tracked_prefs::kTrackedPreferenceMigratedLegacyDeviceId,
+                  ALLOW_NONE));
   }
 };
 
 PREF_HASH_BROWSER_TEST(PrefHashBrowserTestChangedAtomic, ChangedAtomic);
 
 // Verifies that changing or adding an entry in a split pref results in both
 // items being reported (and remove if the protection level allows it).
 class PrefHashBrowserTestChangedSplitPref : public PrefHashBrowserTestBase {
  public:
   void SetupPreferences() override {
@@ skipping 28 matching lines @@
     // don't need to be valid extension settings).
     base::DictionaryValue* fake_extension = new base::DictionaryValue;
     fake_extension->SetString("name", "foo");
     extensions_dict->Set(std::string(32, 'a'), fake_extension);
   }
 
   void VerifyReactionToPrefAttack() override {
     // Expect a single split pref changed report with a count of 2 for tracked
     // pref #5 (extensions).
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM ? 1 : 0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceChanged",
-                                           BEGIN_ALLOW_SINGLE_BUCKET + 5));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceChanged,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 5));
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM ? 1 : 0,
               GetTrackedPrefHistogramCount(
                   "Settings.TrackedSplitPreferenceChanged.extensions.settings",
                   BEGIN_ALLOW_SINGLE_BUCKET + 2));
 
     // Everything else should have remained unchanged.
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM
-                  ? num_tracked_prefs() - 1 : 0,
+                  ? num_tracked_prefs() - 1
+                  : 0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceUnchanged", ALLOW_ANY));
+                  user_tracked_prefs::kTrackedPreferenceUnchanged, ALLOW_ANY));
 
-    EXPECT_EQ(
-        (protection_level_ > PROTECTION_DISABLED_ON_PLATFORM &&
-         protection_level_ < PROTECTION_ENABLED_EXTENSIONS) ? 1 : 0,
-        GetTrackedPrefHistogramCount("Settings.TrackedPreferenceWantedReset",
-                                     BEGIN_ALLOW_SINGLE_BUCKET + 5));
+    EXPECT_EQ((protection_level_ > PROTECTION_DISABLED_ON_PLATFORM &&
+               protection_level_ < PROTECTION_ENABLED_EXTENSIONS)
+                  ? 1
+                  : 0,
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceWantedReset,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 5));
     EXPECT_EQ(protection_level_ >= PROTECTION_ENABLED_EXTENSIONS ? 1 : 0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceReset",
-                                           BEGIN_ALLOW_SINGLE_BUCKET + 5));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceReset,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 5));
 
     EXPECT_EQ(protection_level_ < PROTECTION_ENABLED_EXTENSIONS,
               extension_service()->GetExtensionById(kGoodCrxId, true) != NULL);
 
     // Nothing else should have triggered.
     EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceCleared",
-                                           ALLOW_NONE));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceCleared, ALLOW_NONE));
+    EXPECT_EQ(
+        0, GetTrackedPrefHistogramCount(
+               user_tracked_prefs::kTrackedPreferenceInitialized, ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceTrustedInitialized,
+                     ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceNullInitialized,
+                     ALLOW_NONE));
     EXPECT_EQ(0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceTrustedInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceNullInitialized", ALLOW_NONE));
-    EXPECT_EQ(
-        0,
-        GetTrackedPrefHistogramCount(
-            "Settings.TrackedPreferenceMigratedLegacyDeviceId", ALLOW_NONE));
+                  user_tracked_prefs::kTrackedPreferenceMigratedLegacyDeviceId,
+                  ALLOW_NONE));
   }
 };
 
 PREF_HASH_BROWSER_TEST(PrefHashBrowserTestChangedSplitPref, ChangedSplitPref);
 
 // Verifies that adding a value to unprotected preferences for a key which is
 // still using the default (i.e. has no value stored in protected preferences)
 // doesn't allow that value to slip in with no valid MAC (regression test for
 // http://crbug.com/414554)
 class PrefHashBrowserTestUntrustedAdditionToPrefs
@@ skipping 10 matching lines @@
       base::DictionaryValue* protected_preferences) override {
     unprotected_preferences->SetInteger(prefs::kRestoreOnStartup,
                                         SessionStartupPref::LAST);
   }
 
   void VerifyReactionToPrefAttack() override {
     // Expect a single Changed event for tracked pref #3 (kRestoreOnStartup) if
     // not protecting; if protection is enabled the change should be a no-op.
     int changed_expected =
         protection_level_ == PROTECTION_DISABLED_FOR_GROUP ? 1 : 0;
-    EXPECT_EQ(
-        (protection_level_ > PROTECTION_DISABLED_ON_PLATFORM &&
-         protection_level_ < PROTECTION_ENABLED_BASIC) ? changed_expected : 0,
-        GetTrackedPrefHistogramCount("Settings.TrackedPreferenceChanged",
-                                     BEGIN_ALLOW_SINGLE_BUCKET + 3));
+    EXPECT_EQ((protection_level_ > PROTECTION_DISABLED_ON_PLATFORM &&
+               protection_level_ < PROTECTION_ENABLED_BASIC)
+                  ? changed_expected
+                  : 0,
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceChanged,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 3));
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM
-                  ? num_tracked_prefs() - changed_expected : 0,
+                  ? num_tracked_prefs() - changed_expected
+                  : 0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceUnchanged", ALLOW_ANY));
+                  user_tracked_prefs::kTrackedPreferenceUnchanged, ALLOW_ANY));
 
-    EXPECT_EQ(
-        (protection_level_ > PROTECTION_DISABLED_ON_PLATFORM &&
-         protection_level_ < PROTECTION_ENABLED_BASIC) ? 1 : 0,
-        GetTrackedPrefHistogramCount("Settings.TrackedPreferenceWantedReset",
-                                     BEGIN_ALLOW_SINGLE_BUCKET + 3));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceReset",
-                                           ALLOW_NONE));
+    EXPECT_EQ((protection_level_ > PROTECTION_DISABLED_ON_PLATFORM &&
+               protection_level_ < PROTECTION_ENABLED_BASIC)
+                  ? 1
+                  : 0,
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceWantedReset,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 3));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceReset, ALLOW_NONE));
 
     // Nothing else should have triggered.
     EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceCleared",
-                                           ALLOW_NONE));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceCleared, ALLOW_NONE));
+    EXPECT_EQ(
+        0, GetTrackedPrefHistogramCount(
+               user_tracked_prefs::kTrackedPreferenceInitialized, ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceTrustedInitialized,
+                     ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceNullInitialized,
+                     ALLOW_NONE));
     EXPECT_EQ(0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceTrustedInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceNullInitialized", ALLOW_NONE));
-    EXPECT_EQ(
-        0,
-        GetTrackedPrefHistogramCount(
-            "Settings.TrackedPreferenceMigratedLegacyDeviceId", ALLOW_NONE));
+                  user_tracked_prefs::kTrackedPreferenceMigratedLegacyDeviceId,
+                  ALLOW_NONE));
   }
 };
 
 PREF_HASH_BROWSER_TEST(PrefHashBrowserTestUntrustedAdditionToPrefs,
                        UntrustedAdditionToPrefs);
 
 // Verifies that adding a value to unprotected preferences while wiping a
 // user-selected value from protected preferences doesn't allow that value to
 // slip in with no valid MAC (regression test for http://crbug.com/414554).
 class PrefHashBrowserTestUntrustedAdditionToPrefsAfterWipe
@@ skipping 17 matching lines @@
     // Expect a single Changed event for tracked pref #2 (kHomePage) if
     // not protecting; if protection is enabled the change should be a Cleared.
     int changed_expected =
         protection_level_ > PROTECTION_DISABLED_ON_PLATFORM &&
         protection_level_ < PROTECTION_ENABLED_BASIC
         ? 1 : 0;
     int cleared_expected =
         protection_level_ >= PROTECTION_ENABLED_BASIC
         ? 1 : 0;
     EXPECT_EQ(changed_expected,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceChanged",
-                                           BEGIN_ALLOW_SINGLE_BUCKET + 2));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceChanged,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 2));
     EXPECT_EQ(cleared_expected,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceCleared",
-                                           BEGIN_ALLOW_SINGLE_BUCKET + 2));
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceCleared,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 2));
     EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM
                   ? num_tracked_prefs() - changed_expected - cleared_expected
                   : 0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceUnchanged", ALLOW_ANY));
+                  user_tracked_prefs::kTrackedPreferenceUnchanged, ALLOW_ANY));
 
-    EXPECT_EQ(
-        changed_expected,
-        GetTrackedPrefHistogramCount("Settings.TrackedPreferenceWantedReset",
-                                     BEGIN_ALLOW_SINGLE_BUCKET + 2));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount("Settings.TrackedPreferenceReset",
-                                           ALLOW_NONE));
+    EXPECT_EQ(changed_expected,
+              GetTrackedPrefHistogramCount(
+                  user_tracked_prefs::kTrackedPreferenceWantedReset,
+                  BEGIN_ALLOW_SINGLE_BUCKET + 2));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceReset, ALLOW_NONE));
 
     // Nothing else should have triggered.
+    EXPECT_EQ(
+        0, GetTrackedPrefHistogramCount(
+               user_tracked_prefs::kTrackedPreferenceInitialized, ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceTrustedInitialized,
+                     ALLOW_NONE));
+    EXPECT_EQ(0, GetTrackedPrefHistogramCount(
+                     user_tracked_prefs::kTrackedPreferenceNullInitialized,
+                     ALLOW_NONE));
     EXPECT_EQ(0,
               GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceTrustedInitialized", ALLOW_NONE));
-    EXPECT_EQ(0,
-              GetTrackedPrefHistogramCount(
-                  "Settings.TrackedPreferenceNullInitialized", ALLOW_NONE));
-    EXPECT_EQ(
-        0,
-        GetTrackedPrefHistogramCount(
-            "Settings.TrackedPreferenceMigratedLegacyDeviceId", ALLOW_NONE));
+                  user_tracked_prefs::kTrackedPreferenceMigratedLegacyDeviceId,
+                  ALLOW_NONE));
   }
 };
 
 PREF_HASH_BROWSER_TEST(PrefHashBrowserTestUntrustedAdditionToPrefsAfterWipe,
                        UntrustedAdditionToPrefsAfterWipe);