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 base {
 namespace {
 
 COMPILE_ASSERT(DefaultSingletonTraits<int>::kRegisterAtExit == true, a);
 
 typedef void (*CallbackFunc)();
 
 class IntSingleton {
  public:
   static IntSingleton* GetInstance() {
     return Singleton<IntSingleton>::get();
@@ skipping 89 matching lines @@
   }
 };
 
 template <class Type>
 class AlignedTestSingleton {
  public:
   AlignedTestSingleton() {}
   ~AlignedTestSingleton() {}
   static AlignedTestSingleton* GetInstance() {
     return Singleton<AlignedTestSingleton,
-        StaticMemorySingletonTraits<AlignedTestSingleton> >::get();
+                     StaticMemorySingletonTraits<AlignedTestSingleton>>::get();
   }
 
   Type type_;
 };
 
 
 void SingletonNoLeak(CallbackFunc CallOnQuit) {
   CallbackSingletonWithNoLeakTrait::GetInstance()->callback_ = CallOnQuit;
 }
 
@@ skipping 11 matching lines @@
 }
 
 void SingletonStatic(CallbackFunc CallOnQuit) {
   CallbackSingletonWithStaticTrait::GetInstance()->callback_ = CallOnQuit;
 }
 
 CallbackFunc* GetStaticSingleton() {
   return &CallbackSingletonWithStaticTrait::GetInstance()->callback_;
 }
 
-}  // namespace
 
 class SingletonTest : public testing::Test {
  public:
   SingletonTest() {}
 
   void SetUp() override {
     non_leak_called_ = false;
     leaky_called_ = false;
     static_called_ = false;
   }
@@ skipping 39 matching lines @@
 bool SingletonTest::leaky_called_ = false;
 bool SingletonTest::static_called_ = false;
 
 TEST_F(SingletonTest, Basic) {
   int* singleton_int;
   int* singleton_int_5;
   CallbackFunc* leaky_singleton;
   CallbackFunc* static_singleton;
 
   {
-    base::ShadowingAtExitManager sem;
+    ShadowingAtExitManager sem;
     {
       singleton_int = SingletonInt();
     }
     // Ensure POD type initialization.
     EXPECT_EQ(*singleton_int, 0);
     *singleton_int = 1;
 
     EXPECT_EQ(singleton_int, SingletonInt());
     EXPECT_EQ(*singleton_int, 1);
 
@@ skipping 13 matching lines @@
 
   // Verify that only the expected callback has been called.
   VerifiesCallbacks();
   // Delete the leaky singleton.
   DeleteLeakySingleton();
 
   // The static singleton can't be acquired post-atexit.
   EXPECT_EQ(NULL, GetStaticSingleton());
 
   {
-    base::ShadowingAtExitManager sem;
+    ShadowingAtExitManager sem;
     // Verifiy that the variables were reset.
     {
       singleton_int = SingletonInt();
       EXPECT_EQ(*singleton_int, 0);
     }
     {
       singleton_int_5 = SingletonInt5();
       EXPECT_EQ(*singleton_int_5, 5);
     }
     {
@@ skipping 23 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);
 }
+
+}  // namespace
+}  // namespace base