Remove the domain check gating settings protection.

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 47 matching lines @@
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
 #include "extensions/browser/pref_names.h"
 #endif
 
 #if defined(ENABLE_MANAGED_USERS)
 #include "chrome/browser/supervised_user/supervised_user_pref_store.h"
 #endif
 
-#if defined(OS_WIN)
-#include "base/win/win_util.h"
-#if defined(ENABLE_RLZ)
+#if defined(OS_WIN) && defined(ENABLE_RLZ)
 #include "rlz/lib/machine_id.h"
-#endif  // defined(ENABLE_RLZ)
-#endif  // defined(OS_WIN)
+#endif  // defined(ENABLE_RLZ) && defined(OS_WIN)
 
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace {
 
-// Whether we are in testing mode; can be enabled via
-// DisableDelaysAndDomainCheckForTesting(). Forces startup checks to occur
-// with no delay and ignores the presence of a domain when determining the
-// active SettingsEnforcement group.
-bool g_disable_delays_and_domain_check_for_testing = false;
-
 // 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.
 // See CleanupDeprecatedTrackedPreferences() in pref_hash_filter.cc to remove a
 // deprecated tracked preference.
 const PrefHashFilter::TrackedPreferenceMetadata kTrackedPrefs[] = {
   {
     0, prefs::kShowHomeButton,
     PrefHashFilter::ENFORCE_ON_LOAD,
@@ skipping 112 matching lines @@
   GROUP_ENFORCE_ALWAYS,
   // 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;
-    static const bool is_enrolled_to_domain = base::win::IsEnrolledToDomain();
-    if (first_call) {
-      UMA_HISTOGRAM_BOOLEAN("Settings.TrackedPreferencesNoEnforcementOnDomain",
-                            is_enrolled_to_domain);
-      first_call = false;
-    }
-    if (is_enrolled_to_domain)
-      return GROUP_NO_ENFORCEMENT;
-  }
-#endif
-
   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::
           kSettingsEnforcementGroupEnforceAlwaysWithDSE,
@@ skipping 257 matching lines @@
 
 void SchedulePrefsFilePathVerification(const base::FilePath& profile_path) {
 #if defined(OS_WIN)
   // Only do prefs file verification on Windows.
   const int kVerifyPrefsFileDelaySeconds = 60;
   BrowserThread::GetBlockingPool()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&VerifyPreferencesFile,
                  ProfilePrefStoreManager::GetPrefFilePathFromProfilePath(
                      profile_path)),
-      base::TimeDelta::FromSeconds(g_disable_delays_and_domain_check_for_testing
-                                       ? 0
-                                       : kVerifyPrefsFileDelaySeconds));
+      base::TimeDelta::FromSeconds(kVerifyPrefsFileDelaySeconds));

[robertshield, 2014/10/02 21:40:43]

do you not still desire to be able to disable the delay for testing?

[gab, 2014/10/02 21:46:00]

It wasn't used (i.e. nothing tests this -- removing the delay would force this
code to at least run incidentally as part of PrefHashBrowserTests which disabled
delays/domain_check for the sake of the domain_check only, but this wasn't
intentional... maybe a test for this could be introduced if you think it's
worthwhile).

FWIW, do we even still care about this verification?

[robertshield, 2014/10/02 21:53:03]

Not overly, no. I think this CL is fine as is.

 #endif
 }
 
-void DisableDelaysAndDomainCheckForTesting() {
-  g_disable_delays_and_domain_check_for_testing = true;
-}
-
 bool InitializePrefsFromMasterPrefs(
     const base::FilePath& profile_path,
     const base::DictionaryValue& master_prefs) {
   return CreateProfilePrefStoreManager(profile_path)
       ->InitializePrefsFromMasterPrefs(master_prefs);
 }
 
 base::Time GetResetTime(Profile* profile) {
   return ProfilePrefStoreManager::GetResetTime(profile->GetPrefs());
 }
 
 void ClearResetTime(Profile* profile) {
   ProfilePrefStoreManager::ClearResetTime(profile->GetPrefs());
 }
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   ProfilePrefStoreManager::RegisterProfilePrefs(registry);
 }
 
 void RegisterPrefs(PrefRegistrySimple* registry) {
   ProfilePrefStoreManager::RegisterPrefs(registry);
 }
 
 }  // namespace chrome_prefs