Minor cleanups to variation_service.cc.

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 "base/base64.h"
 #include "base/build_time.h"
 #include "base/version.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 26 matching lines @@
     case chrome_variations::Study_Channel_BETA:
       return chrome::VersionInfo::CHANNEL_BETA;
     case chrome_variations::Study_Channel_STABLE:
       return chrome::VersionInfo::CHANNEL_STABLE;
   }
   // All enum values of |study_channel| were handled above.
   NOTREACHED();
   return chrome::VersionInfo::CHANNEL_UNKNOWN;
 }
 
+// Converts |date_time| in chrome_variations::Study date format to base::Time.
+base::Time ConvertStudyDateToBaseTime(int64 date_time) {
+  return base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(date_time);
+}
+
 }  // namespace
 
 // Static
 VariationsService* VariationsService::GetInstance() {
   return Singleton<VariationsService>::get();
 }
 
 bool VariationsService::CreateTrialsFromSeed(PrefService* local_prefs) {
   chrome_variations::TrialsSeed seed;
   if (!LoadTrialsSeedFromPref(local_prefs, &seed))
@@ skipping 98 matching lines @@
       return true;
   }
   return false;
 }
 
 // static
 bool VariationsService::CheckStudyVersion(const chrome_variations::Study& study,
                                           const std::string& version_string) {
   const Version current_version(version_string);
   if (!current_version.IsValid()) {
-    DCHECK(false);
+    NOTREACHED();
     return false;
   }
 
   if (study.has_min_version()) {
     const Version min_version(study.min_version());
     if (!min_version.IsValid())
       return false;
     if (current_version.CompareTo(min_version) < 0)
       return false;
   }
 
   if (study.has_max_version()) {
     const Version max_version(study.max_version());
     if (!max_version.IsValid())
       return false;
     if (current_version.CompareTo(max_version) > 0)
       return false;
   }
 
   return true;
 }
 
 // static
 bool VariationsService::CheckStudyDate(const chrome_variations::Study& study,
                                        const base::Time& date_time) {
-  const base::Time epoch = base::Time::UnixEpoch();
-
   if (study.has_start_date()) {
     const base::Time start_date =
-        epoch + base::TimeDelta::FromSeconds(study.start_date());
+        ConvertStudyDateToBaseTime(study.start_date());
     if (date_time < start_date)
       return false;
   }
 
   if (study.has_expiry_date()) {
     const base::Time expiry_date =
-        epoch + base::TimeDelta::FromSeconds(study.expiry_date());
+        ConvertStudyDateToBaseTime(study.expiry_date());
     if (date_time >= expiry_date)
       return false;
   }
 
   return true;
 }
 
 bool VariationsService::LoadTrialsSeedFromPref(
     PrefService* local_prefs,
     chrome_variations::TrialsSeed* seed) {
@@ skipping 33 matching lines @@
       found_default_group = true;
   }
   if (!found_default_group) {
     DVLOG(1) << study.name() << " is missing default experiment in it's "
              << "experiment list";
     // The default group was not found in the list of groups. This study is not
     // valid.
     return;
   }
 
-  const base::Time epoch = base::Time::UnixEpoch();
   const base::Time expiry_date =
-      epoch + base::TimeDelta::FromSeconds(study.expiry_date());
+      ConvertStudyDateToBaseTime(study.expiry_date());
   base::Time::Exploded exploded_end_date;
   expiry_date.UTCExplode(&exploded_end_date);
 
   scoped_refptr<base::FieldTrial> trial(
       base::FieldTrialList::FactoryGetFieldTrial(
           study.name(), divisor, default_group_name, exploded_end_date.year,
           exploded_end_date.month, exploded_end_date.day_of_month, NULL));
 
   if (study.has_consistency() &&
       study.consistency() == chrome_variations::Study_Consistency_PERMANENT) {
     trial->UseOneTimeRandomization();
   }
 
   for (int i = 0; i < study.experiment_size(); ++i) {
     if (study.experiment(i).name() != default_group_name) {
       trial->AppendGroup(study.experiment(i).name(),
                          study.experiment(i).probability_weight());
     }
   }
 
   // TODO(jwd): Add experiment_id association code.
   trial->SetForced();
 }