Policy: Ignore ForceSafeSearch if ForceGoogleSafeSearch or ForceYoutubeSafetyMode are enabled

chrome/browser/policy/configuration_policy_handler_list_factory.cc

 // Copyright 2013 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/policy/configuration_policy_handler_list_factory.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
+#include "base/prefs/pref_value_map.h"
 #include "base/values.h"
 #include "chrome/browser/net/proxy_policy_handler.h"
 #include "chrome/browser/policy/managed_bookmarks_policy_handler.h"
 #include "chrome/browser/profiles/incognito_mode_policy_handler.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "components/policy/core/browser/autofill_policy_handler.h"
 #include "components/policy/core/browser/configuration_policy_handler.h"
 #include "components/policy/core/browser/configuration_policy_handler_list.h"
@@ skipping 72 matching lines @@
     base::Value::TYPE_BOOLEAN },
   { key::kWPADQuickCheckEnabled,
     prefs::kQuickCheckEnabled,
     base::Value::TYPE_BOOLEAN },
   { key::kDisableSpdy,
     prefs::kDisableSpdy,
     base::Value::TYPE_BOOLEAN },
   { key::kSafeBrowsingEnabled,
     prefs::kSafeBrowsingEnabled,
     base::Value::TYPE_BOOLEAN },
-  { key::kForceSafeSearch,
-    prefs::kForceSafeSearch,
-    base::Value::TYPE_BOOLEAN },
   { key::kForceGoogleSafeSearch,
     prefs::kForceGoogleSafeSearch,
     base::Value::TYPE_BOOLEAN },
   { key::kForceYouTubeSafetyMode,
     prefs::kForceYouTubeSafetyMode,
     base::Value::TYPE_BOOLEAN },
   { key::kPasswordManagerEnabled,
     password_manager::prefs::kPasswordManagerSavingEnabled,
     base::Value::TYPE_BOOLEAN },
   { key::kPasswordManagerAllowShowPasswords,
@@ skipping 381 matching lines @@
     base::Value::TYPE_BOOLEAN },
   { key::kBrowserGuestModeEnabled,
     prefs::kBrowserGuestModeEnabled,
     base::Value::TYPE_BOOLEAN },
   { key::kBrowserAddPersonEnabled,
     prefs::kBrowserAddPersonEnabled,
     base::Value::TYPE_BOOLEAN },
 #endif  // !defined(OS_CHROMEOS) && !defined(OS_ANDROID) && !defined(OS_IOS)
 };
 
+class ForceSafeSearchPolicyHandler : public TypeCheckingPolicyHandler {

[Mattias Nissler (ping if slow), 2015/04/16 13:10:47]

What you have works. However, I think an easier-to-follow solution would be to
drop the simple mappings declared above and move the responsibility for mapping
prefs::kFocreGoogleSafeSearch and prefs::kForceYouToubeSafetyMode into a single
place, namely this handler. That way, the reader has all the logic deciding the
pref values in one place and doesn't need to be aware of the simple mapping
declared in the table above.

[Marc Treib, 2015/04/16 13:18:23]

I considered that, and I actually prefer the way it is now: If you're only
interested in the non-legacy policies, you see the simple mapping above and know
all you need to know. Only the weirdly-behaving legacy policy has special code.
And if we can ever actually remove the legacy policy, it's as simple as removing
this class.
I've added a comment that refers to kSimplePolicyMap though :)

[Mattias Nissler (ping if slow), 2015/04/16 13:27:56]

I suppose somebody trying to understand how these policies work would prefer to
have the full story told in a single place. Your comment achieves that same goal
though, so fine with me.

+ public:
+  ForceSafeSearchPolicyHandler()
+      : TypeCheckingPolicyHandler(key::kForceSafeSearch,
+                                  base::Value::TYPE_BOOLEAN) {}
+  ~ForceSafeSearchPolicyHandler() override {}
+
+  // ConfigurationPolicyHandler implementation:
+  void ApplyPolicySettings(const PolicyMap& policies,
+                           PrefValueMap* prefs) override {
+    // If either of the new GoogleSafeSearch or YouTubeSafetyMode policies is
+    // defined, then this one should be ignored. crbug.com/476908
+    if (policies.GetValue(key::kForceGoogleSafeSearch) ||
+        policies.GetValue(key::kForceYouTubeSafetyMode)) {
+      return;
+    }
+    const base::Value* value = policies.GetValue(policy_name());
+    if (value) {
+      prefs->SetValue(prefs::kForceGoogleSafeSearch, value->DeepCopy());
+      prefs->SetValue(prefs::kForceYouTubeSafetyMode, value->DeepCopy());
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ForceSafeSearchPolicyHandler);
+};
+
 #if defined(ENABLE_EXTENSIONS)
 void GetExtensionAllowedTypesMap(
     ScopedVector<StringMappingListPolicyHandler::MappingEntry>* result) {
   // Mapping from extension type names to Manifest::Type.
   for (size_t index = 0;
        index < extensions::schema_constants::kAllowedTypesMapSize;
        ++index) {
     const extensions::schema_constants::AllowedTypesMapEntry& entry =
         extensions::schema_constants::kAllowedTypesMap[index];
     result->push_back(new StringMappingListPolicyHandler::MappingEntry(
@@ skipping 32 matching lines @@
           base::Bind(&PopulatePolicyHandlerParameters),
           base::Bind(&GetChromePolicyDetails)));
   for (size_t i = 0; i < arraysize(kSimplePolicyMap); ++i) {
     handlers->AddHandler(make_scoped_ptr(new SimplePolicyHandler(
         kSimplePolicyMap[i].policy_name, kSimplePolicyMap[i].preference_path,
         kSimplePolicyMap[i].value_type)));
   }
 
   handlers->AddHandler(make_scoped_ptr(new AutofillPolicyHandler()));
   handlers->AddHandler(make_scoped_ptr(new DefaultSearchPolicyHandler()));
+  handlers->AddHandler(make_scoped_ptr(new ForceSafeSearchPolicyHandler()));
   handlers->AddHandler(make_scoped_ptr(new IncognitoModePolicyHandler()));
   handlers->AddHandler(
       make_scoped_ptr(new ManagedBookmarksPolicyHandler(chrome_schema)));
   handlers->AddHandler(make_scoped_ptr(new ProxyPolicyHandler()));
   handlers->AddHandler(make_scoped_ptr(new URLBlacklistPolicyHandler()));
 
 #if defined(OS_ANDROID)
   handlers->AddHandler(
       make_scoped_ptr(new ContextualSearchPolicyHandlerAndroid()));
 #endif
@@ skipping 187 matching lines @@
   handlers->AddHandler(make_scoped_ptr(new SimpleSchemaValidatingPolicyHandler(
       key::kSessionLocales, NULL, chrome_schema, SCHEMA_STRICT,
       SimpleSchemaValidatingPolicyHandler::RECOMMENDED_ALLOWED,
       SimpleSchemaValidatingPolicyHandler::MANDATORY_PROHIBITED)));
 #endif  // defined(OS_CHROMEOS)
 
   return handlers.Pass();
 }
 
 }  // namespace policy