Cache the Windows Parental Controls Platform Answer

chrome/browser/prefs/incognito_mode_prefs.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/incognito_mode_prefs.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 
 #if defined(OS_WIN)
 #include "base/win/metro.h"
 #endif  // OS_WIN
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/android/chromium_application.h"
 #endif  // OS_ANDROID
 
 #if defined(OS_WIN)
 namespace {
 
-bool g_parental_control_on = false;
+// Possible values for the parental controls state.
+enum class ParentalControlsState {
+  // Parental controls state unknown. We have not queried for this value yet.
+  UNKNOWN = 0,
+  // Parental controls activity logging disabled.
+  ACTIVITY_LOGGING_DISABLED = 1,
+  // Parental controls activity logging enabled.
+  ACTIVITY_LOGGING_ENABLED = 2,
+};
+ParentalControlsState g_parental_controls_state =
+    ParentalControlsState::UNKNOWN;
 
 } // empty namespace
 #endif  // OS_WIN
 
 // static
 bool IncognitoModePrefs::IntToAvailability(int in_value,
                                            Availability* out_value) {
   if (in_value < 0 || in_value >= AVAILABILITY_NUM_TYPES) {
     *out_value = ENABLED;
     return false;
   }
   *out_value = static_cast<Availability>(in_value);
   return true;
 }
 
 // static
 IncognitoModePrefs::Availability IncognitoModePrefs::GetAvailability(
     const PrefService* pref_service) {
   DCHECK(pref_service);
   int pref_value = pref_service->GetInteger(prefs::kIncognitoModeAvailability);
   Availability result = IncognitoModePrefs::ENABLED;
   bool valid = IntToAvailability(pref_value, &result);
   DCHECK(valid);
-  if (ArePlatformParentalControlsEnabled()) {
+  if (ArePlatformParentalControlsEnabledCached()) {
     if (result == IncognitoModePrefs::FORCED)
       LOG(ERROR) << "Ignoring FORCED incognito. Parental control logging on";
     return IncognitoModePrefs::DISABLED;
   }
   return result;
 }
 
 // static
 void IncognitoModePrefs::SetAvailability(PrefService* prefs,
                                          const Availability availability) {
@@ skipping 33 matching lines @@
 
     case IncognitoModePrefs::FORCED:
       return profile->IsOffTheRecord();
 
     default:
       NOTREACHED();
       return false;
   }
 }
 
-// static
-bool IncognitoModePrefs::ArePlatformParentalControlsEnabled() {
+void IncognitoModePrefs::InitializePlatformParentalControls() {
 #if defined(OS_WIN)
-  // Disable incognito mode windows if parental controls are on. This is only
-  // for Windows Vista and above.
-  return base::win::IsParentalControlActivityLoggingOn();
+  DCHECK(g_parental_controls_state == ParentalControlsState::UNKNOWN);
+  g_parental_controls_state =
+      base::win::IsParentalControlActivityLoggingOn() ?
+          ParentalControlsState::ACTIVITY_LOGGING_ENABLED :
+          ParentalControlsState::ACTIVITY_LOGGING_DISABLED;
+#endif  // defined(OS_WIN)
+}
+
+void IncognitoModePrefs::UninitializePlatformParentalControlsImpl() {
+#if defined(OS_WIN)
+  g_parental_controls_state = ParentalControlsState::UNKNOWN;

[msw, 2015/02/28 01:05:33]

Why do tests have to do this? Will the system value actually change?

[robliao, 2015/02/28 01:16:31]

Turns out this state is shared between groups of test cases in a single process
(since this is a global).

This means if one test case initializes this, all other ones get the
initialization for free. Of course this means if you reorder the test cases or
run them in complete isolation, things will break. 

The cleanup here ensures the initialization only occurs once and tests that need
to do this will break if they don't perform the initialization.

+#endif  // defined(OS_WIN)
+}
+
+bool IncognitoModePrefs::ArePlatformParentalControlsEnabledCached() {
+#if defined(OS_WIN)
+  DCHECK(g_parental_controls_state != ParentalControlsState::UNKNOWN);
+  return g_parental_controls_state ==
+      ParentalControlsState::ACTIVITY_LOGGING_ENABLED;
 #elif defined(OS_ANDROID)
   return chrome::android::ChromiumApplication::AreParentalControlsEnabled();
 #else
-  return false;
-#endif
-}
-
-#if defined(OS_WIN)
-void IncognitoModePrefs::InitializePlatformParentalControls() {
-  g_parental_control_on = base::win::IsParentalControlActivityLoggingOn();
-}
-#endif // OS_WIN
-
-bool IncognitoModePrefs::ArePlatformParentalControlsEnabledCached() {
-#if defined(OS_WIN)
-  return g_parental_control_on;
-#elif defined(OS_ANDROID)
-  return chrome::android::ChromiumApplication::AreParentalControlsEnabled();
-#else
   return false;
 #endif
 }