Added a ForceYouTubeRestrict policy and deprecated the old ForceYouTubeSafetyMode policy

chrome/browser/net/chrome_network_delegate.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 <stddef.h>
 #include <stdlib.h>
 
 #include <vector>
@@ skipping 14 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/cookie_settings_factory.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/net/chrome_extensions_network_delegate.h"
 #include "chrome/browser/net/request_source_bandwidth_histograms.h"
-#include "chrome/browser/net/safe_search_util.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/task_manager/task_manager_interface.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
 #include "components/content_settings/core/browser/cookie_settings.h"
 #include "components/data_usage/core/data_use_aggregator.h"
 #include "components/domain_reliability/monitor.h"
 #include "components/policy/core/browser/url_blacklist_manager.h"
 #include "components/prefs/pref_member.h"
@@ skipping 92 matching lines @@
     }
   }
 }
 
 }  // namespace
 
 ChromeNetworkDelegate::ChromeNetworkDelegate(
     extensions::EventRouterForwarder* event_router,
     BooleanPrefMember* enable_referrers,
     const metrics::UpdateUsagePrefCallbackType& metrics_data_use_forwarder)
-    : profile_(NULL),
+    : profile_(nullptr),
       enable_referrers_(enable_referrers),
-      enable_do_not_track_(NULL),
-      force_google_safe_search_(NULL),
-      force_youtube_safety_mode_(NULL),
+      enable_do_not_track_(nullptr),
+      force_google_safe_search_(nullptr),
+      force_youtube_restrict_(nullptr),
       allowed_domains_for_apps_(nullptr),
-      url_blacklist_manager_(NULL),
-      domain_reliability_monitor_(NULL),
+      url_blacklist_manager_(nullptr),
+      domain_reliability_monitor_(nullptr),
       data_use_measurement_(metrics_data_use_forwarder),
       experimental_web_platform_features_enabled_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnableExperimentalWebPlatformFeatures)),
       data_use_aggregator_(nullptr),
       is_data_usage_off_the_record_(true) {
   DCHECK(enable_referrers);
   extensions_delegate_.reset(
       ChromeExtensionsNetworkDelegate::Create(event_router));
 }
