X-Chrome-Variations logic refactoring

chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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/renderer_host/chrome_resource_dispatcher_host_delegate.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chrome_metrics_helper.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/download/download_resource_throttle.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/extensions/user_script_listener.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/net/load_timing_observer.h"
 #include "chrome/browser/net/resource_prefetch_predictor_observer.h"
 #include "chrome/browser/prerender/prerender_manager.h"
@@ skipping 58 matching lines @@
       content::NotificationService::NoDetails());
 }
 
 }  // end namespace
 
 ChromeResourceDispatcherHostDelegate::ChromeResourceDispatcherHostDelegate(
     prerender::PrerenderTracker* prerender_tracker)
     : download_request_limiter_(g_browser_process->download_request_limiter()),
       safe_browsing_(g_browser_process->safe_browsing_service()),
       user_script_listener_(new extensions::UserScriptListener()),
-      prerender_tracker_(prerender_tracker),
-      variation_ids_cache_initialized_(false) {
+      prerender_tracker_(prerender_tracker) {
 }
 
 ChromeResourceDispatcherHostDelegate::~ChromeResourceDispatcherHostDelegate() {
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldBeginRequest(
     int child_id,
     int route_id,
     const std::string& method,
     const GURL& url,
@@ skipping 55 matching lines @@
 #endif
 #if defined(OS_CHROMEOS)
   if (resource_type == ResourceType::MAIN_FRAME) {
     // We check offline first, then check safe browsing so that we still can
     // block unsafe site after we remove offline page.
     throttles->push_back(new OfflineResourceThrottle(
         child_id, route_id, request, appcache_service));
   }
 #endif
 
-  AppendChromeMetricsHeaders(request, resource_context, resource_type);
+  ChromeMetricsHelper::GetInstance()->AppendHeadersToRequest(request,
+                                                             resource_context);
 
 #if defined(ENABLE_ONE_CLICK_SIGNIN)
   AppendChromeSyncGaiaHeader(request, resource_context);
 #endif
 
   AppendStandardResourceThrottles(request,
                                   resource_context,
                                   child_id,
                                   route_id,
                                   resource_type,
@@ skipping 127 matching lines @@
         request, child_id, route_id, !is_subresource_request));
 #endif
 
   content::ResourceThrottle* throttle =
       user_script_listener_->CreateResourceThrottle(request->url(),
                                                     resource_type);
   if (throttle)
     throttles->push_back(throttle);
 }
 
-void ChromeResourceDispatcherHostDelegate::AppendChromeMetricsHeaders(
-    net::URLRequest* request,
-    content::ResourceContext* resource_context,
-    ResourceType::Type resource_type) {
-  // Don't attempt to append headers to requests that have already started.
-  // TODO(stevet): Remove this once the request ordering issues are resolved
-  // in crbug.com/128048.
-  if (request->is_pending())
-    return;
-
-  // Note the criteria for attaching Chrome experiment headers:
-  // 1. We only transmit to *.google.<TLD> domains. NOTE that this use of
-  //    google_util helpers to check this does not guarantee that the URL is
-  //    Google-owned, only that it is of the form *.google.<TLD>. In the future
-  //    we may choose to reinforce this check.
-  // 2. Only transmit for non-Incognito profiles.
-  // 3. For the X-Chrome-UMA-Enabled bit, only set it if UMA is in fact enabled
-  //    for this install of Chrome.
-  // 4. For the X-Chrome-Variations, only include non-empty variation IDs.
-  ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
-  if (io_data->is_incognito() ||
-      !google_util::IsGoogleDomainUrl(request->url().spec(),
-                                      google_util::ALLOW_SUBDOMAIN,
-                                      google_util::ALLOW_NON_STANDARD_PORTS))
-    return;
-
-  if (io_data->GetMetricsEnabledStateOnIOThread())
-    request->SetExtraRequestHeaderByName("X-Chrome-UMA-Enabled", "1", false);
-
-  // Lazily initialize the header, if not already done, before attempting to
-  // transmit it.
-  InitVariationIDsCacheIfNeeded();
-  if (!variation_ids_header_.empty()) {
-    request->SetExtraRequestHeaderByName("X-Chrome-Variations",
-        variation_ids_header_,
-        false);
-  }
-}
-
 #if defined(ENABLE_ONE_CLICK_SIGNIN)
 void ChromeResourceDispatcherHostDelegate::AppendChromeSyncGaiaHeader(
     net::URLRequest* request,
     content::ResourceContext* resource_context) {
   static const char kAllowChromeSignIn[] = "Allow-Chrome-SignIn";
 
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
   OneClickSigninHelper::Offer offer =
       OneClickSigninHelper::CanOfferOnIOThread(request, io_data);
   switch (offer) {
@@ skipping 87 matching lines @@
   OneClickSigninHelper::ShowInfoBarIfPossible(request, info->GetChildID(),
                                               info->GetRouteID());
 #endif
 
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
   if (io_data->resource_prefetch_predictor_observer()) {
     io_data->resource_prefetch_predictor_observer()->OnRequestRedirected(
         redirect_url, request);
   }
 }
-
-void ChromeResourceDispatcherHostDelegate::OnFieldTrialGroupFinalized(
-    const std::string& trial_name,
-    const std::string& group_name) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  chrome_variations::VariationID new_id =
-      chrome_variations::GetGoogleVariationID(
-          chrome_variations::GOOGLE_WEB_PROPERTIES, trial_name, group_name);
-  if (new_id == chrome_variations::kEmptyID)
-    return;
-  variation_ids_set_.insert(new_id);
-  UpdateVariationIDsHeaderValue();
-}
-
-void ChromeResourceDispatcherHostDelegate::InitVariationIDsCacheIfNeeded() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (variation_ids_cache_initialized_)
-    return;
-
-  // Register for additional cache updates. This is done first to avoid a race
-  // that could cause registered FieldTrials to be missed.
-  base::FieldTrialList::AddObserver(this);
-
-  base::FieldTrial::ActiveGroups initial_groups;
-  base::FieldTrialList::GetActiveFieldTrialGroups(&initial_groups);
-  for (base::FieldTrial::ActiveGroups::const_iterator it =
-       initial_groups.begin(); it != initial_groups.end(); ++it) {
-    const chrome_variations::VariationID id =
-        chrome_variations::GetGoogleVariationID(
-            chrome_variations::GOOGLE_WEB_PROPERTIES, it->trial_name,
-            it->group_name);
-    if (id != chrome_variations::kEmptyID)
-      variation_ids_set_.insert(id);
-  }
-  UpdateVariationIDsHeaderValue();
-
-  variation_ids_cache_initialized_ = true;
-}
-
-void ChromeResourceDispatcherHostDelegate::UpdateVariationIDsHeaderValue() {
-  // The header value is a serialized protobuffer of Variation IDs which is
-  // base64 encoded before transmitting as a string.
-  if (variation_ids_set_.empty())
-    return;
-
-  // This is the bottleneck for the creation of the header, so validate the size
-  // here. Force a hard maximum on the ID count in case the Variations server
-  // returns too many IDs and DOSs receiving servers with large requests.
-  DCHECK_LE(variation_ids_set_.size(), 10U);
-  if (variation_ids_set_.size() > 20) {
-    variation_ids_header_.clear();
-    return;
-  }
-
-  metrics::ChromeVariations proto;
-  for (std::set<chrome_variations::VariationID>::const_iterator it =
-      variation_ids_set_.begin(); it != variation_ids_set_.end(); ++it)
-    proto.add_variation_id(*it);
-
-  std::string serialized;
-  proto.SerializeToString(&serialized);
-
-  std::string hashed;
-  if (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 descrepancies.
-    variation_ids_header_ = hashed;
-  } else {
-    DVLOG(1) << "Failed to base64 encode Variation IDs value: " << serialized;
-  }
-}