Allow URLRequests from one context to have different NetworkDelegates.

net/ocsp/nss_ocsp.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/ocsp/nss_ocsp.h"
 
 #include <certt.h>
 #include <certdb.h>
 #include <ocsp.h>
 #include <nspr.h>
 #include <nss.h>
 #include <pthread.h>
 #include <secerr.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "net/base/host_port_pair.h"
@@ skipping 146 matching lines @@
 class OCSPRequestSession
     : public base::RefCountedThreadSafe<OCSPRequestSession>,
       public URLRequest::Delegate {
  public:
   OCSPRequestSession(const GURL& url,
                      const char* http_request_method,
                      base::TimeDelta timeout)
       : url_(url),
         http_request_method_(http_request_method),
         timeout_(timeout),
-        request_(NULL),
         buffer_(new IOBuffer(kRecvBufferSize)),
         response_code_(-1),
         cv_(&lock_),
         io_loop_(NULL),
         finished_(false) {}
 
   void SetPostData(const char* http_data, PRUint32 http_data_len,
                    const char* http_content_type) {
     // |upload_content_| should not be modified if |request_| is active.
     DCHECK(!request_);
@@ skipping 10 matching lines @@
     // At this point, it runs on worker thread.
     // |io_loop_| was initialized to be NULL in constructor, and
     // set only in StartURLRequest, so no need to lock |lock_| here.
     DCHECK(!io_loop_);
     g_ocsp_io_loop.Get().PostTaskToIOLoop(
         FROM_HERE,
         base::Bind(&OCSPRequestSession::StartURLRequest, this));
   }
 
   bool Started() const {
-    return request_ != NULL;
+    return request_.get() != NULL;
   }
 
   void Cancel() {
     // IO thread may set |io_loop_| to NULL, so protect by |lock_|.
     base::AutoLock autolock(lock_);
     CancelLocked();
   }
 
   bool Finished() const {
     base::AutoLock autolock(lock_);
@@ skipping 47 matching lines @@
   }
 
   const std::string& http_response_data() const {
     DCHECK(finished_);
     return data_;
   }
 
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const GURL& new_url,
                                   bool* defer_redirect) OVERRIDE {
-    DCHECK_EQ(request, request_);
+    DCHECK_EQ(request_.get(), request);
     DCHECK_EQ(base::MessageLoopForIO::current(), io_loop_);
 
     if (!new_url.SchemeIs("http")) {
       // Prevent redirects to non-HTTP schemes, including HTTPS. This matches
       // the initial check in OCSPServerSession::CreateRequest().
       CancelURLRequest();
     }
   }
 
   virtual void OnResponseStarted(URLRequest* request) OVERRIDE {
-    DCHECK_EQ(request, request_);
+    DCHECK_EQ(request_.get(), request);
     DCHECK_EQ(base::MessageLoopForIO::current(), io_loop_);
 
     int bytes_read = 0;
     if (request->status().is_success()) {
       response_code_ = request_->GetResponseCode();
       response_headers_ = request_->response_headers();
       response_headers_->GetMimeType(&response_content_type_);
       request_->Read(buffer_.get(), kRecvBufferSize, &bytes_read);
     }
-    OnReadCompleted(request_, bytes_read);
+    OnReadCompleted(request_.get(), bytes_read);
   }
 
   virtual void OnReadCompleted(URLRequest* request,
                                int bytes_read) OVERRIDE {
-    DCHECK_EQ(request, request_);
+    DCHECK_EQ(request_.get(), request);
     DCHECK_EQ(base::MessageLoopForIO::current(), io_loop_);
 
     do {
       if (!request_->status().is_success() || bytes_read <= 0)
         break;
       data_.append(buffer_->data(), bytes_read);
     } while (request_->Read(buffer_.get(), kRecvBufferSize, &bytes_read));
 
     if (!request_->status().is_io_pending()) {
-      delete request_;
-      request_ = NULL;
+      request_.reset();
       g_ocsp_io_loop.Get().RemoveRequest(this);
       {
         base::AutoLock autolock(lock_);
         finished_ = true;
         io_loop_ = NULL;
       }
       cv_.Signal();
       Release();  // Balanced with StartURLRequest().
     }
   }
 
   // Must be called on the IO loop thread.
   void CancelURLRequest() {
 #ifndef NDEBUG
     {
       base::AutoLock autolock(lock_);
       if (io_loop_)
         DCHECK_EQ(base::MessageLoopForIO::current(), io_loop_);
     }
 #endif
     if (request_) {
-      request_->Cancel();
-      delete request_;
-      request_ = NULL;
+      request_.reset();
       g_ocsp_io_loop.Get().RemoveRequest(this);
       {
         base::AutoLock autolock(lock_);
         finished_ = true;
         io_loop_ = NULL;
       }
       cv_.Signal();
       Release();  // Balanced with StartURLRequest().
     }
   }
@@ skipping 30 matching lines @@
     if (url_request_context == NULL)
       return;
 
     {
       base::AutoLock autolock(lock_);
       DCHECK(!io_loop_);
       io_loop_ = base::MessageLoopForIO::current();
       g_ocsp_io_loop.Get().AddRequest(this);
     }
 
-    request_ =
-        new URLRequest(url_, DEFAULT_PRIORITY, this, url_request_context);
+    request_ = url_request_context->CreateRequest(
+        url_, DEFAULT_PRIORITY, this, NULL);
     // To meet the privacy requirements of incognito mode.
     request_->SetLoadFlags(LOAD_DISABLE_CACHE | LOAD_DO_NOT_SAVE_COOKIES |
                            LOAD_DO_NOT_SEND_COOKIES);
 
     if (http_request_method_ == "POST") {
       DCHECK(!upload_content_.empty());
       DCHECK(!upload_content_type_.empty());
 
       request_->set_method("POST");
       extra_request_headers_.SetHeader(
           HttpRequestHeaders::kContentType, upload_content_type_);
 
       scoped_ptr<UploadElementReader> reader(new UploadBytesElementReader(
           upload_content_.data(), upload_content_.size()));
       request_->set_upload(make_scoped_ptr(
           UploadDataStream::CreateWithReader(reader.Pass(), 0)));
     }
     if (!extra_request_headers_.IsEmpty())
       request_->SetExtraRequestHeaders(extra_request_headers_);
 
     request_->Start();
     AddRef();  // Release after |request_| deleted.
   }
 
-  GURL url_;                      // The URL we eventually wound up at
+  GURL url_;                        // The URL we eventually wound up at
   std::string http_request_method_;
-  base::TimeDelta timeout_;       // The timeout for OCSP
-  URLRequest* request_;           // The actual request this wraps
+  base::TimeDelta timeout_;         // The timeout for OCSP
+  scoped_ptr<URLRequest> request_;  // The actual request this wraps
   scoped_refptr<IOBuffer> buffer_;  // Read buffer
   HttpRequestHeaders extra_request_headers_;
 
   // HTTP POST payload. |request_| reads bytes from this.
   std::string upload_content_;
   std::string upload_content_type_;  // MIME type of POST payload
 
   int response_code_;             // HTTP status code for the request
   std::string response_content_type_;
   scoped_refptr<HttpResponseHeaders> response_headers_;
@@ skipping 530 matching lines @@
 void SetURLRequestContextForNSSHttpIO(URLRequestContext* request_context) {
   pthread_mutex_lock(&g_request_context_lock);
   if (request_context) {
     DCHECK(!g_request_context);
   }
   g_request_context = request_context;
   pthread_mutex_unlock(&g_request_context_lock);
 }
 
 }  // namespace net