@@ skipping 20 matching lines @@
     bool is_data_usage_off_the_record) {
   data_use_aggregator_ = data_use_aggregator;
   is_data_usage_off_the_record_ = is_data_usage_off_the_record;
 }
 
 // static
 void ChromeNetworkDelegate::InitializePrefsOnUIThread(
     BooleanPrefMember* enable_referrers,
     BooleanPrefMember* enable_do_not_track,
     BooleanPrefMember* force_google_safe_search,
-    BooleanPrefMember* force_youtube_safety_mode,
+    IntegerPrefMember* force_youtube_restrict,
     StringPrefMember* allowed_domains_for_apps,
     PrefService* pref_service) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   enable_referrers->Init(prefs::kEnableReferrers, pref_service);
   enable_referrers->MoveToThread(
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
   if (enable_do_not_track) {
     enable_do_not_track->Init(prefs::kEnableDoNotTrack, pref_service);
     enable_do_not_track->MoveToThread(
         BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
   }
   if (force_google_safe_search) {
     force_google_safe_search->Init(prefs::kForceGoogleSafeSearch, pref_service);
     force_google_safe_search->MoveToThread(
         BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
   }
-  if (force_youtube_safety_mode) {
-    force_youtube_safety_mode->Init(prefs::kForceYouTubeSafetyMode,
-                                    pref_service);
-    force_youtube_safety_mode->MoveToThread(
+  if (force_youtube_restrict) {
+    force_youtube_restrict->Init(prefs::kForceYouTubeRestrict, pref_service);
+    force_youtube_restrict->MoveToThread(
         BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
   }
   if (allowed_domains_for_apps) {
     allowed_domains_for_apps->Init(prefs::kAllowedDomainsForApps, pref_service);
     allowed_domains_for_apps->MoveToThread(
         BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
   }
 }
 
 // static
@@ skipping 80 matching lines @@
                                          true);
   }
 
   return rv;
 }
 
 int ChromeNetworkDelegate::OnBeforeStartTransaction(
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
-  if (force_youtube_safety_mode_ && force_youtube_safety_mode_->GetValue())
-    safe_search_util::ForceYouTubeSafetyMode(request, headers);
+  if (force_youtube_restrict_ &&
+      force_youtube_restrict_->GetValue() != safe_search_util::YOUTUBE_OFF)
+    safe_search_util::ForceYouTubeRestrict(
+        request, headers, static_cast<safe_search_util::YouTubeRestrictMode>(
+                              force_youtube_restrict_->GetValue()));
 
   return extensions_delegate_->OnBeforeStartTransaction(request, callback,
                                                         headers);
 }
 
 void ChromeNetworkDelegate::OnStartTransaction(
     net::URLRequest* request,
     const net::HttpRequestHeaders& headers) {
   extensions_delegate_->OnStartTransaction(request, headers);
 }
@@ skipping 79 matching lines @@
     const net::AuthChallengeInfo& auth_info,
     const AuthCallback& callback,
     net::AuthCredentials* credentials) {
   return extensions_delegate_->OnAuthRequired(
       request, auth_info, callback, credentials);
 }
 
 bool ChromeNetworkDelegate::OnCanGetCookies(
     const net::URLRequest& request,
     const net::CookieList& cookie_list) {
-  // NULL during tests, or when we're running in the system context.
+  // nullptr during tests, or when we're running in the system context.
   if (!cookie_settings_.get())
     return true;
 
   bool allow = cookie_settings_->IsReadingCookieAllowed(
       request.url(), request.first_party_for_cookies());
 
   int render_process_id = -1;
   int render_frame_id = -1;
   if (content::ResourceRequestInfo::GetRenderFrameForRequest(
           &request, &render_process_id, &render_frame_id)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&TabSpecificContentSettings::CookiesRead,
                    render_process_id, render_frame_id,
                    request.url(), request.first_party_for_cookies(),
                    cookie_list, !allow));
   }
 
   return allow;
 }
 
 bool ChromeNetworkDelegate::OnCanSetCookie(const net::URLRequest& request,
                                            const std::string& cookie_line,
                                            net::CookieOptions* options) {
-  // NULL during tests, or when we're running in the system context.
+  // nullptr during tests, or when we're running in the system context.
   if (!cookie_settings_.get())
     return true;
 
   bool allow = cookie_settings_->IsSettingCookieAllowed(
       request.url(), request.first_party_for_cookies());
 
   int render_process_id = -1;
   int render_frame_id = -1;
   if (content::ResourceRequestInfo::GetRenderFrameForRequest(
           &request, &render_process_id, &render_frame_id)) {
@@ skipping 85 matching lines @@
   }
 
   DVLOG(1) << "File access denied - " << path.value().c_str();
   return false;
 #endif  // !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
 }
 
 bool ChromeNetworkDelegate::OnCanEnablePrivacyMode(
     const GURL& url,
     const GURL& first_party_for_cookies) const {
-  // NULL during tests, or when we're running in the system context.
+  // nullptr during tests, or when we're running in the system context.
   if (!cookie_settings_.get())
     return false;
 
   bool reading_cookie_allowed = cookie_settings_->IsReadingCookieAllowed(
       url, first_party_for_cookies);
   bool setting_cookie_allowed = cookie_settings_->IsSettingCookieAllowed(
       url, first_party_for_cookies);
   bool privacy_mode = !(reading_cookie_allowed && setting_cookie_allowed);
   return privacy_mode;
 }
@@ skipping 24 matching lines @@
   if (!data_use_aggregator_)
     return;
 
   if (is_data_usage_off_the_record_) {
     data_use_aggregator_->ReportOffTheRecordDataUse(tx_bytes, rx_bytes);
     return;
   }
 
   data_use_aggregator_->ReportDataUse(request, tx_bytes, rx_bytes);
 }