Added a ForceYouTubeRestrict policy and deprecated the old ForceYouTubeSafetyMode policy

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 <limits.h>
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/net/disk_cache_dir_policy_handler.h"
+#include "chrome/browser/net/safe_search_util.h"
 #include "chrome/browser/policy/file_selection_dialogs_policy_handler.h"
 #include "chrome/browser/policy/javascript_policy_handler.h"
 #include "chrome/browser/policy/managed_bookmarks_policy_handler.h"
 #include "chrome/browser/policy/network_prediction_policy_handler.h"
 #include "chrome/browser/profiles/incognito_mode_policy_handler.h"
 #include "chrome/browser/sessions/restore_on_startup_policy_handler.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
 #include "components/bookmarks/common/bookmark_pref_names.h"
@@ skipping 83 matching lines @@
     base::Value::TYPE_BOOLEAN },
   { key::kPacHttpsUrlStrippingEnabled,
     prefs::kPacHttpsUrlStrippingEnabled,
     base::Value::TYPE_BOOLEAN },
   { key::kSafeBrowsingEnabled,
     prefs::kSafeBrowsingEnabled,
     base::Value::TYPE_BOOLEAN },
   { key::kForceGoogleSafeSearch,
     prefs::kForceGoogleSafeSearch,
     base::Value::TYPE_BOOLEAN },
-  { key::kForceYouTubeSafetyMode,
-    prefs::kForceYouTubeSafetyMode,
-    base::Value::TYPE_BOOLEAN },
+  { key::kForceYouTubeRestrict,
+    prefs::kForceYouTubeRestrict,
+    base::Value::TYPE_INTEGER},
   { key::kPasswordManagerEnabled,
     password_manager::prefs::kPasswordManagerSavingEnabled,
     base::Value::TYPE_BOOLEAN },
   { key::kPrintingEnabled,
     prefs::kPrintingEnabled,
     base::Value::TYPE_BOOLEAN },
   { key::kDisablePrintPreview,
     prefs::kPrintPreviewDisabled,
     base::Value::TYPE_BOOLEAN },
   { key::kDefaultPrinterSelection,
@@ skipping 473 matching lines @@
 class ForceSafeSearchPolicyHandler : public TypeCheckingPolicyHandler {
  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
-    // Note: Those policies are declared in kSimplePolicyMap above.
+    // If either of the new ForceGoogleSafeSearch, ForceYouTubeSafetyMode or
+    // ForceYouTubeRestrict policies are defined, then this one should be
+    // ignored. crbug.com/476908, crbug.com/590478
+    // Note: Those policies are declared in kSimplePolicyMap above. except

[Thiemo Nagel, 2016/10/05 17:38:14]

Nit: Since you're continuing with small caps, the period was probably intended
as a comma?

[ljusten (tachyonic), 2016/10/06 10:14:45]

Done.

+    //       ForceYouTubeSafetyMode, which has been replaced by

[Thiemo Nagel, 2016/10/05 17:38:14]

Nit: I'd suggest to not indent inside the comment, that'll safe you one line of
vertical space.

[ljusten (tachyonic), 2016/10/06 10:14:45]

Done.

+    //       ForceYouTubeRestrict.
     if (policies.GetValue(key::kForceGoogleSafeSearch) ||

[Thiemo Nagel, 2016/10/05 17:38:14]

As I read the code, the combination of ForceSafeSearch=true,
ForceGoogleSafeSearch=true policies leads to prefs
ForceYouTubeSafetyMode=undefined and ForceYouTubeRestrict=undefined.  That
doesn't seem right.

[ljusten (tachyonic), 2016/10/06 10:14:45]

This is correct, see crbug.com/476908. As soon as ForceGoogleSafeSearch is set,
it is understood that ForceSafeSearch is ignored. If we did set
ForceYouTubeRestrict=Moderate in this case (there is no ForceYouTubeSafetyMode
pref anymore), then on new clients Moderate would be enforced, whereas on old
clients we would not enforce restricted resp. safety mode.

[Thiemo Nagel, 2016/10/06 14:05:57]

Alright.  Thanks for updating the CL description to reflect that.

-        policies.GetValue(key::kForceYouTubeSafetyMode)) {
+        policies.GetValue(key::kForceYouTubeSafetyMode) ||
+        policies.GetValue(key::kForceYouTubeRestrict)) {
       return;
     }
     const base::Value* value = policies.GetValue(policy_name());
     if (value) {
+      bool enabled;
       prefs->SetValue(prefs::kForceGoogleSafeSearch, value->CreateDeepCopy());
-      prefs->SetValue(prefs::kForceYouTubeSafetyMode, value->CreateDeepCopy());
+
+      // Note that ForceYouTubeRestrict is an int policy,

[Thiemo Nagel, 2016/10/05 17:38:14]

Nit: Please wrap comments at 80 characters.

[ljusten (tachyonic), 2016/10/06 10:14:45]

Done.

+      // we cannot simply deep copy value, which is a boolean.
+      if (value->GetAsBoolean(&enabled)) {
+        prefs->SetValue(
+            prefs::kForceYouTubeRestrict,
+            base::MakeUnique<base::FundamentalValue>(static_cast<int>(
+                enabled ? safe_search_util::YouTubeRestrictMode::kModerate
+                        : safe_search_util::YouTubeRestrictMode::kOff)));
+      }
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ForceSafeSearchPolicyHandler);
 };
 
+class ForceYouTubeSafetyModePolicyHandler : public TypeCheckingPolicyHandler {
+ public:
+  ForceYouTubeSafetyModePolicyHandler()
+      : TypeCheckingPolicyHandler(key::kForceYouTubeSafetyMode,
+                                  base::Value::TYPE_BOOLEAN) {}
+  ~ForceYouTubeSafetyModePolicyHandler() override {}
+
+  // ConfigurationPolicyHandler implementation:
+  void ApplyPolicySettings(const PolicyMap& policies,
+                           PrefValueMap* prefs) override {
+    // If only the deprecated ForceYouTubeSafetyMode policy is set,
+    // but not ForceYouTubeRestrict, set ForceYouTubeRestrict to Moderate.
+    if (policies.GetValue(key::kForceYouTubeRestrict))
+      return;
+
+    const base::Value* value = policies.GetValue(policy_name());
+    bool enabled;
+    if (value && value->GetAsBoolean(&enabled)) {
+      prefs->SetValue(
+          prefs::kForceYouTubeRestrict,
+          base::MakeUnique<base::FundamentalValue>(static_cast<int>(
+              enabled ? safe_search_util::YouTubeRestrictMode::kModerate
+                      : safe_search_util::YouTubeRestrictMode::kOff)));
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ForceYouTubeSafetyModePolicyHandler);
+};
+
 #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 30 matching lines @@
           base::Bind(&GetChromePolicyDetails)));
   for (size_t i = 0; i < arraysize(kSimplePolicyMap); ++i) {
     handlers->AddHandler(base::MakeUnique<SimplePolicyHandler>(
         kSimplePolicyMap[i].policy_name, kSimplePolicyMap[i].preference_path,
         kSimplePolicyMap[i].value_type));
   }
 
   handlers->AddHandler(base::MakeUnique<AutofillPolicyHandler>());
   handlers->AddHandler(base::MakeUnique<DefaultSearchPolicyHandler>());
   handlers->AddHandler(base::MakeUnique<ForceSafeSearchPolicyHandler>());
