Recommit and fix of "Added a ForceYouTubeRestrict policy and deprecated the old ForceYouTubeSafetyM…

chrome/browser/policy/policy_browsertest.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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <string>
@@ skipping 865 matching lines @@
       policies->Set(key, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                     POLICY_SOURCE_CLOUD, std::move(value), nullptr);
     } else {
       policies->Erase(key);
     }
   }
 
   void ApplySafeSearchPolicy(
       std::unique_ptr<base::FundamentalValue> legacy_safe_search,
       std::unique_ptr<base::FundamentalValue> google_safe_search,
-      std::unique_ptr<base::FundamentalValue> youtube_safety_mode) {
+      std::unique_ptr<base::FundamentalValue> legacy_youtube,
+      std::unique_ptr<base::FundamentalValue> youtube_restrict) {
     PolicyMap policies;
     SetPolicy(&policies, key::kForceSafeSearch, std::move(legacy_safe_search));
     SetPolicy(&policies, key::kForceGoogleSafeSearch,
               std::move(google_safe_search));
     SetPolicy(&policies, key::kForceYouTubeSafetyMode,
-              std::move(youtube_safety_mode));
+              std::move(legacy_youtube));
+    SetPolicy(&policies, key::kForceYouTubeRestrict,
+              std::move(youtube_restrict));
     UpdateProviderPolicy(policies);
   }
 
   void CheckSafeSearch(bool expect_safe_search) {
     content::WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     content::TestNavigationObserver observer(web_contents);
     chrome::FocusLocationBar(browser());
     LocationBar* location_bar = browser()->window()->GetLocationBar();
     ui_test_utils::SendToOmniboxAndSubmit(location_bar, "http://google.com/");
@@ skipping 259 matching lines @@
           ->GetPolicyService()
           ->GetPolicies(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
   EXPECT_TRUE(expected.Equals(actual_from_browser));
   const PolicyMap& actual_from_profile =
       ProfilePolicyConnectorFactory::GetForBrowserContext(browser()->profile())
           ->policy_service()
           ->GetPolicies(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
   EXPECT_TRUE(expected.Equals(actual_from_profile));
 }
 
-IN_PROC_BROWSER_TEST_F(PolicyTest, ForceSafeSearch) {
+IN_PROC_BROWSER_TEST_F(PolicyTest, LegacySafeSearch) {
+  static_assert(safe_search_util::YOUTUBE_RESTRICT_OFF      == 0 &&
+                safe_search_util::YOUTUBE_RESTRICT_MODERATE == 1 &&
+                safe_search_util::YOUTUBE_RESTRICT_STRICT   == 2 &&
+                safe_search_util::YOUTUBE_RESTRICT_COUNT    == 3,
+                "This test relies on mapping ints to enum values.");
+
+  // Go over all combinations of (undefined, true, false) for the policies
+  // ForceSafeSearch, ForceGoogleSafeSearch and ForceYouTubeSafetyMode as well
+  // as (undefined, off, moderate, strict) for ForceYouTubeRestrict and make
+  // sure the prefs are set as expected.
+  const int num_restrict_modes = 1 + safe_search_util::YOUTUBE_RESTRICT_COUNT;
+  for (int i = 0; i < 3 * 3 * 3 * num_restrict_modes; i++) {
+    int val = i;
+    int legacy_safe_search = val % 3; val /= 3;
+    int google_safe_search = val % 3; val /= 3;
+    int legacy_youtube     = val % 3; val /= 3;
+    int youtube_restrict   = val % num_restrict_modes;
+
+    // Override the default SafeSearch setting using policies.
+    ApplySafeSearchPolicy(
+        legacy_safe_search == 0
+            ? nullptr
+            : base::MakeUnique<base::FundamentalValue>(legacy_safe_search == 1),
+        google_safe_search == 0
+            ? nullptr
+            : base::MakeUnique<base::FundamentalValue>(google_safe_search == 1),
+        legacy_youtube == 0
+            ? nullptr
+            : base::MakeUnique<base::FundamentalValue>(legacy_youtube == 1),
+        youtube_restrict == 0
+            ? nullptr  // subtracting 1 gives 0,1,2, see above
+            : base::MakeUnique<base::FundamentalValue>(youtube_restrict - 1));
+
+    // The legacy ForceSafeSearch policy should only have an effect if none of
+    // the other 3 policies are defined.
+    bool legacy_safe_search_in_effect =
+        google_safe_search == 0 && legacy_youtube == 0 &&
+        youtube_restrict == 0 && legacy_safe_search != 0;
+    bool legacy_safe_search_enabled =
+        legacy_safe_search_in_effect && legacy_safe_search == 1;
+
+    // Likewise, ForceYouTubeSafetyMode should only have an effect if
+    // ForceYouTubeRestrict is not set.
+    bool legacy_youtube_in_effect =
+        youtube_restrict == 0 && legacy_youtube != 0;
+    bool legacy_youtube_enabled =
+        legacy_youtube_in_effect && legacy_youtube == 1;
+
+    // Consistency check, can't have both legacy modes at the same time.
+    EXPECT_FALSE(legacy_youtube_in_effect && legacy_safe_search_in_effect);
+
+    // Google safe search can be triggered by the ForceGoogleSafeSearch policy
+    // or the legacy safe search mode.
+    PrefService* prefs = browser()->profile()->GetPrefs();
+    EXPECT_EQ(google_safe_search != 0 || legacy_safe_search_in_effect,
+              prefs->IsManagedPreference(prefs::kForceGoogleSafeSearch));
+    EXPECT_EQ(google_safe_search == 1 || legacy_safe_search_enabled,
+              prefs->GetBoolean(prefs::kForceGoogleSafeSearch));
+
+    // YouTube restrict mode can be triggered by the ForceYouTubeRestrict policy
+    // or any of the legacy modes.
+    EXPECT_EQ(youtube_restrict != 0 || legacy_safe_search_in_effect ||
+              legacy_youtube_in_effect,
+              prefs->IsManagedPreference(prefs::kForceYouTubeRestrict));
+
+    if (youtube_restrict != 0) {
+      // The ForceYouTubeRestrict policy should map directly to the pref.
+      EXPECT_EQ(youtube_restrict - 1,
+          prefs->GetInteger(prefs::kForceYouTubeRestrict));
+    } else {
+      // The legacy modes should result in MODERATE strictness, if enabled.
+      safe_search_util::YouTubeRestrictMode expected_mode =
+          legacy_safe_search_enabled || legacy_youtube_enabled
+            ? safe_search_util::YOUTUBE_RESTRICT_MODERATE
+            : safe_search_util::YOUTUBE_RESTRICT_OFF;
+      EXPECT_EQ(prefs->GetInteger(prefs::kForceYouTubeRestrict), expected_mode);
+    }
+  }
+}
+
+IN_PROC_BROWSER_TEST_F(PolicyTest, ForceGoogleSafeSearch) {
   // Makes the requests fail since all we want to check is that the redirection
   // is done properly.
   MakeRequestFail make_request_fail("google.com");
 
   // Verifies that requests to Google Search engine with the SafeSearch
   // enabled set the safe=active&ssui=on parameters at the end of the query.
   // First check that nothing happens.
   CheckSafeSearch(false);
 
-  // Go over all combinations of (undefined,true,false) for the three policies.
-  for (int i = 0; i < 3 * 3 * 3; i++) {
-    int legacy = i % 3;
-    int google = (i / 3) % 3;
-    int youtube = i / (3 * 3);
+  // Go over all combinations of (undefined, true, false) for the
+  // ForceGoogleSafeSearch policy.
+  for (int safe_search = 0; safe_search < 3; safe_search++) {
+    // Override the Google safe search policy.
+    ApplySafeSearchPolicy(
+        nullptr,          // ForceSafeSearch
+        safe_search == 0  // ForceGoogleSafeSearch
+            ? nullptr
+            : base::MakeUnique<base::FundamentalValue>(safe_search == 1),
+        nullptr,          // ForceYouTubeSafetyMode
+        nullptr           // ForceYouTubeRestrict
+    );
 
-    // Override the default SafeSearch setting using policies.
-    ApplySafeSearchPolicy(
-        legacy == 0 ? nullptr
-                    : base::MakeUnique<base::FundamentalValue>(legacy == 1),
-        google == 0 ? nullptr
-                    : base::MakeUnique<base::FundamentalValue>(google == 1),
-        youtube == 0 ? nullptr
-                     : base::MakeUnique<base::FundamentalValue>(youtube == 1));
-
-    // The legacy policy should only have an effect if both google and youtube
-    // are undefined.
-    bool legacy_in_effect = (google == 0 && youtube == 0 && legacy != 0);
-    bool legacy_enabled = legacy_in_effect && legacy == 1;
-
+    // Verify that the safe search pref behaves the way we expect.
     PrefService* prefs = browser()->profile()->GetPrefs();
-    EXPECT_EQ(google != 0 || legacy_in_effect,
+    EXPECT_EQ(safe_search != 0,
               prefs->IsManagedPreference(prefs::kForceGoogleSafeSearch));
-    EXPECT_EQ(google == 1 || legacy_enabled,
+    EXPECT_EQ(safe_search == 1,
               prefs->GetBoolean(prefs::kForceGoogleSafeSearch));
 
-    EXPECT_EQ(youtube != 0 || legacy_in_effect,
-              prefs->IsManagedPreference(prefs::kForceYouTubeSafetyMode));
-    EXPECT_EQ(youtube == 1 || legacy_enabled,
-              prefs->GetBoolean(prefs::kForceYouTubeSafetyMode));
-
-    CheckSafeSearch(google == 1 || legacy_enabled);
+    // Verify that safe search actually works.
+    CheckSafeSearch(safe_search == 1);
   }
 }
 
 IN_PROC_BROWSER_TEST_F(PolicyTest, Disable3DAPIs) {
   // This test assumes Gpu access.
   if (!content::GpuDataManager::GetInstance()->GpuAccessAllowed(NULL))
     return;
 
   ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL));
   // WebGL is enabled by default.
@@ skipping 3196 matching lines @@
 
   SetEmptyPolicy();
   // Policy not set.
   CheckSystemTimezoneAutomaticDetectionPolicyUnset();
   EXPECT_TRUE(CheckResolveTimezoneByGeolocation(true, false));
   EXPECT_TRUE(manager->TimeZoneResolverShouldBeRunningForTests());
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace policy