Switch the NSS thread from being a base::Thread to a base::SequencedWorkerPool of 1

net/socket/client_socket_factory.cc

 // Copyright (c) 2012 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/socket/client_socket_factory.h"
 
 #include "base/lazy_instance.h"
 #include "base/thread_task_runner_handle.h"
-#include "base/threading/thread.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "build/build_config.h"
 #include "net/base/cert_database.h"
 #include "net/socket/client_socket_handle.h"
 #if defined(OS_WIN)
 #include "net/socket/ssl_client_socket_nss.h"
 #include "net/socket/ssl_client_socket_win.h"
 #elif defined(USE_OPENSSL)
 #include "net/socket/ssl_client_socket_openssl.h"
 #elif defined(USE_NSS)
 #include "net/socket/ssl_client_socket_nss.h"
@@ skipping 20 matching lines @@
 bool g_use_dedicated_nss_thread = true;
 #else
 bool g_use_dedicated_nss_thread = false;
 #endif
 
 class DefaultClientSocketFactory : public ClientSocketFactory,
                                    public CertDatabase::Observer {
  public:
   DefaultClientSocketFactory() {
     if (g_use_dedicated_nss_thread) {
-      nss_thread_.reset(new base::Thread("NSS SSL Thread"));
-      if (nss_thread_->Start())
-        nss_thread_task_runner_ = nss_thread_->message_loop_proxy();
+      // Use a single thread for the worker pool.
+      worker_pool_ = new base::SequencedWorkerPool(1, "NSS SSL Thread");
+      nss_thread_task_runner_ =
+          worker_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
+              worker_pool_->GetSequenceToken(),
+              base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
     }
 
     CertDatabase::AddObserver(this);
   }
 
   virtual ~DefaultClientSocketFactory() {
     // Note: This code never runs, as the factory is defined as a Leaky
     // singleton.
     CertDatabase::RemoveObserver(this);
   }
@@ skipping 31 matching lines @@
       const SSLClientSocketContext& context) {
     // nss_thread_task_runner_ may be NULL if g_use_dedicated_nss_thread is
     // false or if the dedicated NSS thread failed to start. If so, cause NSS
     // functions to execute on the current task runner.
     //
     // Note: The current task runner is obtained on each call due to unit
     // tests, which may create and tear down the current thread's TaskRunner
     // between each test. Because the DefaultClientSocketFactory is leaky, it
     // may span multiple tests, and thus the current task runner may change
     // from call to call.
-    scoped_refptr<base::SingleThreadTaskRunner> nss_task_runner(
+    scoped_refptr<base::SequencedTaskRunner> nss_task_runner(
         nss_thread_task_runner_);
     if (!nss_task_runner)
       nss_task_runner = base::ThreadTaskRunnerHandle::Get();
 
 #if defined(USE_OPENSSL)
     return new SSLClientSocketOpenSSL(transport_socket, host_and_port,
                                       ssl_config, context);
 #elif defined(USE_NSS)
     return new SSLClientSocketNSS(nss_task_runner, transport_socket,
                                   host_and_port, ssl_config, context);
@@ skipping 17 matching lines @@
     NOTIMPLEMENTED();
     return NULL;
 #endif
   }
 
   void ClearSSLSessionCache() {
     SSLClientSocket::ClearSessionCache();
   }
 
  private:
-  scoped_ptr<base::Thread> nss_thread_;
-  scoped_refptr<base::SingleThreadTaskRunner> nss_thread_task_runner_;
+  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
+  scoped_refptr<base::SequencedTaskRunner> nss_thread_task_runner_;
 };
 
 static base::LazyInstance<DefaultClientSocketFactory>::Leaky
     g_default_client_socket_factory = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // Deprecated function (http://crbug.com/37810) that takes a StreamSocket.
 SSLClientSocket* ClientSocketFactory::CreateSSLClientSocket(
     StreamSocket* transport_socket,
@@ skipping 18 matching lines @@
 #if defined(OS_WIN)
   // Reflect the capability of SSLClientSocketWin.
   SSLConfigService::SetDefaultVersionMax(SSL_PROTOCOL_VERSION_TLS1);
 #elif defined(OS_MACOSX)
   // Reflect the capability of SSLClientSocketMac.
   SSLConfigService::SetDefaultVersionMax(SSL_PROTOCOL_VERSION_TLS1);
 #endif
 }
 
 }  // namespace net