Un-refcount SSLClientAuthHandler.

content/browser/loader/resource_loader.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 "content/browser/loader/resource_loader.h"
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 79 matching lines @@
       waiting_for_upload_progress_ack_(false),
       is_transferring_(false),
       weak_ptr_factory_(this) {
   request_->set_delegate(this);
   handler_->SetController(this);
 }
 
 ResourceLoader::~ResourceLoader() {
   if (login_delegate_.get())
     login_delegate_->OnRequestCancelled();
-  if (ssl_client_auth_handler_.get())
-    ssl_client_auth_handler_->OnRequestCancelled();
+  ssl_client_auth_handler_.reset();
 
   // Run ResourceHandler destructor before we tear-down the rest of our state
   // as the ResourceHandler may want to inspect the URLRequest and other state.
   handler_.reset();
 }
 
 void ResourceLoader::StartRequest() {
   if (delegate_->HandleExternalProtocol(this, request_->url())) {
     CancelAndIgnore();
     return;
@@ skipping 188 matching lines @@
 void ResourceLoader::OnCertificateRequested(
     net::URLRequest* unused,
     net::SSLCertRequestInfo* cert_info) {
   DCHECK_EQ(request_.get(), unused);
 
   if (request_->load_flags() & net::LOAD_PREFETCH) {
     request_->Cancel();
     return;
   }
 
-  DCHECK(!ssl_client_auth_handler_.get())
+  DCHECK(!ssl_client_auth_handler_)
       << "OnCertificateRequested called with ssl_client_auth_handler pending";
-  ssl_client_auth_handler_ = new SSLClientAuthHandler(
-      GetRequestInfo()->GetContext()->CreateClientCertStore(),
-      request_.get(),
-      cert_info,
-      base::Bind(&ResourceLoader::ContinueWithCertificate,
-                 weak_ptr_factory_.GetWeakPtr()));
+  ssl_client_auth_handler_.reset(new SSLClientAuthHandler(
+      GetRequestInfo()->GetContext()->CreateClientCertStore(), request_.get(),
+      cert_info, base::Bind(&ResourceLoader::ContinueWithCertificate,
+                            weak_ptr_factory_.GetWeakPtr())));
   ssl_client_auth_handler_->SelectCertificate();
 }
 
 void ResourceLoader::OnSSLCertificateError(net::URLRequest* request,
                                            const net::SSLInfo& ssl_info,
                                            bool fatal) {
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
   int render_process_id;
   int render_frame_id;
@@ skipping 252 matching lines @@
   }
 
   // TODO(darin): Perhaps we should really be looking to see if the status is
   // IO_PENDING?
   bool was_pending = request_->is_pending();
 
   if (login_delegate_.get()) {
     login_delegate_->OnRequestCancelled();
     login_delegate_ = NULL;
   }
-  if (ssl_client_auth_handler_.get()) {
-    ssl_client_auth_handler_->OnRequestCancelled();
-    ssl_client_auth_handler_ = NULL;
-  }
+  ssl_client_auth_handler_.reset();
 
   request_->CancelWithError(error);
 
   if (!was_pending) {
     // If the request isn't in flight, then we won't get an asynchronous
     // notification from the request, so we have to signal ourselves to finish
     // this request.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ResourceLoader::ResponseCompleted,
@@ skipping 246 matching lines @@
       case net::URLRequestStatus::FAILED:
         status = STATUS_UNDEFINED;
         break;
     }
 
     UMA_HISTOGRAM_ENUMERATION("Net.Prefetch.Pattern", status, STATUS_MAX);
   }
 }
 
 void ResourceLoader::ContinueWithCertificate(net::X509Certificate* cert) {
-  ssl_client_auth_handler_ = NULL;
+  ssl_client_auth_handler_.reset();

[pneubeck (no reviews), 2014/12/14 16:45:12]

please don't do this in a call stack containing ssl_client_auth_handler_ as a
this ptr.
you could probably reuse the existing weak_ptr_factory_ to delay the deletion.

[davidben, 2015/01/23 21:05:35]

Made it a DeleteSoon.

   request_->ContinueWithCertificate(cert);
 }
 
 }  // namespace content