Try to fix valgrind error in nss_ocsp.cc

net/ocsp/nss_ocsp.cc

 // Copyright (c) 2009 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"
 
 // Work around https://bugzilla.mozilla.org/show_bug.cgi?id=455424
 // until NSS 3.12.2 comes out and we update to it.
 #define Lock FOO_NSS_Lock
 #include <certt.h>
@@ skipping 20 matching lines @@
 #include "net/url_request/url_request_context.h"
 
 namespace {
 
 static 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.
 
-class OCSPInitSingleton {
+class OCSPInitSingleton : public MessageLoop::DestructionObserver {
  public:
+  virtual void WillDestroyCurrentMessageLoop() {
+    io_loop_ = NULL;
+  };
+
   MessageLoop* io_thread() const {
-    DCHECK(io_loop_);
     return io_loop_;
   }
 
   // This is static method because it is called before NSS initialization,
   // that is, before OCSPInitSingleton is initialized.
   static void set_url_request_context(URLRequestContext* request_context) {
     request_context_ = request_context;
   }
   URLRequestContext* url_request_context() const {
     return request_context_.get();
   }
 
  private:
   friend struct DefaultSingletonTraits<OCSPInitSingleton>;
   OCSPInitSingleton();
-  ~OCSPInitSingleton() {
+  virtual ~OCSPInitSingleton() {
     request_context_ = NULL;
   }
 
   SEC_HttpClientFcn client_fcn_;
 
   // I/O thread.
   MessageLoop* io_loop_;  // I/O thread
 
   // URLRequestContext for OCSP handlers.
   static scoped_refptr<URLRequestContext> request_context_;
 
   DISALLOW_COPY_AND_ASSIGN(OCSPInitSingleton);
 };
 
 scoped_refptr<URLRequestContext> OCSPInitSingleton::request_context_;
 
 // Concrete class for SEC_HTTP_REQUEST_SESSION.
 // Public methods except virtual methods of URLRequest::Delegate (On* methods)
 // run on certificate verifier thread (worker thread).
 // Virtual methods of URLRequest::Delegate and private methods run
 // on IO thread.
 class OCSPRequestSession
     : public base::RefCountedThreadSafe<OCSPRequestSession>,
-      public URLRequest::Delegate {
+      public URLRequest::Delegate,
+      public MessageLoop::DestructionObserver {
  public:
   OCSPRequestSession(const GURL& url,
                      const char* http_request_method,
                      base::TimeDelta timeout)
       : url_(url),
         http_request_method_(http_request_method),
         timeout_(timeout),
         io_loop_(Singleton<OCSPInitSingleton>::get()->io_thread()),
         request_(NULL),
         buffer_(new net::IOBuffer(kRecvBufferSize)),
         response_code_(-1),
         cv_(&lock_),
         finished_(false) {}
 
   void SetPostData(const char* http_data, PRUint32 http_data_len,
                    const char* http_content_type) {
     upload_content_.assign(http_data, http_data_len);
     upload_content_type_.assign(http_content_type);
   }
 
   void AddHeader(const char* http_header_name, const char* http_header_value) {
     if (!extra_request_headers_.empty())
       extra_request_headers_ += "\r\n";
     StringAppendF(&extra_request_headers_,
                   "%s: %s", http_header_name, http_header_value);
   }
 
   void Start() {
-    DCHECK(io_loop_);
-    io_loop_->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(this, &OCSPRequestSession::StartURLRequest));
+    if (io_loop_) {
+      io_loop_->PostTask(
+          FROM_HERE,
+          NewRunnableMethod(this, &OCSPRequestSession::StartURLRequest));
+    }
   }
 
   bool Started() const {
     return request_ != NULL;
   }
 
   void Cancel() {
-    io_loop_->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(this, &OCSPRequestSession::CancelURLRequest));
+    if (io_loop_) {
+      io_loop_->PostTask(
+          FROM_HERE,
+          NewRunnableMethod(this, &OCSPRequestSession::CancelURLRequest));
+    }
   }
 
   bool Finished() const {
     AutoLock autolock(lock_);
     return finished_;
   }
 
   bool Wait() {
     base::TimeDelta timeout = timeout_;
     AutoLock autolock(lock_);
@@ skipping 70 matching lines @@
     } while (request_->Read(buffer_, kRecvBufferSize, &bytes_read));
 
     if (!request_->status().is_io_pending()) {
       {
         AutoLock autolock(lock_);
         finished_ = true;
       }
       cv_.Signal();
       delete request_;
       request_ = NULL;
+      io_loop_->RemoveDestructionObserver(this);
+      io_loop_ = NULL;
     }
   }
 
+  virtual void WillDestroyCurrentMessageLoop() {
+    DCHECK(MessageLoopForIO::current() == io_loop_);
+    if (request_) {
+      request_->Cancel();
+      delete request_;
+      request_ = NULL;
+    }
+    io_loop_ = NULL;
+  }
+
  private:
   friend class base::RefCountedThreadSafe<OCSPRequestSession>;
 
   virtual ~OCSPRequestSession() {
     DCHECK(!request_);
+    if (io_loop_)
+      io_loop_->RemoveDestructionObserver(this);
+    io_loop_ = NULL;
   }
 
   void StartURLRequest() {
     DCHECK(MessageLoopForIO::current() == io_loop_);
     DCHECK(!request_);
 
+    io_loop_->AddDestructionObserver(this);
+
     request_ = new URLRequest(url_, this);
     request_->set_context(
         Singleton<OCSPInitSingleton>::get()->url_request_context());
     // To meet the privacy requirements of off-the-record mode.
     request_->set_load_flags(
         net::LOAD_DISABLE_CACHE|net::LOAD_DO_NOT_SAVE_COOKIES);
 
     if (http_request_method_ == "POST") {
       DCHECK(!upload_content_.empty());
       DCHECK(!upload_content_type_.empty());
@@ skipping 252 matching lines @@
   LOG(INFO) << "OCSP free";
   DCHECK(!MessageLoop::current());
   OCSPRequestSession* req = reinterpret_cast<OCSPRequestSession*>(request);
   req->Cancel();
   req->Release();
   return SECSuccess;
 }
 
 OCSPInitSingleton::OCSPInitSingleton()
     : io_loop_(MessageLoopForIO::current()) {
+  io_loop_->AddDestructionObserver(this);
   client_fcn_.version = 1;
   SEC_HttpClientFcnV1Struct *ft = &client_fcn_.fcnTable.ftable1;
   ft->createSessionFcn = OCSPCreateSession;
   ft->keepAliveSessionFcn = OCSPKeepAliveSession;
   ft->freeSessionFcn = OCSPFreeSession;
   ft->createFcn = OCSPCreate;
   ft->setPostDataFcn = OCSPSetPostData;
   ft->addHeaderFcn = OCSPAddHeader;
   ft->trySendAndReceiveFcn = OCSPTrySendAndReceive;
   ft->cancelFcn = NULL;
@@ skipping 11 matching lines @@
 void EnsureOCSPInit() {
   Singleton<OCSPInitSingleton>::get();
 }
 
 // This function would be called before NSS initialization.
 void SetURLRequestContextForOCSP(URLRequestContext* request_context) {
   OCSPInitSingleton::set_url_request_context(request_context);
 }
 
 }  // namespace net