Remove SSLClientAuthHandler's RDH dependency.

content/browser/ssl/ssl_client_auth_handler.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/ssl/ssl_client_auth_handler.h"
 
 #include "base/bind.h"
-#include "content/browser/loader/resource_dispatcher_host_impl.h"
+#include "base/callback_helpers.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/ssl/client_cert_store.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 namespace content {
 
 SSLClientAuthHandler::SSLClientAuthHandler(
     scoped_ptr<net::ClientCertStore> client_cert_store,
     net::URLRequest* request,
-    net::SSLCertRequestInfo* cert_request_info)
+    net::SSLCertRequestInfo* cert_request_info,
+    const SSLClientAuthHandler::CertificateCallback& callback)
     : request_(request),
       http_network_session_(
           request_->context()->http_transaction_factory()->GetSession()),
       cert_request_info_(cert_request_info),
-      client_cert_store_(client_cert_store.Pass()) {
+      client_cert_store_(client_cert_store.Pass()),
+      callback_(callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 SSLClientAuthHandler::~SSLClientAuthHandler() {
   // If we were simply dropped, then act as if we selected no certificate.
   DoCertificateSelected(NULL);
 }
 
 void SSLClientAuthHandler::OnRequestCancelled() {
   request_ = NULL;
+  callback_.Reset();
 }
 
 void SSLClientAuthHandler::SelectCertificate() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(request_);
 
   if (client_cert_store_) {
     client_cert_store_->GetClientCerts(
         *cert_request_info_,
         &cert_request_info_->client_certs,
@@ skipping 48 matching lines @@
           render_process_host_id, render_frame_host_id));
 }
 
 void SSLClientAuthHandler::DoCertificateSelected(net::X509Certificate* cert) {
   VLOG(1) << this << " DoCertificateSelected " << cert;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // request_ could have been NULLed if the request was cancelled while the
   // user was choosing a cert, or because we have already responded to the
   // certificate.
   if (request_) {
-    request_->ContinueWithCertificate(cert);
-
-    ResourceDispatcherHostImpl::Get()->
-        ClearSSLClientAuthHandlerForRequest(request_);
+    DCHECK(!callback_.is_null());
+    base::ResetAndReturn(&callback_).Run(cert);
     request_ = NULL;

[mmenke, 2014/09/23 19:24:23]

Should we clear request_ first?  If the ResetAndReturn gets us anything, seems
like request_ should be reset first.  If it doesn't get us anything, I'm not
sure if we should be using ResetAndReturn, or just NULLing out the callback when
done.

[davidben, 2014/09/23 21:22:02]

No longer relevant.

   }
 }
 
 void SSLClientAuthHandler::DoSelectCertificate(
     int render_process_host_id, int render_frame_host_id) {
   GetContentClient()->browser()->SelectClientCertificate(
       render_process_host_id,
       render_frame_host_id,
       http_network_session_,
       cert_request_info_.get(),
       base::Bind(&SSLClientAuthHandler::CertificateSelected, this));
 }
 
 }  // namespace content