Add more Google domains to the list of domains which should have

chrome/browser/metrics/variations/variations_http_header_provider.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/metrics/variations/variations_http_header_provider.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/common/metrics/proto/chrome_experiments.pb.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/http/http_request_headers.h"
 #include "url/gurl.h"
 
 namespace chrome_variations {
 
+namespace {
+
+const char* kSuffixesToSetHeadersFor[] = {
+  "android.com",
+  "doubleclick.com",
+  "doubleclick.net",
+  "ggpht.com",
+  "googleadservices.com",
+  "googleapis.com",
+  "googlesyndication.com",
+  "googleusercontent.com",
+  "googlevideo.com",
+  "gstatic.com",
+  "ytimg.com",
+};
+
+}  // namespace
+
 VariationsHttpHeaderProvider* VariationsHttpHeaderProvider::GetInstance() {
   return Singleton<VariationsHttpHeaderProvider>::get();
 }
 
 void VariationsHttpHeaderProvider::AppendHeaders(
     const GURL& url,
     bool incognito,
     bool uma_enabled,
     net::HttpRequestHeaders* headers) {
   // Note the criteria for attaching Chrome experiment headers:
@@ skipping 55 matching lines @@
     if (trigger_id)
       default_trigger_id_set_.insert(variation_id);
     else
       default_variation_ids_set_.insert(variation_id);
   }
   return true;
 }
 
 VariationsHttpHeaderProvider::VariationsHttpHeaderProvider()
     : variation_ids_cache_initialized_(false) {
+  for (size_t i = 0; i < arraysize(kSuffixesToSetHeadersFor); ++i) {
+    suffixes_to_set_headers_for_.insert(kSuffixesToSetHeadersFor[i]);
+  }
 }
 
 VariationsHttpHeaderProvider::~VariationsHttpHeaderProvider() {
 }
 
 void VariationsHttpHeaderProvider::OnFieldTrialGroupFinalized(
     const std::string& trial_name,
     const std::string& group_name) {
   VariationID new_id =
       GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_name, group_name);
@@ skipping 101 matching lines @@
 
   std::string hashed;
   base::Base64Encode(serialized, &hashed);
   // If successful, swap the header value with the new one.
   // Note that the list of IDs and the header could be temporarily out of sync
   // if IDs are added as the header is recreated. The receiving servers are OK
   // with such discrepancies.
   variation_ids_header_ = hashed;
 }
 
-// static
 bool VariationsHttpHeaderProvider::ShouldAppendHeaders(const GURL& url) {
   if (google_util::IsGoogleDomainUrl(url, google_util::ALLOW_SUBDOMAIN,
                                      google_util::ALLOW_NON_STANDARD_PORTS)) {
     return true;
   }
 
   if (!url.is_valid() || !url.SchemeIsHTTPOrHTTPS())
     return false;
 
   // Some domains don't have international TLD extensions, so testing for them
   // is very straight forward.
   const std::string host = url.host();
-  if (EndsWith(host, ".doubleclick.net", false) ||
-      EndsWith(host, ".googlesyndication.com", false) ||
-      LowerCaseEqualsASCII(host, "www.googleadservices.com")) {
-    return true;
+  size_t suffix_start = host.length();
+  bool found_first_dot = false;
+  for (size_t i = host.length(); i > 0; --i) {
+    if (host[i - 1] != '.') {
+      continue;
+    }
+
+    if (!found_first_dot) {
+      found_first_dot = true;
+      continue;
+    }
+
+    suffix_start = i;
+    break;
+  }
+
+  if (suffix_start != host.length()) {
+    std::string suffix = StringToLowerASCII(host.substr(suffix_start));
+    if (ContainsKey(suffixes_to_set_headers_for_, suffix)) {
+      return true;
+    }
   }
 
   // The below mirrors logic in IsGoogleDomainUrl(), but for youtube.<TLD>.
   const size_t tld_length = net::registry_controlled_domains::GetRegistryLength(
       host,
       net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
       net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
   if ((tld_length == 0) || (tld_length == std::string::npos))
     return false;
 
   const std::string host_minus_tld(host, 0, host.length() - tld_length);
   return LowerCaseEqualsASCII(host_minus_tld, "youtube.") ||
       EndsWith(host_minus_tld, ".youtube.", false);
 }
 
 }  // namespace chrome_variations