Reland 66791 (change was innocent)...

net/ocsp/nss_ocsp.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 "net/ocsp/nss_ocsp.h"
 
 #include <certt.h>
 #include <certdb.h>
 #include <ocsp.h>
 #include <nspr.h>
@@ skipping 67 matching lines @@
   bool shutdown_;  // Protected by |lock_|.
   std::set<OCSPRequestSession*> requests_;  // Protected by |lock_|.
   bool used_;  // Protected by |lock_|.
   // This should not be modified after |used_|.
   MessageLoopForIO* io_loop_;  // Protected by |lock_|.
   ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(OCSPIOLoop);
 };
 
-base::LazyInstance<OCSPIOLoop> g_ocsp_io_loop(base::LINKER_INITIALIZED);
+base::LazyInstance<OCSPIOLoop, base::LeakyLazyInstanceTraits<OCSPIOLoop> >
+    g_ocsp_io_loop(base::LINKER_INITIALIZED);
 
 const int kRecvBufferSize = 4096;
 
 // All OCSP handlers should be called in the context of
 // CertVerifier's thread (i.e. worker pool, not on the I/O thread).
 // It supports blocking mode only.
 
 SECStatus OCSPCreateSession(const char* host, PRUint16 portnum,
                             SEC_HTTP_SERVER_SESSION* pSession);
 SECStatus OCSPKeepAliveSession(SEC_HTTP_SERVER_SESSION session,
@@ skipping 454 matching lines @@
 }
 
 OCSPNSSInitialization::~OCSPNSSInitialization() {}
 
 
 // OCSP Http Client functions.
 // Our Http Client functions operate in blocking mode.
 SECStatus OCSPCreateSession(const char* host, PRUint16 portnum,
                             SEC_HTTP_SERVER_SESSION* pSession) {
   VLOG(1) << "OCSP create session: host=" << host << " port=" << portnum;
-  DCHECK(!MessageLoop::current());
   pthread_mutex_lock(&g_request_context_lock);
   URLRequestContext* request_context = g_request_context;
   pthread_mutex_unlock(&g_request_context_lock);
   if (request_context == NULL) {
     LOG(ERROR) << "No URLRequestContext for OCSP handler.";
     // The application failed to call SetURLRequestContextForOCSP, so we
     // can't create and use URLRequest.  PR_NOT_IMPLEMENTED_ERROR is not an
     // accurate error code for this error condition, but is close enough.
     PORT_SetError(PR_NOT_IMPLEMENTED_ERROR);
     return SECFailure;
   }
   *pSession = new OCSPServerSession(host, portnum);
   return SECSuccess;
 }
 
 SECStatus OCSPKeepAliveSession(SEC_HTTP_SERVER_SESSION session,
                                PRPollDesc **pPollDesc) {
   VLOG(1) << "OCSP keep alive";
-  DCHECK(!MessageLoop::current());
   if (pPollDesc)
     *pPollDesc = NULL;
   return SECSuccess;
 }
 
 SECStatus OCSPFreeSession(SEC_HTTP_SERVER_SESSION session) {
   VLOG(1) << "OCSP free session";
-  DCHECK(!MessageLoop::current());
   delete reinterpret_cast<OCSPServerSession*>(session);
   return SECSuccess;
 }
 
 SECStatus OCSPCreate(SEC_HTTP_SERVER_SESSION session,
                      const char* http_protocol_variant,
                      const char* path_and_query_string,
                      const char* http_request_method,
                      const PRIntervalTime timeout,
                      SEC_HTTP_REQUEST_SESSION* pRequest) {
   VLOG(1) << "OCSP create protocol=" << http_protocol_variant
           << " path_and_query=" << path_and_query_string
           << " http_request_method=" << http_request_method
           << " timeout=" << timeout;
-  DCHECK(!MessageLoop::current());
   OCSPServerSession* ocsp_session =
       reinterpret_cast<OCSPServerSession*>(session);
 
   OCSPRequestSession* req = ocsp_session->CreateRequest(http_protocol_variant,
                                                         path_and_query_string,
                                                         http_request_method,
                                                         timeout);
   SECStatus rv = SECFailure;
   if (req) {
     req->AddRef();  // Release in OCSPFree().
     rv = SECSuccess;
   }
   *pRequest = req;
   return rv;
 }
 
 SECStatus OCSPSetPostData(SEC_HTTP_REQUEST_SESSION request,
                           const char* http_data,
                           const PRUint32 http_data_len,
                           const char* http_content_type) {
   VLOG(1) << "OCSP set post data len=" << http_data_len;
-  DCHECK(!MessageLoop::current());
   OCSPRequestSession* req = reinterpret_cast<OCSPRequestSession*>(request);
 
   req->SetPostData(http_data, http_data_len, http_content_type);
   return SECSuccess;
 }
 
 SECStatus OCSPAddHeader(SEC_HTTP_REQUEST_SESSION request,
                         const char* http_header_name,
                         const char* http_header_value) {
   VLOG(1) << "OCSP add header name=" << http_header_name
           << " value=" << http_header_value;
-  DCHECK(!MessageLoop::current());
   OCSPRequestSession* req = reinterpret_cast<OCSPRequestSession*>(request);
 
   req->AddHeader(http_header_name, http_header_value);
   return SECSuccess;
 }
 
 // Sets response of |req| in the output parameters.
 // It is helper routine for OCSP trySendAndReceiveFcn.
 // |http_response_data_len| could be used as input parameter.  If it has
 // non-zero value, it is considered as maximum size of |http_response_data|.
@@ skipping 39 matching lines @@
                                 const char** http_response_headers,
                                 const char** http_response_data,
                                 PRUint32* http_response_data_len) {
   if (http_response_data_len) {
     // We must always set an output value, even on failure.  The output value 0
     // means the failure was unrelated to the acceptable response data length.
     *http_response_data_len = 0;
   }
 
   VLOG(1) << "OCSP try send and receive";
-  DCHECK(!MessageLoop::current());
   OCSPRequestSession* req = reinterpret_cast<OCSPRequestSession*>(request);
   // We support blocking mode only.
   if (pPollDesc)
     *pPollDesc = NULL;
 
   if (req->Started() || req->Finished()) {
     // We support blocking mode only, so this function shouldn't be called
     // again when req has stareted or finished.
     NOTREACHED();
     PORT_SetError(SEC_ERROR_BAD_HTTP_RESPONSE);  // Simple approximation.
@@ skipping 57 matching lines @@
   return OCSPSetResponse(
       req, http_response_code,
       http_response_content_type,
       http_response_headers,
       http_response_data,
       http_response_data_len);
 }
 
 SECStatus OCSPFree(SEC_HTTP_REQUEST_SESSION request) {
   VLOG(1) << "OCSP free";
-  DCHECK(!MessageLoop::current());
   OCSPRequestSession* req = reinterpret_cast<OCSPRequestSession*>(request);
   req->Cancel();
   req->Release();
   return SECSuccess;
 }
 
 // Data for GetAlternateOCSPAIAInfo.
 
 // CN=Network Solutions Certificate Authority,O=Network Solutions L.L.C.,C=US
 //
@@ skipping 115 matching lines @@
 
 URLRequestContext* GetURLRequestContextForOCSP() {
   pthread_mutex_lock(&g_request_context_lock);
   URLRequestContext* request_context = g_request_context;
   pthread_mutex_unlock(&g_request_context_lock);
   DCHECK(!request_context || request_context->is_main());
   return request_context;
 }
 
 }  // namespace net