Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(3662)

Unified Diff: chrome/browser/net/safe_search_util.cc

Issue 354183002: Enforce SafetyMode for YouTube if prefs::kForceSafeSearch is on. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: revert string_util.h change Created 6 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/browser/net/safe_search_util.h ('k') | chrome/browser/net/safe_search_util_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/net/safe_search_util.cc
diff --git a/chrome/browser/net/safe_search_util.cc b/chrome/browser/net/safe_search_util.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e94413cd48537292e842d414f6c663ea183a6768
--- /dev/null
+++ b/chrome/browser/net/safe_search_util.cc
@@ -0,0 +1,195 @@
+// 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/cookies/cookie_util.h"
+#include "net/http/http_request_headers.h"
+#include "net/url_request/url_request.h"
+#include "url/gurl.h"
+
+namespace {
+
+const char kYouTubePrefCookieName[] = "PREF";
+// 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);
+
+// 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, '&');
+}
+
+bool IsYouTubePrefCookie(const net::cookie_util::ParsedRequestCookie& cookie) {
+ return cookie.first == base::StringPiece(kYouTubePrefCookieName);
+}
+
+bool IsYouTubePrefCookieSafetyModeFlagsEntry(
+ const std::pair<std::string, std::string>& pref_entry) {
+ return pref_entry.first == kYouTubePrefCookieSafetyModeFlagsEntryName;
+}
+
+std::string JoinStringKeyValuePair(
+ const base::StringPairs::value_type& key_value,
+ char delimiter) {
+ return key_value.first + delimiter + key_value.second;
+}
+
+// Does the opposite of base::SplitStringIntoKeyValuePairs() from
+// base/strings/string_util.h.
+std::string JoinStringKeyValuePairs(const base::StringPairs& pairs,
+ char key_value_delimiter,
+ char key_value_pair_delimiter) {
+ if (pairs.empty())
+ return std::string();
+
+ base::StringPairs::const_iterator it = pairs.begin();
+ std::string result = JoinStringKeyValuePair(*it, key_value_delimiter);
+ ++it;
+
+ for (; it != pairs.end(); ++it) {
+ result += key_value_pair_delimiter;
+ result += JoinStringKeyValuePair(*it, key_value_delimiter);
+ }
+
+ return result;
+}
+
+} // 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);
+ net::cookie_util::ParsedRequestCookies cookies;
+ net::cookie_util::ParseRequestCookieLine(cookie_string, &cookies);
+
+ // Find YouTube's pref cookie, or add it if it doesn't exist yet.
+ net::cookie_util::ParsedRequestCookies::iterator pref_it =
+ std::find_if(cookies.begin(), cookies.end(), IsYouTubePrefCookie);
+ if (pref_it == cookies.end()) {
+ cookies.push_back(std::make_pair(base::StringPiece(kYouTubePrefCookieName),
+ base::StringPiece()));
+ pref_it = cookies.end() - 1;
+ }
+
+ // The pref cookie's value may be quoted. If so, remove the quotes.
+ std::string pref_string = pref_it->second.as_string();
+ bool pref_string_quoted = false;
+ if (pref_string.size() >= 2 &&
+ pref_string[0] == '\"' &&
+ pref_string[pref_string.size() - 1] == '\"') {
+ pref_string_quoted = true;
+ pref_string = pref_string.substr(1, pref_string.length() - 2);
+ }
+
+ // The pref cookie's value consists of key/value pairs. Parse them.
+ base::StringPairs pref_values;
+ base::SplitStringIntoKeyValuePairs(pref_string, '=', '&', &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("%x", flag_value);
+ pref_string = JoinStringKeyValuePairs(pref_values, '=', '&');
+ if (pref_string_quoted) {
+ pref_string = '\"' + pref_string + '\"';
+ }
+ pref_it->second = base::StringPiece(pref_string);
+ cookie_string = net::cookie_util::SerializeRequestCookieLine(cookies);
+ headers->SetHeader(base::StringPiece(net::HttpRequestHeaders::kCookie),
+ base::StringPiece(cookie_string));
+}
+
+} // namespace safe_search_util
« no previous file with comments | « chrome/browser/net/safe_search_util.h ('k') | chrome/browser/net/safe_search_util_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698