Enforce SafetyMode for YouTube if prefs::kForceSafeSearch is on.

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 <stdlib.h>
 
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/cookie_settings.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/client_hints.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/performance_monitor/performance_monitor.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
@@ skipping 124 matching lines @@
 void ForceGoogleSafeSearchCallbackWrapper(
     const net::CompletionCallback& callback,
     net::URLRequest* request,
     GURL* new_url,
     int rv) {
   if (rv == net::OK && new_url->is_empty())
     ForceGoogleSafeSearch(request, new_url);
   callback.Run(rv);
 }
 
+const char kYoutubePrefCookieName[] = "PREF";

[battre, 2014/07/07 09:00:06]

What do you think of moving the youtube and safebrowsing code into a separate
file? This manipulation of bits feels like very grungy code.

Please add a unit test.

[Marc Treib, 2014/07/07 16:06:46]

It is grungy :-/
I moved the code into new safe_search_util.h/cc files.
Done.

+// Youtube pref flags are stored in bit masks of 31 bits each, called "f1",
+// "f2" etc. The Safety Mode flag is bit 58, so bit 27 in "f2".
+const char kYoutubePrefCookieSafetyModeFlagsEntryName[] = "f2";
+const int kYoutubePrefCookieSafetyModeFlagsEntryValue = (1 << 27);
+const char kYoutubePrefCookieFlagsValueFormat[] = "%x";
+
+bool IsYoutubePrefCookie(const std::pair<std::string, std::string>& cookie) {
+  return cookie.first == kYoutubePrefCookieName;
+}
+
+bool IsYoutubePrefCookieSafetyModeFlagsEntry(
+    const std::pair<std::string, std::string>& pref_entry) {
+  return pref_entry.first == kYoutubePrefCookieSafetyModeFlagsEntryName;
+}
+
+// If |request| is a request to Youtube, enforces Youtube's Safety Mode by
+// adding/modifying Youtube's PrefCookie header.
+void ForceYoutubeSafetyMode(const net::URLRequest* request,
+                            net::HttpRequestHeaders* headers) {

[battre, 2014/07/07 09:00:06]

Could you add more newlines into this function and document what the blocks are
doing?

[Marc Treib, 2014/07/07 16:06:46]

Done.

+  if (!google_util::IsYoutubeDomainUrl(
+          request->url(),
+          google_util::ALLOW_SUBDOMAIN,
+          google_util::DISALLOW_NON_STANDARD_PORTS))
+    return;
+
+  std::string cookie_string;
+  headers->GetHeader(base::StringPiece(net::HttpRequestHeaders::kCookie),
+                     &cookie_string);
+  base::StringPairs cookies;
+  base::SplitStringIntoKeyValuePairs(cookie_string, '=', ';', &cookies);
+  base::StringPairs::iterator pref_it =
+      std::find_if(cookies.begin(), cookies.end(), IsYoutubePrefCookie);
+  if (pref_it == cookies.end()) {
+    cookies.push_back(std::make_pair(std::string(kYoutubePrefCookieName),
+                                     std::string()));
+    pref_it = cookies.end() - 1;
+  }
+  base::StringPairs pref_values;
+  base::SplitStringIntoKeyValuePairs(pref_it->second, '=', '&', &pref_values);
+  base::StringPairs::iterator flag_it =
+      std::find_if(pref_values.begin(), pref_values.end(),
+                   IsYoutubePrefCookieSafetyModeFlagsEntry);
+  int flag_value = 0;
+  if (flag_it == pref_values.end()) {
+    pref_values.push_back(
+        std::make_pair(std::string(kYoutubePrefCookieSafetyModeFlagsEntryName),
+                       std::string()));
+    flag_it = pref_values.end() - 1;
+  } else {
+    base::HexStringToInt(base::StringPiece(flag_it->second), &flag_value);
+  }
+  flag_value |= kYoutubePrefCookieSafetyModeFlagsEntryValue;
+  flag_it->second =
+      base::StringPrintf(kYoutubePrefCookieFlagsValueFormat, flag_value);
+  pref_it->second = JoinStringKeyValuePairs(pref_values, '=', '&');
+  cookie_string = JoinStringKeyValuePairs(cookies, '=', ';');
+  headers->SetHeader(base::StringPiece(net::HttpRequestHeaders::kCookie),
+                     base::StringPiece(cookie_string));
+}
+
 void UpdateContentLengthPrefs(
     int received_content_length,
     int original_content_length,
     data_reduction_proxy::DataReductionProxyRequestType request_type,
     Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_GE(received_content_length, 0);
   DCHECK_GE(original_content_length, 0);
 
   // Can be NULL in a unit test.
@@ skipping 297 matching lines @@
   if (connect_interceptor_)
     connect_interceptor_->WitnessURLRequest(request);
 
   return rv;
 }
 
 int ChromeNetworkDelegate::OnBeforeSendHeaders(
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
+  bool force_safe_search = force_google_safe_search_ &&
+                           force_google_safe_search_->GetValue();
+  if (force_safe_search)
+    ForceYoutubeSafetyMode(request, headers);
+
   TRACE_EVENT_ASYNC_STEP_PAST0("net", "URLRequest", request, "SendRequest");
   return extensions_delegate_->OnBeforeSendHeaders(request, callback, headers);
 }
 
 void ChromeNetworkDelegate::OnBeforeSendProxyHeaders(
     net::URLRequest* request,
     const net::ProxyInfo& proxy_info,
     net::HttpRequestHeaders* headers) {
   if (data_reduction_proxy_auth_request_handler_) {
     data_reduction_proxy_auth_request_handler_->MaybeAddRequestHeader(
@@ skipping 333 matching lines @@
     data_reduction_proxy::DataReductionProxyRequestType request_type) {
   DCHECK_GE(received_content_length, 0);
   DCHECK_GE(original_content_length, 0);
   StoreAccumulatedContentLength(received_content_length,
                                 original_content_length,
                                 request_type,
                                 reinterpret_cast<Profile*>(profile_));
   received_content_length_ += received_content_length;
   original_content_length_ += original_content_length;
 }