Support delta-compressed variations server responses.

chrome/browser/metrics/variations/variations_service.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_service.h"
 
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 202 matching lines @@
   const base::Time seed_date = base::Time::FromInternalValue(date_value);
   const base::Time build_time = base::GetBuildTime();
   // Use the build time for date checks if either the seed date is invalid or
   // the build time is newer than the seed date.
   base::Time reference_date = seed_date;
   if (seed_date.is_null() || seed_date < build_time)
     reference_date = build_time;
   return reference_date;
 }
 
+// Returns the header value for |name| from |headers| or an empty string if not
+// set.
+std::string GetHeaderValue(const net::HttpResponseHeaders* headers,
+                           const base::StringPiece& name) {
+  std::string value;
+  headers->EnumerateHeader(NULL, name, &value);
+  return value;
+}
+
 // Overrides the string resource sepecified by |hash| with |string| in the
 // resource bundle. Used as a callback passed to the variations seed processor.
 void OverrideUIString(uint32_t hash, const base::string16& string) {
   int resource_id = GetResourceIndex(hash);
   if (resource_id == -1)
     return;
 
   ui::ResourceBundle::GetSharedInstance().OverrideLocaleStringResource(
       resource_id, string);
 }
 
 }  // namespace
 
 VariationsService::VariationsService(
     web_resource::ResourceRequestAllowedNotifier* notifier,
     PrefService* local_state,
     metrics::MetricsStateManager* state_manager)
     : local_state_(local_state),
       state_manager_(state_manager),
       policy_pref_service_(local_state),
       seed_store_(local_state),
       create_trials_from_seed_called_(false),
       initial_request_completed_(false),
+      disable_deltas_for_next_request_(false),
       resource_request_allowed_notifier_(notifier),
       request_count_(0),
       weak_ptr_factory_(this) {
   resource_request_allowed_notifier_->Init(this);
 }
 
 VariationsService::~VariationsService() {
 }
 
 bool VariationsService::CreateTrialsFromSeed() {
@@ skipping 197 matching lines @@
 #endif
   result.reset(new VariationsService(
       new web_resource::ResourceRequestAllowedNotifier(
           local_state, switches::kDisableBackgroundNetworking),
       local_state, state_manager));
   return result.Pass();
 }
 
 void VariationsService::DoActualFetch() {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!pending_seed_request_);
 
   pending_seed_request_ = net::URLFetcher::Create(0, variations_server_url_,
                                                   net::URLFetcher::GET, this);
   pending_seed_request_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                                       net::LOAD_DO_NOT_SAVE_COOKIES);
   pending_seed_request_->SetRequestContext(
       g_browser_process->system_request_context());
   pending_seed_request_->SetMaxRetriesOn5xx(kMaxRetrySeedFetch);
-  if (!seed_store_.variations_serial_number().empty()) {
+  if (!seed_store_.variations_serial_number().empty() &&
+      !disable_deltas_for_next_request_) {
+    // If the current seed includes a country code, deltas are not supported (as
+    // the serial number doesn't take into account the country code). The server
+    // will update us with a seed that doesn't include a country code which will
+    // enable deltas to work.
+    // TODO(asvitkine): Remove the check in M50+ when the percentage of clients
+    // that have an old seed with a country code becomes miniscule.
+    if (!seed_store_.seed_has_country_code()) {
+      // Tell the server that delta-compressed seeds are supported.
+      pending_seed_request_->AddExtraRequestHeader("A-IM:x-bm");
+    }
+    // Get the seed only if its serial number doesn't match what we have.
     pending_seed_request_->AddExtraRequestHeader(
-        "If-Match:" + seed_store_.variations_serial_number());
+        "If-None-Match:" + seed_store_.variations_serial_number());
   }
   pending_seed_request_->Start();
 
   const base::TimeTicks now = base::TimeTicks::Now();
   base::TimeDelta time_since_last_fetch;
   // Record a time delta of 0 (default value) if there was no previous fetch.
   if (!last_request_started_time_.is_null())
     time_since_last_fetch = now - last_request_started_time_;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.TimeSinceLastFetchAttempt",
                               time_since_last_fetch.InMinutes(), 0,
                               base::TimeDelta::FromDays(7).InMinutes(), 50);
   UMA_HISTOGRAM_COUNTS_100("Variations.RequestCount", request_count_);
   ++request_count_;
   last_request_started_time_ = now;
