Support serial number requests in variations service.

chrome/browser/metrics/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_service.h"
 
 #include <set>
 
 #include "base/base64.h"
 #include "base/build_time.h"
@@ skipping 80 matching lines @@
   if (server_url.empty())
     server_url = kDefaultVariationsServerURL;
   GURL url_as_gurl = GURL(server_url);
   DCHECK(url_as_gurl.is_valid());
   return url_as_gurl;
 }
 
 }  // namespace
 
 VariationsService::VariationsService()
-    : variations_server_url_(GetVariationsServerURL()) {
+    : variations_server_url_(GetVariationsServerURL()),
+      create_trials_from_seed_called_(false) {
 }
 
 VariationsService::~VariationsService() {}
 
 bool VariationsService::CreateTrialsFromSeed(PrefService* local_prefs) {
+  create_trials_from_seed_called_ = true;

[Ilya Sherman, 2012/08/02 23:40:49]

nit: Is it ok that this method can return |false| after this line?  Is the
DCHECK below that uses this variable just making sure that we don't lose the
optimization we gain in non-exceptional cases from caching the seed?

[Alexei Svitkine (slow), 2012/08/02 23:51:02]

Right, it's just making sure we don't lose the optimization. It's not necessary
that |variations_serial_number_| actually got set (and it's valid for it not to
be - e.g. on first run).

+
   TrialsSeed seed;
   if (!LoadTrialsSeedFromPref(local_prefs, &seed))
     return false;
 
   const int64 date_value = local_prefs->GetInt64(prefs::kVariationsSeedDate);
   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;
 
   const chrome::VersionInfo current_version_info;
   if (!current_version_info.is_valid())
     return false;
 
   for (int i = 0; i < seed.study_size(); ++i) {
     if (ShouldAddStudy(seed.study(i), current_version_info, reference_date))
       CreateTrialFromStudy(seed.study(i), reference_date);
   }
 
   return true;
 }
 
 void VariationsService::StartRepeatedVariationsSeedFetch() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
+  // Check that |CreateTrialsFromSeed| was called, which is necessary to
+  // retrieve the serial number that will be sent to the server.
+  DCHECK(create_trials_from_seed_called_);
+
   // Perform the first fetch.
   FetchVariationsSeed();
 
   // Repeat this periodically.
   timer_.Start(FROM_HERE, base::TimeDelta::FromHours(kSeedFetchPeriodHours),
                this, &VariationsService::FetchVariationsSeed);
 }
 
 void VariationsService::FetchVariationsSeed() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   const bool is_offline = net::NetworkChangeNotifier::IsOffline();
   UMA_HISTOGRAM_BOOLEAN("Variations.NetworkAvailability", !is_offline);
   if (is_offline) {
     DVLOG(1) << "Network was offline.";
     return;
   }
 
   pending_seed_request_.reset(net::URLFetcher::Create(
       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_->SetMaxRetries(kMaxRetrySeedFetch);
+  if (!variations_serial_number_.empty()) {
+    pending_seed_request_->AddExtraRequestHeader("If-Match:" +
+                                                 variations_serial_number_);
+  }
   pending_seed_request_->Start();
 }
 
 void VariationsService::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK_EQ(pending_seed_request_.get(), source);
   // When we're done handling the request, the fetcher will be deleted.
   scoped_ptr<const net::URLFetcher> request(
       pending_seed_request_.release());
   if (request->GetStatus().status() != net::URLRequestStatus::SUCCESS) {
     DVLOG(1) << "Variations server request failed.";
     return;
   }
+
   if (request->GetResponseCode() != 200) {
     DVLOG(1) << "Variations server request returned non-200 response code: "
-            << request->GetResponseCode();
+             << request->GetResponseCode();
     return;
   }
 
   std::string seed_data;
   bool success = request->GetResponseAsString(&seed_data);
   DCHECK(success);
 
   base::Time response_date;
   success = request->GetResponseHeaders()->GetDateValue(&response_date);
   DCHECK(success || response_date.is_null());
@@ skipping 22 matching lines @@
   std::string base64_seed_data;
   if (!base::Base64Encode(seed_data, &base64_seed_data)) {
     VLOG(1) << "Variations Seed data from server fails Base64Encode, rejecting "
             << "the seed.";
     return false;
   }
 
   local_prefs->SetString(prefs::kVariationsSeed, base64_seed_data);
   local_prefs->SetInt64(prefs::kVariationsSeedDate,
                         seed_date.ToInternalValue());
+  variations_serial_number_ = seed.serial_number();
   return true;
 }
 
 // static
 bool VariationsService::ShouldAddStudy(
     const Study& study,
     const chrome::VersionInfo& version_info,
     const base::Time& reference_date) {
   if (study.has_filter()) {
     if (!CheckStudyChannel(study.filter(), chrome::VersionInfo::GetChannel())) {
@@ skipping 181 matching lines @@
 
   // If the decode process fails, assume the pref value is corrupt, and clear
   // it.
   if (!base::Base64Decode(base64_seed_data, &seed_data) ||
       !seed->ParseFromString(seed_data)) {
     VLOG(1) << "Variations Seed data in local pref is corrupt, clearing the "
             << "pref.";
     local_prefs->ClearPref(prefs::kVariationsSeed);
     return false;
   }
+  variations_serial_number_ = seed->serial_number();
   return true;
 }
 
 void VariationsService::CreateTrialFromStudy(const Study& study,
                                              const base::Time& reference_date) {
   base::FieldTrial::Probability total_probability = 0;
   if (!ValidateStudyAndComputeTotalProbability(study, &total_probability))
     return;
 
   // The trial is created without specifying an expiration date because the
@@ skipping 22 matching lines @@
                                                           variation_id);
     }
   }
 
   trial->SetForced();
   if (IsStudyExpired(study, reference_date))
     trial->Disable();
 }
 
 }  // namespace chrome_variations