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

chrome/browser/net/safe_search_util.cc

+// Copyright (c) 2014 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/safe_search_util.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "chrome/common/url_constants.h"
+#include "components/google/core/browser/google_util.h"
+#include "net/http/http_request_headers.h"
+#include "net/url_request/url_request.h"
+#include "url/gurl.h"
+
+namespace {
+
+// Returns whether a URL parameter, |first_parameter| (e.g. foo=bar), has the
+// same key as the the |second_parameter| (e.g. foo=baz). Both parameters
+// must be in key=value form.
+bool HasSameParameterKey(const std::string& first_parameter,
+                         const std::string& second_parameter) {
+  DCHECK(second_parameter.find("=") != std::string::npos);
+  // Prefix for "foo=bar" is "foo=".
+  std::string parameter_prefix = second_parameter.substr(
+      0, second_parameter.find("=") + 1);
+  return StartsWithASCII(first_parameter, parameter_prefix, false);
+}
+
+// Examines the query string containing parameters and adds the necessary ones
+// so that SafeSearch is active. |query| is the string to examine and the
+// return value is the |query| string modified such that SafeSearch is active.
+std::string AddSafeSearchParameters(const std::string& query) {
+  std::vector<std::string> new_parameters;
+  std::string safe_parameter = chrome::kSafeSearchSafeParameter;
+  std::string ssui_parameter = chrome::kSafeSearchSsuiParameter;
+
+  std::vector<std::string> parameters;
+  base::SplitString(query, '&', &parameters);
+
+  std::vector<std::string>::iterator it;
+  for (it = parameters.begin(); it < parameters.end(); ++it) {
+    if (!HasSameParameterKey(*it, safe_parameter) &&
+        !HasSameParameterKey(*it, ssui_parameter)) {
+      new_parameters.push_back(*it);
+    }
+  }
+
+  new_parameters.push_back(safe_parameter);
+  new_parameters.push_back(ssui_parameter);
+  return JoinString(new_parameters, '&');
+}
+
+const char kYoutubePrefCookieName[] = "PREF";

[Pam (message me for reviews), 2014/07/07 19:23:10]

nit: YouTube should have a capital T, here and throughout the CL

+// 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;
+}
+
+} // namespace
+
+namespace safe_search_util {
+
+// If |request| is a request to Google Web Search the function
+// enforces that the SafeSearch query parameters are set to active.
+// Sets the query part of |new_url| with the new value of the parameters.
+void ForceGoogleSafeSearch(const net::URLRequest* request, GURL* new_url) {
+  if (!google_util::IsGoogleSearchUrl(request->url()) &&
+      !google_util::IsGoogleHomePageUrl(request->url()))
+    return;
+
+  std::string query = request->url().query();
+  std::string new_query = AddSafeSearchParameters(query);
+  if (query == new_query)
+    return;
+
+  GURL::Replacements replacements;
+  replacements.SetQueryStr(new_query);
+  *new_url = request->url().ReplaceComponents(replacements);
+}
+
+// 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) {
+  if (!google_util::IsYoutubeDomainUrl(
+          request->url(),
+          google_util::ALLOW_SUBDOMAIN,
+          google_util::DISALLOW_NON_STANDARD_PORTS))
+    return;
+
+  // Get the cookie string from the headers and parse it into key/value pairs.
+  std::string cookie_string;
+  headers->GetHeader(base::StringPiece(net::HttpRequestHeaders::kCookie),
+                     &cookie_string);
+  base::StringPairs cookies;
+  base::SplitStringIntoKeyValuePairs(cookie_string, '=', ';', &cookies);
+
+  // Find Youtube's pref cookie, or add it if it doesn't exist yet.
+  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;
+  }
+
+  // The pref cookie's value again consists of key/value pairs. Parse them.
+  base::StringPairs pref_values;
+  base::SplitStringIntoKeyValuePairs(pref_it->second, '=', '&', &pref_values);
+
+  // Find the "flags" entry that contains the Safety Mode flag, or add it if it
+  // doesn't exist.
+  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);
+  }
+
+  // Set the Safety Mode bit.
+  flag_value |= kYoutubePrefCookieSafetyModeFlagsEntryValue;
+
+  // Finally, put it all back together and replace the original cookie string.
+  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));
+}
+
+}  // namespace safe_search_util