+  handlers->AddHandler(base::MakeUnique<ForceYouTubeSafetyModePolicyHandler>());
   handlers->AddHandler(base::MakeUnique<IncognitoModePolicyHandler>());
   handlers->AddHandler(
       base::MakeUnique<ManagedBookmarksPolicyHandler>(chrome_schema));
   handlers->AddHandler(base::MakeUnique<ProxyPolicyHandler>());
   handlers->AddHandler(base::MakeUnique<URLBlacklistPolicyHandler>());
 
   handlers->AddHandler(base::MakeUnique<SimpleSchemaValidatingPolicyHandler>(
       key::kCertificateTransparencyEnforcementDisabledForUrls,
       certificate_transparency::prefs::kCTExcludedHosts, chrome_schema,
       SCHEMA_STRICT, SimpleSchemaValidatingPolicyHandler::RECOMMENDED_ALLOWED,
@@ skipping 185 matching lines @@
       SimpleSchemaValidatingPolicyHandler::MANDATORY_PROHIBITED)));
   handlers->AddHandler(
       base::MakeUnique<chromeos::KeyPermissionsPolicyHandler>(chrome_schema));
   handlers->AddHandler(base::WrapUnique(new DefaultGeolocationPolicyHandler()));
 #endif  // defined(OS_CHROMEOS)
 
   return handlers;
 }
 
 }  // namespace policy