Move VariationsParamAssociator to base

components/variations/variations_associated_data.cc

 // Copyright 2013 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 "components/variations/variations_associated_data.h"
 
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
+#include "base/metrics/field_trial_param_associator.h"
 #include "base/strings/string_split.h"
 #include "components/variations/variations_http_header_provider.h"
 
 namespace variations {
 
 namespace {
 
 const char kGroupTesting[] = "Testing";
 
 // The internal singleton accessor for the map, used to keep it thread-safe.
@@ skipping 73 matching lines @@
   GroupMapAccessor() {
     group_to_id_maps_.resize(ID_COLLECTION_COUNT);
   }
   ~GroupMapAccessor() {}
 
   base::Lock lock_;
   std::vector<GroupToIDMap> group_to_id_maps_;
 
   DISALLOW_COPY_AND_ASSIGN(GroupMapAccessor);
 };
-
-// Singleton helper class that keeps track of the parameters of all variations
-// and ensures access to these is thread-safe.
-class VariationsParamAssociator {
- public:
-  typedef std::pair<std::string, std::string> VariationKey;
-  typedef std::map<std::string, std::string> VariationParams;
-
-  // Retrieve the singleton.
-  static VariationsParamAssociator* GetInstance() {
-    return base::Singleton<
-        VariationsParamAssociator,
-        base::LeakySingletonTraits<VariationsParamAssociator>>::get();
-  }
-
-  bool AssociateVariationParams(const std::string& trial_name,
-                                const std::string& group_name,
-                                const VariationParams& params) {
-    base::AutoLock scoped_lock(lock_);
-
-    if (base::FieldTrialList::IsTrialActive(trial_name))
-      return false;
-
-    const VariationKey key(trial_name, group_name);
-    if (base::ContainsKey(variation_params_, key))
-      return false;
-
-    variation_params_[key] = params;
-    return true;
-  }
-
-  bool GetVariationParams(const std::string& trial_name,
-                          VariationParams* params) {
-    base::AutoLock scoped_lock(lock_);
-
-    const std::string group_name =
-        base::FieldTrialList::FindFullName(trial_name);
-    const VariationKey key(trial_name, group_name);
-    if (!base::ContainsKey(variation_params_, key))
-      return false;
-
-    *params = variation_params_[key];
-    return true;
-  }
-
-  void ClearAllParamsForTesting() {
-    base::AutoLock scoped_lock(lock_);
-    variation_params_.clear();
-  }
-
- private:
-  friend struct base::DefaultSingletonTraits<VariationsParamAssociator>;
-
-  VariationsParamAssociator() {}
-  ~VariationsParamAssociator() {}
-
-  base::Lock lock_;
-  std::map<VariationKey, VariationParams> variation_params_;
-
-  DISALLOW_COPY_AND_ASSIGN(VariationsParamAssociator);
-};
-
 }  // namespace
 
 void AssociateGoogleVariationID(IDCollectionKey key,
                                 const std::string& trial_name,
                                 const std::string& group_name,
                                 VariationID id) {
   GroupMapAccessor::GetInstance()->AssociateID(
       key, MakeActiveGroupId(trial_name, group_name), id, false);
 }
 
@@ skipping 21 matching lines @@
 VariationID GetGoogleVariationIDFromHashes(
     IDCollectionKey key,
     const ActiveGroupId& active_group) {
   return GroupMapAccessor::GetInstance()->GetID(key, active_group);
 }
 
 bool AssociateVariationParams(
     const std::string& trial_name,
     const std::string& group_name,
     const std::map<std::string, std::string>& params) {
-  return VariationsParamAssociator::GetInstance()->AssociateVariationParams(
-      trial_name, group_name, params);
+  return base::FieldTrialParamAssociator::GetInstance()
+      ->AssociateFieldTrialParams(trial_name, group_name, params);
 }
 
 bool GetVariationParams(const std::string& trial_name,
                         std::map<std::string, std::string>* params) {
-  return VariationsParamAssociator::GetInstance()->GetVariationParams(
+  return base::FieldTrialParamAssociator::GetInstance()->GetFieldTrialParams(
       trial_name, params);
 }
 
 bool GetVariationParamsByFeature(const base::Feature& feature,
                                  std::map<std::string, std::string>* params) {
   if (!base::FeatureList::IsEnabled(feature))
     return false;
 
   base::FieldTrial* trial = base::FeatureList::GetFieldTrial(feature);
   if (!trial)
@@ skipping 47 matching lines @@
   field_trial_list_.reset(new base::FieldTrialList(nullptr));
   variations::AssociateVariationParams(trial_name, kGroupTesting, params);
   base::FieldTrialList::CreateFieldTrial(trial_name, kGroupTesting);
 }
 
 void ClearAllVariationIDs() {
   GroupMapAccessor::GetInstance()->ClearAllMapsForTesting();
 }
 
 void ClearAllVariationParams() {
-  VariationsParamAssociator::GetInstance()->ClearAllParamsForTesting();
+  base::FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting();
 }
 
 }  // namespace testing
 
 }  // namespace variations