Google search subdomains included for Safesearch

components/google/core/browser/google_util.cc

 // Copyright 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 "components/google/core/browser/google_util.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 23 matching lines @@
 #endif
 
 namespace google_util {
 
 // Helpers --------------------------------------------------------------------
 
 namespace {
 
 bool gUseMockLinkDoctorBaseURLForTesting = false;
 
+const char* const gGoogleSearchSubdomains[] = {"ipv4.google.com",

[Ilya Sherman, 2017/05/11 00:33:35]

nit: s/g/k, since this is a constant.

[Peter Kasting, 2017/05/11 00:48:08]

Also, prefer to define this locally in the function that uses it.

Could probably be constexpr as well.

[igorcov, 2017/05/11 11:30:05]

Included all this locally inside a static set.

+                                               "ipv6.google.com"};
+
 bool IsPathHomePageBase(base::StringPiece path) {
   return (path == "/") || (path == "/webhp");
 }
 
+// Removes a single trailing dot if present in |host|.
+void StripTrailingDot(base::StringPiece* host) {
+  if (host->ends_with("."))
+    host->remove_suffix(1);
+}
+
 // True if the given canonical |host| is "[www.]<domain_in_lower_case>.<TLD>"
 // with a valid TLD. If |subdomain_permission| is ALLOW_SUBDOMAIN, we check
 // against host "*.<domain_in_lower_case>.<TLD>" instead. Will return the TLD
 // string in |tld|, if specified and the |host| can be parsed.
 bool IsValidHostName(base::StringPiece host,
                      base::StringPiece domain_in_lower_case,
                      SubdomainPermission subdomain_permission,
                      base::StringPiece* tld) {
   // Fast path to avoid searching the registry set.
   if (host.find(domain_in_lower_case) == base::StringPiece::npos)
@@ skipping 39 matching lines @@
 bool IsCanonicalHostGoogleHostname(base::StringPiece canonical_host,
                                    SubdomainPermission subdomain_permission) {
   const GURL& base_url(CommandLineGoogleBaseURL());
   if (base_url.is_valid() && (canonical_host == base_url.host_piece()))
     return true;
 
   base::StringPiece tld;
   if (!IsValidHostName(canonical_host, "google", subdomain_permission, &tld))
     return false;
 
+  // Remove the trailing dot from tld if present, as for google domain it's the
+  // same page.
+  StripTrailingDot(&tld);
+
   CR_DEFINE_STATIC_LOCAL(std::set<std::string>, google_tlds,
                          ({GOOGLE_TLD_LIST}));
   return base::ContainsKey(google_tlds, tld.as_string());
 }
 
 }  // namespace
 
 // Global functions -----------------------------------------------------------
 
 bool HasGoogleSearchQueryParam(base::StringPiece str) {
@@ skipping 24 matching lines @@
 }
 
 GURL AppendGoogleLocaleParam(const GURL& url,
                              const std::string& application_locale) {
   return net::AppendQueryParameter(
       url, "hl", GetGoogleLocale(application_locale));
 }
 
 std::string GetGoogleCountryCode(const GURL& google_homepage_url) {
   base::StringPiece google_hostname = google_homepage_url.host_piece();
+  // TODO(igorcov): This needs a fix for case when the host has a trailing dot,
+  // like "google.com./". https://crbug.com/720295.
   const size_t last_dot = google_hostname.find_last_of('.');
   if (last_dot == std::string::npos) {
     NOTREACHED();
   }
   base::StringPiece country_code = google_hostname.substr(last_dot + 1);
   // Assume the com TLD implies the US.
   if (country_code == "com")
     return "us";
   // Google uses the Unicode Common Locale Data Repository (CLDR), and the CLDR
   // code for the UK is "gb".
@@ skipping 47 matching lines @@
                                        subdomain_permission);
 }
 
 bool IsGoogleDomainUrl(const GURL& url,
                        SubdomainPermission subdomain_permission,
                        PortPermission port_permission) {
   return IsValidURL(url, port_permission) &&
          IsCanonicalHostGoogleHostname(url.host_piece(), subdomain_permission);
 }
 
+bool IsGoogleSearchSubdomainUrl(const GURL& url,
+                                PortPermission port_permission) {

[Peter Kasting, 2017/05/11 00:48:08]

Nit: Callers all seem to pass DISALLOW_NON_STANDARD_PORTS here, so I'd remove
this second argument and hardcode that.  (That goes for other functions above
too as applicable.)

[igorcov, 2017/05/11 11:30:05]

Done.

+  if (!IsValidURL(url, port_permission))
+    return false;
+
+  base::StringPiece host(url.host_piece());
+  StripTrailingDot(&host);
+
+  // If the size of |gGoogleSearchSubdomains| becomes larger, it might make
+  // sense to std::binary_search this.
+  for (const char* subdomain : gGoogleSearchSubdomains) {

[Peter Kasting, 2017/05/11 00:48:08]

Nit: It might make sense to CR_DEFINE_STATIC_LOCAL a string array, instead of
the char* array, so you can easily just use std::find() here.  Or possibly a
flat_map, which could be allocated to the right size and would have even simpler
syntax to use.  But maybe that's overkill.

[igorcov, 2017/05/11 11:30:05]

Done.

+    if (host == subdomain) {

[Peter Kasting, 2017/05/11 00:48:08]

Nit: {} not necessary

+      return true;
+    }
+  }
+
+  return false;
+}
+
 bool IsGoogleHomePageUrl(const GURL& url) {
   // First check to see if this has a Google domain.
-  if (!IsGoogleDomainUrl(url, DISALLOW_SUBDOMAIN, DISALLOW_NON_STANDARD_PORTS))
+  if (!IsGoogleDomainUrl(url, DISALLOW_SUBDOMAIN,
+                         DISALLOW_NON_STANDARD_PORTS) &&
+      !IsGoogleSearchSubdomainUrl(url, DISALLOW_NON_STANDARD_PORTS)) {
     return false;
+  }
 
   // Make sure the path is a known home page path.
   base::StringPiece path(url.path_piece());
   return IsPathHomePageBase(path) ||
          base::StartsWith(path, "/ig", base::CompareCase::INSENSITIVE_ASCII);
 }
 
 bool IsGoogleSearchUrl(const GURL& url) {
   // First check to see if this has a Google domain.
-  if (!IsGoogleDomainUrl(url, DISALLOW_SUBDOMAIN, DISALLOW_NON_STANDARD_PORTS))
+  if (!IsGoogleDomainUrl(url, DISALLOW_SUBDOMAIN,
+                         DISALLOW_NON_STANDARD_PORTS) &&
+      !IsGoogleSearchSubdomainUrl(url, DISALLOW_NON_STANDARD_PORTS)) {
     return false;
+  }
 
   // Make sure the path is a known search path.
   base::StringPiece path(url.path_piece());
   bool is_home_page_base = IsPathHomePageBase(path);
   if (!is_home_page_base && (path != "/search"))
     return false;
 
   // Check for query parameter in URL parameter and hash fragment, depending on
   // the path type.
   return HasGoogleSearchQueryParam(url.ref_piece()) ||
       (!is_home_page_base && HasGoogleSearchQueryParam(url.query_piece()));
 }
 
 bool IsYoutubeDomainUrl(const GURL& url,
                         SubdomainPermission subdomain_permission,
                         PortPermission port_permission) {
   return IsValidURL(url, port_permission) &&
       IsValidHostName(url.host_piece(), "youtube", subdomain_permission,
                       nullptr);
 }
 
 }  // namespace google_util