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

base/singleton.h

 // Copyright (c) 2010 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.
 
 #ifndef BASE_SINGLETON_H_
 #define BASE_SINGLETON_H_
 #pragma once
 
 #include "base/at_exit.h"
 #include "base/atomicops.h"
@@ skipping 96 matching lines @@
 
   // Signal the object was already deleted, so it is not revived.
   static base::subtle::Atomic32 dead_;
 };
 
 template <typename Type> intptr_t
     StaticMemorySingletonTraits<Type>::buffer_[kBufferSize];
 template <typename Type> base::subtle::Atomic32
     StaticMemorySingletonTraits<Type>::dead_ = 0;
 
+// This is a hack to work around a limitation where a template argument cannot
+// be declared as a friend directly. This is used in the below Singleton
+// template.
+template <typename T>
+struct FriendMaker {
+  typedef T FriendType;
+};
 
 // The Singleton<Type, Traits, DifferentiatingType> class manages a single
 // instance of Type which will be created on first use and will be destroyed at
 // normal process exit). The Trait::Delete function will not be called on
 // abnormal process exit.
 //
 // DifferentiatingType is used as a key to differentiate two different
 // singletons having the same memory allocation functions but serving a
 // different purpose. This is mainly used for Locks serving different purposes.
 //
-// Example usages: (none are preferred, they all result in the same code)
-//   1. FooClass* ptr = Singleton<FooClass>::get();
-//      ptr->Bar();
-//   2. Singleton<FooClass>()->Bar();
-//   3. Singleton<FooClass>::get()->Bar();
+// Example usage:
+//
+// In your header:
+//   #include "base/singleton.h"
+//   class FooClass {
+//    public:
+//     static FooClass* GetInstance();  <-- See comment below on this.
+//     void Bar() { ... }
+//    private:
+//     FooClass() { ... }
+//     friend struct DefaultSingletonTraits<FooClass>;
+//
+//     DISALLOW_COPY_AND_ASSIGN(FooClass);
+//   };
+//
+// In your source file:
+//  FooClass* FooClass::GetInstance() {
+//    return Singleton<FooClass>::get();
+//  }
+//
+// And to call methods on FooClass:
+//   FooClass::GetInstance()->Bar();
+//
+// NOTE: It is important that FooClass::GetInstance() is not inlined in the
+// header, so that when source files from multiple targets include this header
+// they don't end up with different copies of the inlined code creating multiple
+// copies of the singleton.
 //
 // Singleton<> has no non-static members and doesn't need to actually be
-// instantiated. It does no harm to instantiate it and use it as a class member
-// or at global level since it is acting as a POD type.
+// instantiated.
 //
 // This class is itself thread-safe. The underlying Type must of course be
 // thread-safe if you want to use it concurrently. Two parameters may be tuned
 // depending on the user's requirements.
 //
 // Glossary:
 //   RAE = kRegisterAtExit
 //
 // On every platform, if Traits::RAE is true, the singleton will be destroyed at
 // process exit. More precisely it uses base::AtExitManager which requires an
 // object of this type to be instantiated. AtExitManager mimics the semantics
 // of atexit() such as LIFO order but under Windows is safer to call. For more
 // information see at_exit.h.
 //
 // If Traits::RAE is false, the singleton will not be freed at process exit,
 // thus the singleton will be leaked if it is ever accessed. Traits::RAE
 // shouldn't be false unless absolutely necessary. Remember that the heap where
 // the object is allocated may be destroyed by the CRT anyway.
 //
-// If you want to ensure that your class can only exist as a singleton, make
-// its constructors private, and make DefaultSingletonTraits<> a friend:
-//
-//   #include "base/singleton.h"
-//   class FooClass {
-//    public:
-//     void Bar() { ... }
-//    private:
-//     FooClass() { ... }
-//     friend struct DefaultSingletonTraits<FooClass>;
-//
-//     DISALLOW_COPY_AND_ASSIGN(FooClass);
-//   };
-//
 // Caveats:
 // (a) Every call to get(), operator->() and operator*() incurs some overhead
 //     (16ns on my P4/2.8GHz) to check whether the object has already been
 //     initialized.  You may wish to cache the result of get(); it will not
 //     change.
 //
 // (b) Your factory function must never throw an exception. This class is not
 //     exception-safe.
 //
 template <typename Type,
           typename Traits = DefaultSingletonTraits<Type>,
           typename DifferentiatingType = Type>
 class Singleton {
- public:
+ private:
+#if defined(OS_WIN)
+  friend typename FriendMaker<Type>::FriendType;
+#else
+  friend class FriendMaker<Type>::FriendType;
+#endif
+
   // This class is safe to be constructed and copy-constructed since it has no
   // member.
 
   // Return a pointer to the one true instance of the class.
   static Type* get() {
     if (!Traits::kAllowedToAccessOnNonjoinableThread)
       base::ThreadRestrictions::AssertSingletonAllowed();
 
     // Our AtomicWord doubles as a spinlock, where a value of
     // kBeingCreatedMarker means the spinlock is being held for creation.
@@ skipping 40 matching lines @@
       if (value != kBeingCreatedMarker)
         break;
       PlatformThread::YieldCurrentThread();
     }
 
     // See the corresponding HAPPENS_BEFORE above.
     ANNOTATE_HAPPENS_AFTER(&instance_);
     return reinterpret_cast<Type*>(value);
   }
 
-  // Shortcuts.
-  Type& operator*() {
-    return *get();
-  }
-
-  Type* operator->() {
-    return get();
-  }
-
- private:
   // Adapter function for use with AtExit().  This should be called single
   // threaded, so don't use atomic operations.
   // Calling OnExit while singleton is in use by other threads is a mistake.
   static void OnExit(void* unused) {
     // AtExit should only ever be register after the singleton instance was
     // created.  We should only ever get here with a valid instance_ pointer.
     Traits::Delete(
         reinterpret_cast<Type*>(base::subtle::NoBarrier_Load(&instance_)));
     instance_ = 0;
   }
   static base::subtle::AtomicWord instance_;
 };
 
 template <typename Type, typename Traits, typename DifferentiatingType>
 base::subtle::AtomicWord Singleton<Type, Traits, DifferentiatingType>::
     instance_ = 0;
 
 #endif  // BASE_SINGLETON_H_