Move variations component code to variations namespace.

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/build_time.h"
 #include "base/command_line.h"
@@ skipping 48 matching lines @@
 
 // TODO(mad): To be removed when we stop updating the NetworkTimeTracker.
 // For the HTTP date headers, the resolution of the server time is 1 second.
 const int64 kServerTimeResolutionMs = 1000;
 
 // Wrapper around channel checking, used to enable channel mocking for
 // testing. If the current browser channel is not UNKNOWN, this will return
 // that channel value. Otherwise, if the fake channel flag is provided, this
 // will return the fake channel. Failing that, this will return the UNKNOWN
 // channel.
-Study_Channel GetChannelForVariations() {
+variations::Study_Channel GetChannelForVariations() {
   switch (chrome::VersionInfo::GetChannel()) {
     case chrome::VersionInfo::CHANNEL_CANARY:
-      return Study_Channel_CANARY;
+      return variations::Study_Channel_CANARY;
     case chrome::VersionInfo::CHANNEL_DEV:
-      return Study_Channel_DEV;
+      return variations::Study_Channel_DEV;
     case chrome::VersionInfo::CHANNEL_BETA:
-      return Study_Channel_BETA;
+      return variations::Study_Channel_BETA;
     case chrome::VersionInfo::CHANNEL_STABLE:
-      return Study_Channel_STABLE;
+      return variations::Study_Channel_STABLE;
     case chrome::VersionInfo::CHANNEL_UNKNOWN:
       break;
   }
   const std::string forced_channel =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kFakeVariationsChannel);
   if (forced_channel == "stable")
-    return Study_Channel_STABLE;
+    return variations::Study_Channel_STABLE;
   if (forced_channel == "beta")
-    return Study_Channel_BETA;
+    return variations::Study_Channel_BETA;
   if (forced_channel == "dev")
-    return Study_Channel_DEV;
+    return variations::Study_Channel_DEV;
   if (forced_channel == "canary")
-    return Study_Channel_CANARY;
+    return variations::Study_Channel_CANARY;
   DVLOG(1) << "Invalid channel provided: " << forced_channel;
-  return Study_Channel_UNKNOWN;
+  return variations::Study_Channel_UNKNOWN;
 }
 
 // Returns a string that will be used for the value of the 'osname' URL param
 // to the variations server.
 std::string GetPlatformString() {
 #if defined(OS_WIN)
   return "win";
 #elif defined(OS_IOS)
   return "ios";
 #elif defined(OS_MACOSX)
@@ skipping 72 matching lines @@
     case ResourceRequestAllowedNotifier::ALLOWED:
       return RESOURCE_REQUESTS_ALLOWED;
   }
   NOTREACHED();
   return RESOURCE_REQUESTS_NOT_ALLOWED;
 }
 
 
 // Gets current form factor and converts it from enum DeviceFormFactor to enum
 // Study_FormFactor.
