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

remoting/base/tracer.cc

 // 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.
 
 #include "remoting/base/tracer.h"
 
 #include <list>
 
 #include "base/basictypes.h"
 #include "base/condition_variable.h"
+#include "base/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/ref_counted.h"
 #include "base/stl_util-inl.h"
 #include "base/thread.h"
 #include "base/thread_local.h"
 #include "base/time.h"
 
 namespace remoting {
 
@@ skipping 60 matching lines @@
       }
 
       if (buffer) {
         LogOneTrace(buffer);
         delete buffer;
       }
     }
   }
 
  private:
-  friend struct DefaultSingletonTraits<OutputLogger>;
+  friend struct base::DefaultLazyInstanceTraits<OutputLogger>;
 
   ~OutputLogger() {
     {
       AutoLock l(lock_);
       stopped_ = true;
       wake_.Signal();
     }
 
     thread_.Stop();
     STLDeleteElements(&buffers_);
   }
 
   Lock lock_;
   base::Thread thread_;
   bool stopped_;
   ConditionVariable wake_;
   std::list<TraceBuffer*> buffers_;
 };
 
+static base::LazyInstance<OutputLogger> g_output_logger(
+    base::LINKER_INITIALIZED);
+static base::LazyInstance<base::ThreadLocalPointer<TraceContext> >
+    g_thread_local_trace_context(base::LINKER_INITIALIZED);
+
 }  // namespace
 
 Tracer::Tracer(const std::string& name, double sample_percent) {
   if (sample_percent > base::RandDouble()) {
     buffer_.reset(new TraceBuffer());
     buffer_->set_name(name);
   }
 }
 
 void Tracer::PrintString(const std::string& s) {
   AutoLock l(lock_);
   if (!buffer_.get()) {
     return;
   }
 
   TraceRecord* record = buffer_->add_record();
   record->set_annotation(s);
   record->set_timestamp(base::Time::Now().ToInternalValue());
 
   // Take the pointer for the current messageloop as identifying for the
   // current thread.
   record->set_thread_id(static_cast<uint64>(PlatformThread::CurrentId()));
 }
 
 Tracer::~Tracer() {
   AutoLock l(lock_);
 
   if (buffer_.get()) {
-    Singleton<OutputLogger>::get()->OutputTrace(buffer_.release());
+    g_output_logger.Get().OutputTrace(buffer_.release());
   }
 }
 
 // static
 Tracer* TraceContext::tracer() {
   return Get()->GetTracerInternal();
 }
 
 // static
 void TraceContext::PushTracer(Tracer* tracer) {
   Get()->PushTracerInternal(tracer);
 }
 
 // static
 void TraceContext::PopTracer() {
   Get()->PopTracerInternal();
 }
 
 // static
 TraceContext* TraceContext::Get() {
   TraceContext* context =
-      Singleton<base::ThreadLocalPointer<TraceContext> >::get()->Get();
+      g_thread_local_trace_context.Get().Get();
   if (context == NULL) {
     context = new TraceContext();
     context->PushTracerInternal(new Tracer("default", 0.0));
-    Singleton<base::ThreadLocalPointer<TraceContext> >::get()->Set(context);
+    g_thread_local_trace_context.Get().Set(context);
   }
   return context;
 }
 
 TraceContext::TraceContext() {}
 
 TraceContext::~TraceContext() {}
 
 void TraceContext::PushTracerInternal(Tracer* tracer) {
   tracers_.push_back(make_scoped_refptr(tracer));
 }
 
 void TraceContext::PopTracerInternal() { tracers_.pop_back(); }
 
 Tracer* TraceContext::GetTracerInternal() { return tracers_.back(); }
 
 
 }  // namespace remoting
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(remoting::OutputLogger);