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

net/tools/fetch/fetch_client.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 "build/build_config.h"
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
+#include "base/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
-#include "base/singleton.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_resolver.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
@@ skipping 18 matching lines @@
   void ClientStopped() {
     if (!--clients_) {
       MessageLoop::current()->Quit();
     }
   }
 
  private:
   int clients_;
 };
 
+static base::LazyInstance<Driver> g_driver(base::LINKER_INITIALIZED);
+
 // A network client
 class Client {
  public:
   Client(net::HttpTransactionFactory* factory, const std::string& url) :
       url_(url),
       buffer_(new net::IOBuffer(kBufferSize)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           connect_callback_(this, &Client::OnConnectComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           read_callback_(this, &Client::OnReadComplete)) {
     int rv = factory->CreateTransaction(&transaction_);
     DCHECK_EQ(net::OK, rv);
     buffer_->AddRef();
-    driver_->ClientStarted();
+    g_driver.Get().ClientStarted();
     request_info_.url = url_;
     request_info_.method = "GET";
     int state = transaction_->Start(
         &request_info_, &connect_callback_, net::BoundNetLog());
     DCHECK(state == net::ERR_IO_PENDING);
   };
 
  private:
   void OnConnectComplete(int result) {
     // Do work here.
@@ skipping 20 matching lines @@
     if (state == net::ERR_IO_PENDING)
       return;  // IO has started.
     if (state < 0)
       return;  // ERROR!
     OnReadComplete(state);
   }
 
   void OnRequestComplete(int result) {
     static base::StatsCounter requests("FetchClient.requests");
     requests.Increment();
-    driver_->ClientStopped();
+    g_driver.Get().ClientStopped();
     printf(".");
   }
 
   static const int kBufferSize = (16 * 1024);
   GURL url_;
   net::HttpRequestInfo request_info_;
   scoped_ptr<net::HttpTransaction> transaction_;
   scoped_refptr<net::IOBuffer> buffer_;
   net::CompletionCallbackImpl<Client> connect_callback_;
   net::CompletionCallbackImpl<Client> read_callback_;
-  Singleton<Driver> driver_;
 };
 
 int main(int argc, char**argv) {
   base::AtExitManager exit;
   base::StatsTable table("fetchclient", 50, 1000);
   table.set_current(&table);
 
   CommandLine::Init(argc, argv);
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   std::string url = parsed_command_line.GetSwitchValueASCII("url");
@@ skipping 81 matching lines @@
       std::string name(table.GetRowName(index));
       if (name.length() > 0) {
         int value = table.GetRowValue(index);
         printf("%s:\t%d\n", name.c_str(), value);
       }
     }
     printf("</stats>\n");
   }
   return 0;
 }