Bring back the domain gating check for 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_SUPERVISED_USERS)
 #include "chrome/browser/supervised_user/supervised_user_pref_store.h"
 #endif
 
-#if defined(OS_WIN) && defined(ENABLE_RLZ)
+#if defined(OS_WIN)
+#include "base/win/win_util.h"
+#if defined(ENABLE_RLZ)
 #include "rlz/lib/machine_id.h"
-#endif  // defined(ENABLE_RLZ) && defined(OS_WIN)
+#endif  // defined(ENABLE_RLZ)
+#endif  // defined(OS_WIN)
 
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace {
 
+#if defined(OS_WIN)
+// Whether we are in testing mode; can be enabled via
+// DisableDomainCheckForTesting(). Forces startup checks to ignore the presence
+// of a domain when determining the active SettingsEnforcement group.
+bool g_disable_domain_check_for_testing = false;
+#endif  // OS_WIN
+
 // 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 154 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_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 253 matching lines @@
   const int kVerifyPrefsFileDelaySeconds = 60;
   BrowserThread::GetBlockingPool()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&VerifyPreferencesFile,
                  ProfilePrefStoreManager::GetPrefFilePathFromProfilePath(
                      profile_path)),
       base::TimeDelta::FromSeconds(kVerifyPrefsFileDelaySeconds));
 #endif
 }
 
+void DisableDomainCheckForTesting() {
+#if defined(OS_WIN)
+  g_disable_domain_check_for_testing = true;
+#endif  // OS_WIN
+}
+
 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