-Study_FormFactor GetCurrentFormFactor() {
+variations::Study_FormFactor GetCurrentFormFactor() {
   switch (ui::GetDeviceFormFactor()) {
     case ui::DEVICE_FORM_FACTOR_PHONE:
-      return Study_FormFactor_PHONE;
+      return variations::Study_FormFactor_PHONE;
     case ui::DEVICE_FORM_FACTOR_TABLET:
-      return Study_FormFactor_TABLET;
+      return variations::Study_FormFactor_TABLET;
     case ui::DEVICE_FORM_FACTOR_DESKTOP:
-      return Study_FormFactor_DESKTOP;
+      return variations::Study_FormFactor_DESKTOP;
   }
   NOTREACHED();
-  return Study_FormFactor_DESKTOP;
+  return variations::Study_FormFactor_DESKTOP;
 }
 
 // Gets the hardware class and returns it as a string. This returns an empty
 // string if the client is not ChromeOS.
 std::string GetHardwareClass() {
 #if defined(OS_CHROMEOS)
   return base::SysInfo::GetLsbReleaseBoard();
 #endif  // OS_CHROMEOS
   return std::string();
 }
@@ skipping 39 matching lines @@
       weak_ptr_factory_(this) {
   resource_request_allowed_notifier_->Init(this);
 }
 
 VariationsService::~VariationsService() {
 }
 
 bool VariationsService::CreateTrialsFromSeed() {
   create_trials_from_seed_called_ = true;
 
-  VariationsSeed seed;
+  variations::VariationsSeed seed;
   if (!seed_store_.LoadSeed(&seed))
     return false;
 
   const chrome::VersionInfo current_version_info;
   if (!current_version_info.is_valid())
     return false;
 
   const base::Version current_version(current_version_info.Version());
   if (!current_version.IsValid())
     return false;
 
-  VariationsSeedProcessor().CreateTrialsFromSeed(
+  variations::VariationsSeedProcessor().CreateTrialsFromSeed(
       seed,
       g_browser_process->GetApplicationLocale(),
       GetReferenceDateForExpiryChecks(local_state_),
       current_version,
       GetChannelForVariations(),
       GetCurrentFormFactor(),
       GetHardwareClass(),
       base::Bind(&OverrideUIString));
 
   // Log the "freshness" of the seed that was just used. The freshness is the
@@ skipping 151 matching lines @@
     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);
   last_request_started_time_ = now;
 }
 
 void VariationsService::StoreSeed(const std::string& seed_data,
                                   const std::string& seed_signature,
                                   const base::Time& date_fetched) {
-  scoped_ptr<VariationsSeed> seed(new VariationsSeed);
+  scoped_ptr<variations::VariationsSeed> seed(new variations::VariationsSeed);
   if (!seed_store_.StoreSeedData(seed_data, seed_signature, date_fetched,
                                  seed.get())) {
     return;
   }
   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;
@@ skipping 14 matching lines @@
   RecordRequestsAllowedHistogram(ResourceRequestStateToHistogramValue(state));
   if (state != ResourceRequestAllowedNotifier::ALLOWED) {
     DVLOG(1) << "Resource requests were not allowed. Waiting for notification.";
     return;
   }
 
   DoActualFetch();
 }
 
 void VariationsService::NotifyObservers(
-    const VariationsSeedSimulator::Result& result) {
+    const variations::VariationsSeedSimulator::Result& result) {
   if (result.kill_critical_group_change_count > 0) {
     FOR_EACH_OBSERVER(Observer, observer_list_,
                       OnExperimentChangesDetected(Observer::CRITICAL));
   } else if (result.kill_best_effort_group_change_count > 0) {
     FOR_EACH_OBSERVER(Observer, observer_list_,
                       OnExperimentChangesDetected(Observer::BEST_EFFORT));
   }
 }
 
 void VariationsService::OnURLFetchComplete(const net::URLFetcher* source) {
@@ skipping 75 matching lines @@
   RecordRequestsAllowedHistogram(RESOURCE_REQUESTS_ALLOWED_NOTIFIED);
   DVLOG(1) << "Retrying fetch.";
   DoActualFetch();
 
   // This service must have created a scheduler in order for this to be called.
   DCHECK(request_scheduler_.get());
   request_scheduler_->Reset();
 }
 
 void VariationsService::PerformSimulationWithVersion(
-    scoped_ptr<VariationsSeed> seed,
+    scoped_ptr<variations::VariationsSeed> seed,
     const base::Version& version) {
   if (version.IsValid())
     return;
 
   const base::ElapsedTimer timer;
 
   scoped_ptr<const base::FieldTrial::EntropyProvider> entropy_provider =
       state_manager_->CreateEntropyProvider();
-  VariationsSeedSimulator seed_simulator(*entropy_provider);
+  variations::VariationsSeedSimulator seed_simulator(*entropy_provider);
 
-  VariationsSeedSimulator::Result result = seed_simulator.SimulateSeedStudies(
-      *seed, g_browser_process->GetApplicationLocale(),
-      GetReferenceDateForExpiryChecks(local_state_), version,
-      GetChannelForVariations(), GetCurrentFormFactor(), GetHardwareClass());
+  const variations::VariationsSeedSimulator::Result result =
+      seed_simulator.SimulateSeedStudies(
+          *seed, g_browser_process->GetApplicationLocale(),
+          GetReferenceDateForExpiryChecks(local_state_), version,
+          GetChannelForVariations(), GetCurrentFormFactor(),
+          GetHardwareClass());
 
   UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.NormalChanges",
                            result.normal_group_change_count);
   UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.KillBestEffortChanges",
                            result.kill_best_effort_group_change_count);
   UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.KillCriticalChanges",
                            result.kill_critical_group_change_count);
 
   UMA_HISTOGRAM_TIMES("Variations.SimulateSeed.Duration", timer.Elapsed());
 
   NotifyObservers(result);
 }
 
 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