Added a ForceYouTubeRestrict policy and deprecated the old ForceYouTubeSafetyMode policy

chrome/browser/net/chrome_network_delegate_unittest.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/net/chrome_network_delegate.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 352 matching lines @@
 };
 
 class ChromeNetworkDelegateSafeSearchTest :
     public ChromeNetworkDelegatePolicyTest {
  public:
   void SetUp() override {
     ChromeNetworkDelegate::InitializePrefsOnUIThread(
         &enable_referrers_,
         nullptr,
         &force_google_safe_search_,
-        &force_youtube_safety_mode_,
+        &force_youtube_restrict_,
         nullptr,
         profile_.GetTestingPrefService());
   }
 
  protected:
   std::unique_ptr<net::NetworkDelegate> CreateNetworkDelegate() {
     std::unique_ptr<ChromeNetworkDelegate> network_delegate(
         new ChromeNetworkDelegate(forwarder(), &enable_referrers_,
                                   metrics::UpdateUsagePrefCallbackType()));
     network_delegate->set_force_google_safe_search(&force_google_safe_search_);
-    network_delegate->set_force_youtube_safety_mode(
-        &force_youtube_safety_mode_);
+    network_delegate->set_force_youtube_restrict(&force_youtube_restrict_);
     return std::move(network_delegate);
   }
 
-  void SetSafeSearch(bool google_safe_search,
-                     bool youtube_safety_mode) {
+  void SetSafeSearch(bool google_safe_search, int youtube_restrict) {
     force_google_safe_search_.SetValue(google_safe_search);
-    force_youtube_safety_mode_.SetValue(youtube_safety_mode);
+    force_youtube_restrict_.SetValue(youtube_restrict);
   }
 
   // Does a request to an arbitrary URL and verifies that the SafeSearch
   // enforcement utility functions were called/not called as expected.
-  void QueryURL(bool expect_google_safe_search,
-                bool expect_youtube_safety_mode) {
+  void QueryURL(bool expect_google_safe_search, bool expect_youtube_restrict) {
     safe_search_util::ClearForceGoogleSafeSearchCountForTesting();
-    safe_search_util::ClearForceYouTubeSafetyModeCountForTesting();
+    safe_search_util::ClearForceYouTubeRestrictCountForTesting();
 
     std::unique_ptr<net::URLRequest> request(context_.CreateRequest(
         GURL("http://anyurl.com"), net::DEFAULT_PRIORITY, &delegate_));
 
     request->Start();
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(expect_google_safe_search ? 1 : 0,
-        safe_search_util::GetForceGoogleSafeSearchCountForTesting());
-    EXPECT_EQ(expect_youtube_safety_mode ? 1 : 0,
-        safe_search_util::GetForceYouTubeSafetyModeCountForTesting());
+              safe_search_util::GetForceGoogleSafeSearchCountForTesting());
+    EXPECT_EQ(expect_youtube_restrict ? 1 : 0,
+              safe_search_util::GetForceYouTubeRestrictCountForTesting());
   }
 
  private:
   BooleanPrefMember force_google_safe_search_;
-  BooleanPrefMember force_youtube_safety_mode_;
+  IntegerPrefMember force_youtube_restrict_;
 };
 
 TEST_F(ChromeNetworkDelegateSafeSearchTest, SafeSearch) {
   std::unique_ptr<net::NetworkDelegate> delegate(CreateNetworkDelegate());
   SetDelegate(delegate.get());
 
   // Loop over all combinations of the two policies.
-  for (int i = 0; i < 4; i++) {
-    bool google_safe_search = i % 2;
-    bool youtube_safety_mode = i / 2;
-    SetSafeSearch(google_safe_search, youtube_safety_mode);
+  for (int i = 0; i < 6; i++) {
+    static_assert(
+      static_cast<int>(safe_search_util::YouTubeRestrictMode::OFF)      == 0 &&
+      static_cast<int>(safe_search_util::YouTubeRestrictMode::MODERATE) == 1 &&
+      static_cast<int>(safe_search_util::YouTubeRestrictMode::STRICT)   == 2,
+      "Adjust youtube_restrict to match YouTubeRestrictMode enum");
+    bool google_safe_search = (i / 3) != 0;
+    int youtube_restrict = i % 3;
+    SetSafeSearch(google_safe_search, youtube_restrict);
 
-    QueryURL(google_safe_search, youtube_safety_mode);
+    QueryURL(google_safe_search, youtube_restrict != 0);
   }
 }
 
 class ChromeNetworkDelegateAllowedDomainsTest :
     public ChromeNetworkDelegatePolicyTest {
  public:
 
   void SetUp() override {
     ChromeNetworkDelegate::InitializePrefsOnUIThread(
         &enable_referrers_,
@@ skipping 183 matching lines @@
 
   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
                                                        kBlockedFirstPartySite));
 
   cookie_settings_->SetCookieSetting(kBlockedFirstPartySite,
                                      CONTENT_SETTING_BLOCK);
   // Privacy mode is disabled as kAllowedSite is still getting cookies
   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
                                                        kBlockedFirstPartySite));
 }