Make members of Singleton<T> private and only visible to the singleton type.

base/singleton_unittest.cc

 // Copyright (c) 2006-2008 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/file_util.h"
 #include "base/path_service.h"
 #include "base/singleton.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 COMPILE_ASSERT(DefaultSingletonTraits<int>::kRegisterAtExit == true, a);
 
-template<typename Type>
-struct LockTrait : public DefaultSingletonTraits<Type> {
+typedef void (*CallbackFunc)();
+
+class IntSingleton {
+ public:
+  static IntSingleton* GetInstance() {
+    return Singleton<IntSingleton>::get();
+  }
+
+  int value_;
 };
 
-struct Init5Trait : public DefaultSingletonTraits<int> {
-  static int* New() {
-    return new int(5);
+class Init5Singleton {
+ public:
+  struct Trait;
+
+  static Init5Singleton* GetInstance() {
+    return Singleton<Init5Singleton, Trait>::get();
+  }
+
+  int value_;
+};
+
+struct Init5Singleton::Trait : public DefaultSingletonTraits<Init5Singleton> {
+  static Init5Singleton* New() {
+    Init5Singleton* instance = new Init5Singleton();
+    instance->value_ = 5;
+    return instance;
   }
 };
 
-typedef void (*CallbackFunc)();
+int* SingletonInt() {
+  return &IntSingleton::GetInstance()->value_;
+}
 
-struct CallbackTrait : public DefaultSingletonTraits<CallbackFunc> {
-  static void Delete(CallbackFunc* p) {
-    if (*p)
-      (*p)();
-    DefaultSingletonTraits<CallbackFunc>::Delete(p);
+int* SingletonInt5() {
+  return &Init5Singleton::GetInstance()->value_;
+}
+
+template <typename Type>
+struct CallbackTrait : public DefaultSingletonTraits<Type> {
+  static void Delete(Type* instance) {
+    if (instance->callback_)
+      (instance->callback_)();
+    DefaultSingletonTraits<Type>::Delete(instance);
   }
 };
 
-struct StaticCallbackTrait : public StaticMemorySingletonTraits<CallbackFunc> {
-  static void Delete(CallbackFunc* p) {
-    if (*p)
-      (*p)();
-    StaticMemorySingletonTraits<CallbackFunc>::Delete(p);
+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();
+  }
+};
+
+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();
+  }
+};
+
+class CallbackSingletonWithStaticTrait : public CallbackSingleton {
+ public:
+  struct Trait;
+
+  CallbackSingletonWithStaticTrait() : CallbackSingleton() { }
+
+  static CallbackSingletonWithStaticTrait* GetInstance() {
+    return Singleton<CallbackSingletonWithStaticTrait, Trait>::get();
+  }
+};
+
+struct CallbackSingletonWithStaticTrait::Trait
+    : public StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait> {
+  static void Delete(CallbackSingletonWithStaticTrait* instance) {
+    if (instance->callback_)
+      (instance->callback_)();
+    StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait>::Delete(
+        instance);
   }
 };
 
 
-struct NoLeakTrait : public CallbackTrait {
-};
-
-struct LeakTrait : public CallbackTrait {
-  static const bool kRegisterAtExit = false;
-};
-
-int* SingletonInt1() {
-  return Singleton<int>::get();
-}
-
-int* SingletonInt2() {
-  // Force to use a different singleton than SingletonInt1.
-  return Singleton<int, DefaultSingletonTraits<int> >::get();
-}
-
-class DummyDifferentiatingClass {
-};
-
-int* SingletonInt3() {
-  // Force to use a different singleton than SingletonInt1 and SingletonInt2.
-  // Note that any type can be used; int, float, std::wstring...
-  return Singleton<int, DefaultSingletonTraits<int>,
-                   DummyDifferentiatingClass>::get();
-}
-
-int* SingletonInt4() {
-  return Singleton<int, LockTrait<int> >::get();
-}
-
-int* SingletonInt5() {
-  return Singleton<int, Init5Trait>::get();
-}
-
 void SingletonNoLeak(CallbackFunc CallOnQuit) {
-  *Singleton<CallbackFunc, NoLeakTrait>::get() = CallOnQuit;
+  CallbackSingletonWithNoLeakTrait::GetInstance()->callback_ = CallOnQuit;
 }
 
 void SingletonLeak(CallbackFunc CallOnQuit) {
-  *Singleton<CallbackFunc, LeakTrait>::get() = CallOnQuit;
+  CallbackSingletonWithLeakTrait::GetInstance()->callback_ = CallOnQuit;
 }
 
 CallbackFunc* GetLeakySingleton() {
-  return Singleton<CallbackFunc, LeakTrait>::get();
+  return &CallbackSingletonWithLeakTrait::GetInstance()->callback_;
+}
+
+void DeleteLeakySingleton() {
+  DefaultSingletonTraits<CallbackSingletonWithLeakTrait>::Delete(
+      CallbackSingletonWithLeakTrait::GetInstance());
 }
 
 void SingletonStatic(CallbackFunc CallOnQuit) {
-  *Singleton<CallbackFunc, StaticCallbackTrait>::get() = CallOnQuit;
+  CallbackSingletonWithStaticTrait::GetInstance()->callback_ = CallOnQuit;
 }
 
 CallbackFunc* GetStaticSingleton() {
-  return Singleton<CallbackFunc, StaticCallbackTrait>::get();
+  return &CallbackSingletonWithStaticTrait::GetInstance()->callback_;
+}
+
+void ResurrectStaticSingleton() {
 }
 
 }  // namespace
 
 class SingletonTest : public testing::Test {
  public:
   SingletonTest() { }
 
   virtual void SetUp() {
     non_leak_called_ = false;
@@ skipping 36 matching lines @@
   static bool non_leak_called_;
   static bool leaky_called_;
   static bool static_called_;
 };
 
 bool SingletonTest::non_leak_called_ = false;
 bool SingletonTest::leaky_called_ = false;
 bool SingletonTest::static_called_ = false;
 
 TEST_F(SingletonTest, Basic) {
-  int* singleton_int_1;
-  int* singleton_int_2;
-  int* singleton_int_3;
-  int* singleton_int_4;
+  int* singleton_int;
   int* singleton_int_5;
   CallbackFunc* leaky_singleton;
   CallbackFunc* static_singleton;
 
   {
     base::ShadowingAtExitManager sem;
     {
-      singleton_int_1 = SingletonInt1();
+      singleton_int = SingletonInt();
     }
     // Ensure POD type initialization.
-    EXPECT_EQ(*singleton_int_1, 0);
-    *singleton_int_1 = 1;
+    EXPECT_EQ(*singleton_int, 0);
+    *singleton_int = 1;
 
-    EXPECT_EQ(singleton_int_1, SingletonInt1());
-    EXPECT_EQ(*singleton_int_1, 1);
-
-    {
-      singleton_int_2 = SingletonInt2();
-    }
-    // Same instance that 1.
-    EXPECT_EQ(*singleton_int_2, 1);
-    EXPECT_EQ(singleton_int_1, singleton_int_2);
-
-    {
-      singleton_int_3 = SingletonInt3();
-    }
-    // Different instance than 1 and 2.
-    EXPECT_EQ(*singleton_int_3, 0);
-    EXPECT_NE(singleton_int_1, singleton_int_3);
-    *singleton_int_3 = 3;
-    EXPECT_EQ(*singleton_int_1, 1);
-    EXPECT_EQ(*singleton_int_2, 1);
-
-    {
-      singleton_int_4 = SingletonInt4();
-    }
-    // Use a lock for creation. Not really tested at length.
-    EXPECT_EQ(*singleton_int_4, 0);
-    *singleton_int_4 = 4;
-    EXPECT_NE(singleton_int_1, singleton_int_4);
-    EXPECT_NE(singleton_int_3, singleton_int_4);
+    EXPECT_EQ(singleton_int, SingletonInt());
+    EXPECT_EQ(*singleton_int, 1);
 
     {
       singleton_int_5 = SingletonInt5();
     }
     // Is default initialized to 5.
     EXPECT_EQ(*singleton_int_5, 5);
-    EXPECT_NE(singleton_int_1, singleton_int_5);
-    EXPECT_NE(singleton_int_3, singleton_int_5);
-    EXPECT_NE(singleton_int_4, singleton_int_5);
 
     SingletonNoLeak(&CallbackNoLeak);
     SingletonLeak(&CallbackLeak);
     SingletonStatic(&CallbackStatic);
     static_singleton = GetStaticSingleton();
     leaky_singleton = GetLeakySingleton();
     EXPECT_TRUE(leaky_singleton);
   }
 
   // Verify that only the expected callback has been called.
   VerifiesCallbacks();
   // Delete the leaky singleton. It is interesting to note that Purify does
   // *not* detect the leak when this call is commented out. :(
-  DefaultSingletonTraits<CallbackFunc>::Delete(leaky_singleton);
+  DeleteLeakySingleton();
 
   // The static singleton can't be acquired post-atexit.
   EXPECT_EQ(NULL, GetStaticSingleton());
 
   {
     base::ShadowingAtExitManager sem;
     // Verifiy that the variables were reset.
     {
-      singleton_int_1 = SingletonInt1();
-      EXPECT_EQ(*singleton_int_1, 0);
+      singleton_int = SingletonInt();
+      EXPECT_EQ(*singleton_int, 0);
     }
     {
       singleton_int_5 = SingletonInt5();
       EXPECT_EQ(*singleton_int_5, 5);
     }
     {
       // Resurrect the static singleton, and assert that it
       // still points to the same (static) memory.
-      StaticMemorySingletonTraits<CallbackFunc>::Resurrect();
+      CallbackSingletonWithStaticTrait::Trait::Resurrect();
       EXPECT_EQ(GetStaticSingleton(), static_singleton);
     }
   }
   // The leaky singleton shouldn't leak since SingletonLeak has not been called.
   VerifiesCallbacksNotCalled();
 }