VariationsService now supports wildcard in min/max version

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 88 matching lines @@
     if (ShouldAddStudy(seed.study(i), current_version_info, reference_date))
       CreateTrialFromStudy(seed.study(i), reference_date);
   }
 
   return true;
 }
 
 void VariationsService::StartFetchingVariationsSeed() {
   if (net::NetworkChangeNotifier::IsOffline())
     return;
-
   pending_seed_request_.reset(net::URLFetcher::Create(
       GURL(kDefaultVariationsServer), 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);
   pending_seed_request_->Start();
 }
 
@@ skipping 113 matching lines @@
 bool VariationsService::CheckStudyVersion(
     const chrome_variations::Study_Filter& filter,
     const std::string& version_string) {
   const Version version(version_string);
   if (!version.IsValid()) {
     NOTREACHED();
     return false;
   }
 
   if (filter.has_min_version()) {
-    const Version min_version(filter.min_version());
-    if (!min_version.IsValid())
-      return false;
-    if (version.CompareTo(min_version) < 0)
+    if (version.CompareToWildcardString(filter.min_version()) < 0)
       return false;
   }
 
   if (filter.has_max_version()) {
-    const Version max_version(filter.max_version());
-    if (!max_version.IsValid())
-      return false;
-    if (version.CompareTo(max_version) > 0)
+    if (version.CompareToWildcardString(filter.max_version()) > 0)
       return false;
   }
 
   return true;
 }
 
 // static
 bool VariationsService::CheckStudyStartDate(
     const chrome_variations::Study_Filter& filter,
     const base::Time& date_time) {
@@ skipping 19 matching lines @@
 
 // static
 bool VariationsService::ValidateStudyAndComputeTotalProbability(
     const chrome_variations::Study& study,
     base::FieldTrial::Probability* total_probability) {
   // At the moment, a missing default_experiment_name makes the study invalid.
   if (study.default_experiment_name().empty()) {
     DVLOG(1) << study.name() << " has no default experiment defined.";
     return false;
   }
+  if (study.filter().has_min_version() &&
+      !Version::IsValidWildcardString(study.filter().min_version())) {
+    DVLOG(1) << study.filter().min_version() << " invalid min version.";
+    return false;
+  }
+  if (study.filter().has_max_version() &&
+      !Version::IsValidWildcardString(study.filter().max_version())) {
+    DVLOG(1) << study.filter().max_version() << " invalid max version.";
+    return false;
+  }
 
   const std::string& default_group_name = study.default_experiment_name();
   base::FieldTrial::Probability divisor = 0;
 
   bool found_default_group = false;
   std::set<std::string> experiment_names;
   for (int i = 0; i < study.experiment_size(); ++i) {
     if (study.experiment(i).name().empty()) {
       DVLOG(1) << study.name() << " is missing experiment " << i << " name";
       return false;
     }
+
     if (!experiment_names.insert(study.experiment(i).name()).second) {
       DVLOG(1) << study.name() << " has a repeated experiment name "
                << study.experiment(i).name();
       return false;
     }
     divisor += study.experiment(i).probability_weight();
     if (study.experiment(i).name() == default_group_name)
       found_default_group = true;
   }
 
@@ skipping 58 matching lines @@
       experiments_helper::AssociateGoogleVariationIDForce(study.name(),
                                                           experiment.name(),
                                                           variation_id);
     }
   }
 
   trial->SetForced();
   if (IsStudyExpired(study, reference_date))
     trial->Disable();
 }