+  disable_deltas_for_next_request_ = false;
 }
 
-void VariationsService::StoreSeed(const std::string& seed_data,
+bool VariationsService::StoreSeed(const std::string& seed_data,
                                   const std::string& seed_signature,
-                                  const base::Time& date_fetched) {
+                                  const std::string& country_code,
+                                  const base::Time& date_fetched,
+                                  bool is_delta_compressed) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_ptr<variations::VariationsSeed> seed(new variations::VariationsSeed);
-  if (!seed_store_.StoreSeedData(seed_data, seed_signature, date_fetched,
+  if (!seed_store_.StoreSeedData(seed_data, seed_signature, country_code,
+                                 date_fetched, is_delta_compressed,
                                  seed.get())) {
-    return;
+    return false;
   }
   RecordLastFetchTime();
 
   // Perform seed simulation only if |state_manager_| is not-NULL. The state
   // manager may be NULL for some unit tests.
   if (!state_manager_)
-    return;
+    return true;
 
   base::PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&GetVersionForSimulation),
       base::Bind(&VariationsService::PerformSimulationWithVersion,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&seed)));
+  return true;
 }
 
 void VariationsService::FetchVariationsSeed() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const web_resource::ResourceRequestAllowedNotifier::State state =
       resource_request_allowed_notifier_->GetResourceRequestsAllowedState();
   RecordRequestsAllowedHistogram(ResourceRequestStateToHistogramValue(state));
   if (state != web_resource::ResourceRequestAllowedNotifier::ALLOWED) {
     DVLOG(1) << "Resource requests were not allowed. Waiting for notification.";
@@ skipping 72 matching lines @@
       // next start up), since 304 is a successful response.
       seed_store_.UpdateSeedDateAndLogDayChange(response_date);
     }
     return;
   }
 
   std::string seed_data;
   bool success = request->GetResponseAsString(&seed_data);
   DCHECK(success);
 
-  std::string seed_signature;
-  request->GetResponseHeaders()->EnumerateHeader(NULL,
-                                                 "X-Seed-Signature",
-                                                 &seed_signature);
-  StoreSeed(seed_data, seed_signature, response_date);
+  net::HttpResponseHeaders* headers = request->GetResponseHeaders();
+  const std::string signature = GetHeaderValue(headers, "X-Seed-Signature");
+  const std::string country_code = GetHeaderValue(headers, "X-Country");
+  const bool is_delta_compressed = (GetHeaderValue(headers, "IM") == "x-bm");
+  const bool store_success = StoreSeed(seed_data, signature, country_code,
+                                       response_date, is_delta_compressed);
+  if (!store_success && is_delta_compressed) {
+    disable_deltas_for_next_request_ = true;
+    request_scheduler_->ScheduleFetchShortly();
+  }
 }
 
 void VariationsService::OnResourceRequestsAllowed() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Note that this only attempts to fetch the seed at most once per period
   // (kSeedFetchPeriodHours). This works because
   // |resource_request_allowed_notifier_| only calls this method if an
   // attempt was made earlier that fails (which implies that the period had
   // elapsed). After a successful attempt is made, the notifier will know not
@@ skipping 124 matching lines @@
   // Otherwise, update the pref with the current Chrome version and country.
   base::ListValue new_list_value;
   new_list_value.AppendString(version.GetString());
   new_list_value.AppendString(latest_country);
   local_state_->Set(prefs::kVariationsPermanentConsistencyCountry,
                     new_list_value);
   return latest_country;
 }
 
 }  // namespace chrome_variations