Flip Finch Configs so we can harden DSE w/o extensions

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 <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 167 matching lines @@
 const size_t kTrackedPrefsReportingIDsCount = 16;
 COMPILE_ASSERT(kTrackedPrefsReportingIDsCount >= arraysize(kTrackedPrefs),
                need_to_increment_ids_count);
 
 // Each group enforces a superset of the protection provided by the previous
 // one.
 enum SettingsEnforcementGroup {
   GROUP_NO_ENFORCEMENT,
   // Enforce protected settings on profile loads.
   GROUP_ENFORCE_ALWAYS,
-  // Also enforce extension settings.
-  GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS,
+  // Also enforce extension default search.
+  GROUP_ENFORCE_ALWAYS_WITH_DSE,
   // Also enforce extension settings and default search.
   GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS_AND_DSE,
   // The default enforcement group contains all protection features.
   GROUP_ENFORCE_DEFAULT
 };
 
 SettingsEnforcementGroup GetSettingsEnforcementGroup() {
 # if defined(OS_WIN)
   if (!g_disable_delays_and_domain_check_for_testing) {
     static bool first_call = true;
@@ skipping 10 matching lines @@
 
   struct {
     const char* group_name;
     SettingsEnforcementGroup group;
   } static const kEnforcementLevelMap[] = {
     { chrome_prefs::internals::kSettingsEnforcementGroupNoEnforcement,
       GROUP_NO_ENFORCEMENT },
     { chrome_prefs::internals::kSettingsEnforcementGroupEnforceAlways,
       GROUP_ENFORCE_ALWAYS },
     { chrome_prefs::internals::
-          kSettingsEnforcementGroupEnforceAlwaysWithExtensions,
-      GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS },
+          kSettingsEnforcementGroupEnforceAlwaysWithDSE,
+      GROUP_ENFORCE_ALWAYS_WITH_DSE },
     { chrome_prefs::internals::
           kSettingsEnforcementGroupEnforceAlwaysWithExtensionsAndDSE,
       GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS_AND_DSE },
   };
 
   // Use the no enforcement setting in the absence of a field trial
   // config. Remember to update the OFFICIAL_BUILD section of
   // extension_startup_browsertest.cc when updating the default value below.
   // TODO(gab): Change this to the strongest enforcement on all platforms.
   SettingsEnforcementGroup enforcement_group = GROUP_NO_ENFORCEMENT;
@@ skipping 28 matching lines @@
 
   std::vector<PrefHashFilter::TrackedPreferenceMetadata> result;
   for (size_t i = 0; i < arraysize(kTrackedPrefs); ++i) {
     PrefHashFilter::TrackedPreferenceMetadata data = kTrackedPrefs[i];
 
     if (GROUP_NO_ENFORCEMENT == enforcement_group) {
       // Remove enforcement for all tracked preferences.
       data.enforcement_level = PrefHashFilter::NO_ENFORCEMENT;
     }
 
-    if (enforcement_group >= GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS &&
+    if (enforcement_group >= GROUP_ENFORCE_ALWAYS_WITH_DSE &&
+        data.name == DefaultSearchManager::kDefaultSearchProviderDataPrefName) {
+      // Specifically enable default search settings enforcement.
+      data.enforcement_level = PrefHashFilter::ENFORCE_ON_LOAD;
+    }
+
+    if (enforcement_group >= GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS_AND_DSE &&
         (data.name == extensions::pref_names::kExtensions ||
          data.name == extensions::pref_names::kKnownDisabled)) {
       // Specifically enable extension settings enforcement and ensure
       // kKnownDisabled follows it in the Protected Preferences.
       // TODO(gab): Get rid of kKnownDisabled altogether.
       data.enforcement_level = PrefHashFilter::ENFORCE_ON_LOAD;
     }
 
-    if (enforcement_group >= GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS_AND_DSE &&
-        data.name == DefaultSearchManager::kDefaultSearchProviderDataPrefName) {
-      // Specifically enable default search settings enforcement.
-      data.enforcement_level = PrefHashFilter::ENFORCE_ON_LOAD;
-    }
-
     result.push_back(data);
   }
   return result;
 }
 
 
 // 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.
@@ skipping 89 matching lines @@
 
 }  // namespace
 
 namespace chrome_prefs {
 
 namespace internals {
 
 const char kSettingsEnforcementTrialName[] = "SettingsEnforcement";
 const char kSettingsEnforcementGroupNoEnforcement[] = "no_enforcement";
 const char kSettingsEnforcementGroupEnforceAlways[] = "enforce_always";
-const char kSettingsEnforcementGroupEnforceAlwaysWithExtensions[] =
-    "enforce_always_with_extensions";
+const char kSettingsEnforcementGroupEnforceAlwaysWithDSE[] =
+    "enforce_always_with_dse";
 const char kSettingsEnforcementGroupEnforceAlwaysWithExtensionsAndDSE[] =
     "enforce_always_with_extensions_and_dse";
 
 }  // namespace internals
 
 scoped_ptr<PrefService> CreateLocalState(
     const base::FilePath& pref_filename,
     base::SequencedTaskRunner* pref_io_task_runner,
     policy::PolicyService* policy_service,
     const scoped_refptr<PrefRegistry>& pref_registry,
@@ skipping 74 matching lines @@
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   ProfilePrefStoreManager::RegisterProfilePrefs(registry);
 }
 
 void RegisterPrefs(PrefRegistrySimple* registry) {
   ProfilePrefStoreManager::RegisterPrefs(registry);
 }
 
 }  // namespace chrome_prefs