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

base/worker_pool_mac.mm

 // 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 "base/worker_pool_mac.h"
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/metrics/histogram.h"
+#include "base/scoped_nsobject.h"
 #include "base/scoped_ptr.h"
-#import "base/singleton_objc.h"
 #include "base/task.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/worker_pool_linux.h"
 
 // When C++ exceptions are disabled, the C++ library defines |try| and
 // |catch| so as to allow exception-expecting C++ code to build properly when
 // language support for exceptions is not present.  These macros interfere
 // with the use of |@try| and |@catch| in Objective-C files such as this one.
 // Undefine these macros here, after everything has been #included, since
 // there will be no C++ uses and only Objective-C uses from this point on.
 #undef try
 #undef catch
 
 namespace {
 
 // |true| to use the Linux WorkerPool implementation for
 // |WorkerPool::PostTask()|.
 bool use_linux_workerpool_ = true;
 
 Lock lock_;
 base::Time last_check_;            // Last hung-test check.
 std::vector<id> outstanding_ops_;  // Outstanding operations at last check.
 size_t running_ = 0;               // Operations in |Run()|.
 size_t outstanding_ = 0;           // Operations posted but not completed.
 
+// We use a wrapper struct here for the NSOperationQueue so that the object
+// can be released when LazyInstance calls our destructor.
+struct NSOperationQueueWrapper {
+  NSOperationQueueWrapper() {
+    operation_queue.reset([[NSOperationQueue alloc] init]);
+  }
+  scoped_nsobject<NSOperationQueue> operation_queue;
+};
+
+static base::LazyInstance<NSOperationQueueWrapper> g_nsoperation_queue(

[Evan Martin, 2010/12/13 17:38:30]

*

+    base::LINKER_INITIALIZED);
+
 }  // namespace
 
 namespace worker_pool_mac {
 
 void SetUseLinuxWorkerPool(bool flag) {
   use_linux_workerpool_ = flag;
 }
 
 }  // namespace worker_pool_mac
 
 @implementation WorkerPoolObjC
 
 + (NSOperationQueue*)sharedOperationQueue {
-  return SingletonObjC<NSOperationQueue>::get();
+  return g_nsoperation_queue.Get().operation_queue.get();
 }
 
 @end  // @implementation WorkerPoolObjC
 
 // TaskOperation adapts Task->Run() for use in an NSOperationQueue.
 @interface TaskOperation : NSOperation {
  @private
   scoped_ptr<Task> task_;
 }
 
@@ skipping 135 matching lines @@
   // Don't report "nothing to report".
   const size_t kUnaccountedOpsDelta = 10;
   if (hung_ops.size() > 0 || outstanding_delta > kUnaccountedOpsDelta) {
     UMA_HISTOGRAM_COUNTS_100("OSX.HungWorkers", hung_ops.size());
     UMA_HISTOGRAM_COUNTS_100("OSX.OutstandingDelta", outstanding_delta);
     UMA_HISTOGRAM_COUNTS_100("OSX.RunningOps", running_ops);
   }
 
   return true;
 }