Coarser levels for the SettingsEnforcement field trial.

chrome/browser/prefs/chrome_pref_service_factory.cc

 // Copyright (c) 2012 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/chrome_pref_service_factory.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
@@ skipping 51 matching lines @@
 
 namespace {
 
 // These preferences must be kept in sync with the TrackedPreference enum in
 // tools/metrics/histograms/histograms.xml. To add a new preference, append it
 // to the array and add a corresponding value to the histogram enum. Each
 // tracked preference must be given a unique reporting ID.
 const PrefHashFilter::TrackedPreferenceMetadata kTrackedPrefs[] = {
   {
     0, prefs::kShowHomeButton,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
   {
     1, prefs::kHomePageIsNewTabPage,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
   {
     2, prefs::kHomePage,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
   {
     3, prefs::kRestoreOnStartup,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
   {
     4, prefs::kURLsToRestoreOnStartup,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
   {
     5, extensions::pref_names::kExtensions,
     PrefHashFilter::NO_ENFORCEMENT,
     PrefHashFilter::TRACKING_STRATEGY_SPLIT
   },
   {
     6, prefs::kGoogleServicesLastUsername,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
   {
     7, prefs::kSearchProviderOverrides,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
   {
     8, prefs::kDefaultSearchProviderSearchURL,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
   {
     9, prefs::kDefaultSearchProviderKeyword,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
   {
     10, prefs::kDefaultSearchProviderName,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
 #if !defined(OS_ANDROID)
   {
     11, prefs::kPinnedTabs,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
 #endif
   {
     12, extensions::pref_names::kKnownDisabled,
     PrefHashFilter::NO_ENFORCEMENT,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
   {
     13, prefs::kProfileResetPromptMemento,
-    PrefHashFilter::ENFORCE_ALL,
+    PrefHashFilter::ENFORCE_ON_LOAD,
     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
   },
 };
 
 // The count of tracked preferences IDs across all platforms.
 const size_t kTrackedPrefsReportingIDsCount = 14;
 COMPILE_ASSERT(kTrackedPrefsReportingIDsCount >= arraysize(kTrackedPrefs),
                need_to_increment_ids_count);
 
-PrefHashFilter::EnforcementLevel GetSettingsEnforcementLevel() {
+enum SettingsEnforcementGroup {
+  GROUP_NO_ENFORCEMENT,
+  GROUP_ENFORCE_ON_LOAD,
+  GROUP_ENFORCE_ALWAYS

[robertshield, 2014/02/11 21:16:40]

Comments re. what these mean plz.

[gab, 2014/02/11 21:25:58]

Done.

+};
+
+SettingsEnforcementGroup GetSettingsEnforcementGroup() {
   static const char kSettingsEnforcementExperiment[] = "SettingsEnforcement";
   struct {
-    const char* level_name;
-    PrefHashFilter::EnforcementLevel level;
+    const char* group_name;
+    SettingsEnforcementGroup group;
   } static const kEnforcementLevelMap[] = {
-    {
-      "no_enforcement",
-      PrefHashFilter::NO_ENFORCEMENT
-    },
-    {
-      "enforce",
-      PrefHashFilter::ENFORCE
-    },
-    {
-      "enforce_no_seeding",
-      PrefHashFilter::ENFORCE_NO_SEEDING
-    },
-    {
-      "enforce_no_seeding_no_migration",
-      PrefHashFilter::ENFORCE_NO_SEEDING_NO_MIGRATION
-    },
+    { "no_enforcement", GROUP_NO_ENFORCEMENT },
+    { "enforce_on_load", GROUP_ENFORCE_ON_LOAD },
+    { "enforce_always", GROUP_ENFORCE_ALWAYS },

[robertshield, 2014/02/11 21:16:40]

GROUP_ENFORCE_ALWAYS isn't currently used, tell me again why we need it in this
CL?

[gab, 2014/02/11 21:25:58]

Added TODO above.

   };
-  COMPILE_ASSERT(ARRAYSIZE_UNSAFE(kEnforcementLevelMap) ==
-                     (PrefHashFilter::ENFORCE_ALL -
-                      PrefHashFilter::NO_ENFORCEMENT),
-                 missing_enforcement_level);
 
   base::FieldTrial* trial =
       base::FieldTrialList::Find(kSettingsEnforcementExperiment);
   if (trial) {
     const std::string& group_name = trial->group_name();
     // ARRAYSIZE_UNSAFE must be used since the array is declared locally; it is
     // only unsafe because it could not trigger a compile error on some
     // non-array pointer types; this is fine since kEnforcementLevelMap is
     // clearly an array.
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kEnforcementLevelMap); ++i) {
-      if (kEnforcementLevelMap[i].level_name == group_name)
-        return kEnforcementLevelMap[i].level;
+      if (kEnforcementLevelMap[i].group_name == group_name)
+        return kEnforcementLevelMap[i].group;
     }
   }
 #if defined(OS_WIN)
-  // Default to ENFORCE_ALL in the absence of a valid value for the
+  // Default to GROUP_ENFORCE_ALWAYS in the absence of a valid value for the
   // SettingsEnforcement field trial.
   // TODO(gab): Switch other platforms over to this mode.
-  return PrefHashFilter::ENFORCE_ALL;
+  return GROUP_ENFORCE_ALWAYS;
 #else
-  return PrefHashFilter::NO_ENFORCEMENT;
+  return GROUP_NO_ENFORCEMENT;
 #endif
 }
 
 // Shows notifications which correspond to PersistentPrefStore's reading errors.
 void HandleReadError(PersistentPrefStore::PrefReadError error) {
   // Sample the histogram also for the successful case in order to get a
   // baseline on the success rate in addition to the error distribution.
   UMA_HISTOGRAM_ENUMERATION("PrefService.ReadError", error,
                             PersistentPrefStore::PREF_READ_ERROR_MAX_ENUM);
 
@@ skipping 52 matching lines @@
   return make_scoped_ptr(new PrefHashStoreImpl(
       profile_path.AsUTF8Unsafe(),
       seed,
       device_id,
       g_browser_process->local_state()));
 #endif
 }
 
 scoped_ptr<PrefHashFilter> CreatePrefHashFilter(
     scoped_ptr<PrefHashStore> pref_hash_store) {
+  const PrefHashFilter::EnforcementLevel enforcement_level =
+      GetSettingsEnforcementGroup() == GROUP_NO_ENFORCEMENT ?
+          PrefHashFilter::NO_ENFORCEMENT : PrefHashFilter::ENFORCE_ON_LOAD;

[robertshield, 2014/02/11 21:16:40]

Can this still live in a GetSettingsEnforcementLevel function? I kind of liked
having all the logic for the enforcement level computation in one place.

[gab, 2014/02/11 21:25:58]

No; GROUP_ENFORCE_ALWAYS means to not do unloaded profile initialization (which
is not a concept PrefHashFilter knows about); that group will be handled in this
file only.

   return make_scoped_ptr(new PrefHashFilter(pref_hash_store.Pass(),
                                             kTrackedPrefs,
                                             arraysize(kTrackedPrefs),
                                             kTrackedPrefsReportingIDsCount,
-                                            GetSettingsEnforcementLevel()));
+                                            enforcement_level));
 }
 
 void PrepareBuilder(
     PrefServiceSyncableFactory* factory,
     const base::FilePath& pref_filename,
     base::SequencedTaskRunner* pref_io_task_runner,
     policy::PolicyService* policy_service,
     ManagedUserSettingsService* managed_user_settings,
     scoped_ptr<PrefHashStore> pref_hash_store,
     const scoped_refptr<PrefStore>& extension_prefs,
@@ skipping 203 matching lines @@
     CreatePrefHashFilter(
         GetPrefHashStoreImpl(profile_path).PassAs<PrefHashStore>())->
             Initialize(*pref_store);
   }
 
   UMA_HISTOGRAM_BOOLEAN("Settings.InitializedFromMasterPrefs", success);
   return success;
 }
 
 }  // namespace chrome_prefs