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) {

[Alexei Svitkine (slow), 2014/05/30 17:23:10]

Can you use string::find_last_of() instead?

(the size_t find_last_of (const char* s, size_t pos, size_t n) const; version
can take |n| as a param I think).

[Ryan Hamilton, 2014/05/30 19:04:38]

I tried that, but it doesn't seem to work. Here's the documentation on that
method. Unless I'm misreading, "n" doesn't affect the number of occurrences to
search for, but rather the number of characters in s to consider:

Pointer to an array of characters.
If argument n is specified (3), the first n characters in the array are searched
for.
Otherwise (2), a null-terminated sequence is expected: the length of the
sequence with the characters to match is determined by the first occurrence of a
null character.

But if I'm misreading this, I'd be happy to use it. I tried:

  size_t suffix_start = host.find_last_of(".", host.length(), 2);

[Alexei Svitkine (slow), 2014/05/30 19:06:19]

I see. Perhaps just call it twice then?

[Ryan Hamilton, 2014/05/30 19:24:57]

Heh, sure. Done.

+    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));

[Alexei Svitkine (slow), 2014/05/30 17:23:10]

Wait, what if it's not ASCII?

[Ryan Hamilton, 2014/05/30 19:04:38]

All of the suffixes in "suffixes_to_set_headers_for_" are ASCII. So if host
contains non-ASCII, we won't lower case it. But that's fine because it wasn't
going to match anyway.

+    if (ContainsKey(suffixes_to_set_headers_for_, suffix)) {

[Alexei Svitkine (slow), 2014/05/30 17:23:10]

Nit: No {}'s

[Ryan Hamilton, 2014/05/30 19:04:38]

Done.

+      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