Make SimpleCache creation threadsafe.

net/disk_cache/simple/simple_backend_impl.cc

 // Copyright (c) 2013 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 "net/disk_cache/simple/simple_backend_impl.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <functional>
 
 #if defined(OS_POSIX)
 #include <sys/resource.h>
 #endif
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
+#include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
@@ skipping 22 matching lines @@
 
 // Maximum number of concurrent worker pool threads, which also is the limit
 // on concurrent IO (as we use one thread per IO request).
 const int kDefaultMaxWorkerThreads = 50;
 
 const char kThreadNamePrefix[] = "SimpleCache";
 
 // Maximum fraction of the cache that one entry can consume.
 const int kMaxFileRatio = 8;
 
-// A global sequenced worker pool to use for launching all tasks.
-SequencedWorkerPool* g_sequenced_worker_pool = NULL;
-
-void MaybeCreateSequencedWorkerPool() {
-  if (!g_sequenced_worker_pool) {
+class LeakySequencedWorkerPool {
+ public:
+  LeakySequencedWorkerPool() {
     int max_worker_threads = kDefaultMaxWorkerThreads;
 
     const std::string thread_count_field_trial =
         base::FieldTrialList::FindFullName("SimpleCacheMaxThreads");

[pasko, 2015/02/19 12:09:13]

I removed this code for the experiment recently, please rebase.

[mmenke, 2015/02/19 16:53:07]

Done.

     if (!thread_count_field_trial.empty()) {
       max_worker_threads =
           std::max(1, std::atoi(thread_count_field_trial.c_str()));
     }
 
-    g_sequenced_worker_pool = new SequencedWorkerPool(max_worker_threads,
-                                                      kThreadNamePrefix);
-    g_sequenced_worker_pool->AddRef();  // Leak it.
+    sequenced_worker_pool_ = new SequencedWorkerPool(max_worker_threads,
+                                                     kThreadNamePrefix);
   }
-}
+
+  void FlushForTesting() {
+    sequenced_worker_pool_->FlushForTesting();
+  }
+
+  scoped_refptr<base::TaskRunner> GetTaskRunner() {
+    return sequenced_worker_pool_->GetTaskRunnerWithShutdownBehavior(
+        SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
+  }
+
+ private:
+  scoped_refptr<SequencedWorkerPool> sequenced_worker_pool_;
+
+  DISALLOW_COPY_AND_ASSIGN(LeakySequencedWorkerPool);
+};
+
+base::LazyInstance<LeakySequencedWorkerPool>::Leaky g_sequenced_worker_pool =
+    LAZY_INSTANCE_INITIALIZER;
 
 bool g_fd_limit_histogram_has_been_populated = false;
 
 void MaybeHistogramFdLimit(net::CacheType cache_type) {
   if (g_fd_limit_histogram_has_been_populated)
     return;
 
   // Used in histograms; add new entries at end.
   enum FdLimitStatus {
     FD_LIMIT_STATUS_UNSUPPORTED = 0,
@@ skipping 149 matching lines @@
                                  SimpleEntryImpl::NON_OPTIMISTIC_OPERATIONS),
       net_log_(net_log) {
   MaybeHistogramFdLimit(cache_type_);
 }
 
 SimpleBackendImpl::~SimpleBackendImpl() {
   index_->WriteToDisk();
 }
 
 int SimpleBackendImpl::Init(const CompletionCallback& completion_callback) {
-  MaybeCreateSequencedWorkerPool();
-
-  worker_pool_ = g_sequenced_worker_pool->GetTaskRunnerWithShutdownBehavior(
-      SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
+  worker_pool_ = g_sequenced_worker_pool.Get().GetTaskRunner();
 
   index_.reset(new SimpleIndex(
       base::ThreadTaskRunnerHandle::Get(),
       this,
       cache_type_,
       make_scoped_ptr(new SimpleIndexFile(
           cache_thread_, worker_pool_.get(), cache_type_, path_))));
   index_->ExecuteWhenReady(
       base::Bind(&RecordIndexLoad, cache_type_, base::TimeTicks::Now()));
 
@@ skipping 464 matching lines @@
     scoped_ptr<std::vector<uint64> > entry_hashes,
     const net::CompletionCallback& callback,
     int result) {
   std::for_each(
       entry_hashes->begin(), entry_hashes->end(),
       std::bind1st(std::mem_fun(&SimpleBackendImpl::OnDoomComplete),
                    this));
   callback.Run(result);
 }
 
+// static
 void SimpleBackendImpl::FlushWorkerPoolForTesting() {
-  if (g_sequenced_worker_pool)
-    g_sequenced_worker_pool->FlushForTesting();
+  g_sequenced_worker_pool.Get().FlushForTesting();
 }
 
 }  // namespace disk_cache