Move Singleton and related structs to namespace base

base/memory/singleton_unittest.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 "base/at_exit.h"
 #include "base/memory/singleton.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {

[danakj, 2015/09/01 20:55:13]

you could wrap this file in the base namespace and then you don't have to add
base:: everywhere. like:

namespace base {
namespace {

... the rest of this file ...

}  // namespace
}  // namespace base

 
-COMPILE_ASSERT(DefaultSingletonTraits<int>::kRegisterAtExit == true, a);
+COMPILE_ASSERT(base::DefaultSingletonTraits<int>::kRegisterAtExit == true, a);
 
 typedef void (*CallbackFunc)();
 
 class IntSingleton {
  public:
   static IntSingleton* GetInstance() {
-    return Singleton<IntSingleton>::get();
+    return base::Singleton<IntSingleton>::get();
   }
 
   int value_;
 };
 
 class Init5Singleton {
  public:
   struct Trait;
 
   static Init5Singleton* GetInstance() {
-    return Singleton<Init5Singleton, Trait>::get();
+    return base::Singleton<Init5Singleton, Trait>::get();
   }
 
   int value_;
 };
 
-struct Init5Singleton::Trait : public DefaultSingletonTraits<Init5Singleton> {
+struct Init5Singleton::Trait
+    : public base::DefaultSingletonTraits<Init5Singleton> {
   static Init5Singleton* New() {
     Init5Singleton* instance = new Init5Singleton();
     instance->value_ = 5;
     return instance;
   }
 };
 
 int* SingletonInt() {
   return &IntSingleton::GetInstance()->value_;
 }
 
 int* SingletonInt5() {
   return &Init5Singleton::GetInstance()->value_;
 }
 
 template <typename Type>
-struct CallbackTrait : public DefaultSingletonTraits<Type> {
+struct CallbackTrait : public base::DefaultSingletonTraits<Type> {
   static void Delete(Type* instance) {
     if (instance->callback_)
       (instance->callback_)();
-    DefaultSingletonTraits<Type>::Delete(instance);
+    base::DefaultSingletonTraits<Type>::Delete(instance);
   }
 };
 
 class CallbackSingleton {
  public:
   CallbackSingleton() : callback_(NULL) { }
   CallbackFunc callback_;
 };
 
 class CallbackSingletonWithNoLeakTrait : public CallbackSingleton {
  public:
   struct Trait : public CallbackTrait<CallbackSingletonWithNoLeakTrait> { };
 
   CallbackSingletonWithNoLeakTrait() : CallbackSingleton() { }
 
   static CallbackSingletonWithNoLeakTrait* GetInstance() {
-    return Singleton<CallbackSingletonWithNoLeakTrait, Trait>::get();
+    return base::Singleton<CallbackSingletonWithNoLeakTrait, Trait>::get();
   }
 };
 
 class CallbackSingletonWithLeakTrait : public CallbackSingleton {
  public:
   struct Trait : public CallbackTrait<CallbackSingletonWithLeakTrait> {
     static const bool kRegisterAtExit = false;
   };
 
   CallbackSingletonWithLeakTrait() : CallbackSingleton() { }
 
   static CallbackSingletonWithLeakTrait* GetInstance() {
-    return Singleton<CallbackSingletonWithLeakTrait, Trait>::get();
+    return base::Singleton<CallbackSingletonWithLeakTrait, Trait>::get();
   }
 };
 
 class CallbackSingletonWithStaticTrait : public CallbackSingleton {
  public:
   struct Trait;
 
   CallbackSingletonWithStaticTrait() : CallbackSingleton() { }
 
   static CallbackSingletonWithStaticTrait* GetInstance() {
-    return Singleton<CallbackSingletonWithStaticTrait, Trait>::get();
+    return base::Singleton<CallbackSingletonWithStaticTrait, Trait>::get();
   }
 };
 
 struct CallbackSingletonWithStaticTrait::Trait
-    : public StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait> {
+    : public base::StaticMemorySingletonTraits<
+          CallbackSingletonWithStaticTrait> {
   static void Delete(CallbackSingletonWithStaticTrait* instance) {
     if (instance->callback_)
       (instance->callback_)();
-    StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait>::Delete(
+    base::StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait>::Delete(
         instance);
   }
 };
 
 template <class Type>
 class AlignedTestSingleton {
  public:
   AlignedTestSingleton() {}
   ~AlignedTestSingleton() {}
   static AlignedTestSingleton* GetInstance() {
-    return Singleton<AlignedTestSingleton,
-        StaticMemorySingletonTraits<AlignedTestSingleton> >::get();
+    return base::Singleton<
+        AlignedTestSingleton,
+        base::StaticMemorySingletonTraits<AlignedTestSingleton>>::get();
   }
 
   Type type_;
 };
 
 
 void SingletonNoLeak(CallbackFunc CallOnQuit) {
   CallbackSingletonWithNoLeakTrait::GetInstance()->callback_ = CallOnQuit;
 }
 
 void SingletonLeak(CallbackFunc CallOnQuit) {
   CallbackSingletonWithLeakTrait::GetInstance()->callback_ = CallOnQuit;
 }
 
 CallbackFunc* GetLeakySingleton() {
   return &CallbackSingletonWithLeakTrait::GetInstance()->callback_;
 }
 
 void DeleteLeakySingleton() {
-  DefaultSingletonTraits<CallbackSingletonWithLeakTrait>::Delete(
+  base::DefaultSingletonTraits<CallbackSingletonWithLeakTrait>::Delete(
       CallbackSingletonWithLeakTrait::GetInstance());
 }
 
 void SingletonStatic(CallbackFunc CallOnQuit) {
   CallbackSingletonWithStaticTrait::GetInstance()->callback_ = CallOnQuit;
 }
 
 CallbackFunc* GetStaticSingleton() {
   return &CallbackSingletonWithStaticTrait::GetInstance()->callback_;
 }
@@ skipping 129 matching lines @@
   AlignedTestSingleton<AlignedMemory<128, 128> >* align128 =
       AlignedTestSingleton<AlignedMemory<128, 128> >::GetInstance();
   AlignedTestSingleton<AlignedMemory<4096, 4096> >* align4096 =
       AlignedTestSingleton<AlignedMemory<4096, 4096> >::GetInstance();
 
   EXPECT_ALIGNED(align4, 4);
   EXPECT_ALIGNED(align32, 32);
   EXPECT_ALIGNED(align128, 128);
   EXPECT_ALIGNED(align4096, 4096);
 }