Move Singleton and related structs to namespace 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/memory/singleton.h"
 
 namespace variations {
 
 namespace {
 
 // The internal singleton accessor for the map, used to keep it thread-safe.
 class GroupMapAccessor {
  public:
   typedef std::map<ActiveGroupId, VariationID, ActiveGroupIdCompare>
       GroupToIDMap;
 
   // Retrieve the singleton.
   static GroupMapAccessor* GetInstance() {
-    return Singleton<GroupMapAccessor>::get();
+    return base::Singleton<GroupMapAccessor>::get();
   }
 
   // Note that this normally only sets the ID for a group the first time, unless
   // |force| is set to true, in which case it will always override it.
   void AssociateID(IDCollectionKey key,
                    const ActiveGroupId& group_identifier,
                    const VariationID id,
                    const bool force) {
 #if !defined(NDEBUG)
     DCHECK_EQ(4, ID_COLLECTION_COUNT);
@@ skipping 38 matching lines @@
     base::AutoLock scoped_lock(lock_);
 
     for (int i = 0; i < ID_COLLECTION_COUNT; ++i) {
       GroupToIDMap* map = GetGroupToIDMap(static_cast<IDCollectionKey>(i));
       DCHECK(map);
       map->clear();
     }
   }
 
  private:
-  friend struct DefaultSingletonTraits<GroupMapAccessor>;
+  friend struct base::DefaultSingletonTraits<GroupMapAccessor>;
 
   // Retrieves the GroupToIDMap for |key|.
   GroupToIDMap* GetGroupToIDMap(IDCollectionKey key) {
     return &group_to_id_maps_[key];
   }
 
   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 Singleton<VariationsParamAssociator>::get();
+    return base::Singleton<VariationsParamAssociator>::get();
   }
 
   bool AssociateVariationParams(const std::string& trial_name,
                                 const std::string& group_name,
                                 const VariationParams& params) {
     base::AutoLock scoped_lock(lock_);
 
     if (IsFieldTrialActive(trial_name))
       return false;
 
@@ skipping 18 matching lines @@
     *params = variation_params_[key];
     return true;
   }
 
   void ClearAllParamsForTesting() {
     base::AutoLock scoped_lock(lock_);
     variation_params_.clear();
   }
 
  private:
-  friend struct DefaultSingletonTraits<VariationsParamAssociator>;
+  friend struct base::DefaultSingletonTraits<VariationsParamAssociator>;
 
   VariationsParamAssociator() {}
   ~VariationsParamAssociator() {}
 
   // Tests whether a field trial is active (i.e. group() has been called on it).
   // TODO(asvitkine): Expose this as an API on base::FieldTrial.
   bool IsFieldTrialActive(const std::string& trial_name) {
     base::FieldTrial::ActiveGroups active_groups;
     base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
     for (size_t i = 0; i < active_groups.size(); ++i) {
@@ skipping 79 matching lines @@
   GroupMapAccessor::GetInstance()->ClearAllMapsForTesting();
 }
 
 void ClearAllVariationParams() {
   VariationsParamAssociator::GetInstance()->ClearAllParamsForTesting();
 }
 
 }  // namespace testing
 
 }  // namespace variations