Log the freshness of the Variations seed in a histogram.

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 <set>
 
 #include "base/base64.h"
 #include "base/build_time.h"
@@ skipping 159 matching lines @@
     return false;
 
   chrome::VersionInfo::Channel channel = GetChannelForVariations();
   for (int i = 0; i < seed.study_size(); ++i) {
     if (ShouldAddStudy(seed.study(i), current_version_info, reference_date,
                        channel)) {
       CreateTrialFromStudy(seed.study(i), reference_date);
     }
   }
 
+  // Log the "freshness" of the seed that was just used. The freshness is the
+  // time between the last successful seed download and now.
+  const int64 last_fetch_time_internal =
+      local_state_->GetInt64(prefs::kVariationsLastFetchTime);
+  if (last_fetch_time_internal) {
+    const base::Time now = base::Time::Now();
+    const base::TimeDelta delta =
+        now - base::Time::FromInternalValue(last_fetch_time_internal);
+    // Log the value in number of minutes.
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.SeedFreshness", delta.InMinutes(),
+        1, base::TimeDelta::FromDays(30).InMinutes(), 50);
+  }
+
   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_);
 
@@ skipping 18 matching lines @@
 
 void VariationsService::SetCreateTrialsFromSeedCalledForTesting(bool called) {
   create_trials_from_seed_called_ = called;
 }
 
 // static
 void VariationsService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kVariationsSeed, std::string());
   registry->RegisterInt64Pref(prefs::kVariationsSeedDate,
                               base::Time().ToInternalValue());
+  registry->RegisterInt64Pref(prefs::kVariationsLastFetchTime, 0);
 }
 
 // static
 VariationsService* VariationsService::Create(PrefService* local_state) {
 // This is temporarily disabled for Android. See http://crbug.com/168224
 #if !defined(GOOGLE_CHROME_BUILD) || defined(OS_ANDROID)
   // Unless the URL was provided, unsupported builds should return NULL to
   // indicate that the service should not be used.
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kVariationsServerURL))
@@ skipping 58 matching lines @@
       network_time_tracker_.UpdateNetworkTime(
           response_date,
           base::TimeDelta::FromMilliseconds(kServerTimeResolutionMs),
           latency);
     }
   }
 
   if (response_code != net::HTTP_OK) {
     DVLOG(1) << "Variations server request returned non-HTTP_OK response code: "
              << response_code;
-    if (response_code == net::HTTP_NOT_MODIFIED)
+    if (response_code == net::HTTP_NOT_MODIFIED) {
       UMA_HISTOGRAM_MEDIUM_TIMES("Variations.FetchNotModifiedLatency", latency);
-    else
+      RecordLastFetchTime();
+    } else {
       UMA_HISTOGRAM_MEDIUM_TIMES("Variations.FetchOtherLatency", latency);
+    }
     return;
   }
   UMA_HISTOGRAM_MEDIUM_TIMES("Variations.FetchSuccessLatency", latency);
 
   std::string seed_data;
   bool success = request->GetResponseAsString(&seed_data);
   DCHECK(success);
 
   StoreSeedData(seed_data, response_date, local_state_);
 }
@@ skipping 31 matching lines @@
   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();
+
+  RecordLastFetchTime();
+
   return true;
 }
 
 // static
 bool VariationsService::ShouldAddStudy(
     const Study& study,
     const chrome::VersionInfo& version_info,
     const base::Time& reference_date,
     const chrome::VersionInfo::Channel channel) {
   if (study.has_filter()) {
@@ skipping 233 matching lines @@
                                       experiment.name(),
                                       variation_id);
     }
   }
 
   trial->SetForced();
   if (IsStudyExpired(study, reference_date))
     trial->Disable();
 }
 
+void VariationsService::RecordLastFetchTime() {
+  // local_state_ is NULL in tests, so check it first.
+  if (local_state_) {
+    local_state_->SetInt64(prefs::kVariationsLastFetchTime,
+                           base::Time::Now().ToInternalValue());
+  }
+}
+
 }  // namespace chrome_variations