Get ClientCertStore through ResourceContext.

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/time/time.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/loader/cross_site_resource_handler.h"
 #include "content/browser/loader/resource_loader_delegate.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/ssl/ssl_client_auth_handler.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/public/browser/cert_store.h"
+#include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/resource_dispatcher_host_login_delegate.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
-#include "net/ssl/client_cert_store.h"
-#include "net/ssl/client_cert_store_impl.h"
 #include "webkit/browser/appcache/appcache_interceptor.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace content {
 namespace {
 
 void PopulateResourceResponse(net::URLRequest* request,
                               ResourceResponse* response) {
@@ skipping 20 matching lines @@
   if (request->load_flags() & net::LOAD_ENABLE_LOAD_TIMING)
     request->GetLoadTimingInfo(&response->head.load_timing);
 }
 
 }  // namespace
 
 ResourceLoader::ResourceLoader(scoped_ptr<net::URLRequest> request,
                                scoped_ptr<ResourceHandler> handler,
                                ResourceLoaderDelegate* delegate)
     : weak_ptr_factory_(this) {
-  scoped_ptr<net::ClientCertStore> client_cert_store;
-#if !defined(USE_OPENSSL)
-  client_cert_store.reset(new net::ClientCertStoreImpl());
-#endif
-  Init(request.Pass(), handler.Pass(), delegate, client_cert_store.Pass());
+  deferred_stage_ = DEFERRED_NONE;
+  request_ = request.Pass();
+  handler_ = handler.Pass();
+  delegate_ = delegate;
+  last_upload_position_ = 0;
+  waiting_for_upload_progress_ack_ = false;
+  is_transferring_ = false;
+
+  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();
 
   // Run ResourceHandler destructor before we tear-down the rest of our state
   // as the ResourceHandler may want to inspect the URLRequest and other state.
@@ skipping 96 matching lines @@
 }
 
 void ResourceLoader::ClearSSLClientAuthHandler() {
   ssl_client_auth_handler_ = NULL;
 }
 
 void ResourceLoader::OnUploadProgressACK() {
   waiting_for_upload_progress_ack_ = false;
 }
 
-ResourceLoader::ResourceLoader(
-    scoped_ptr<net::URLRequest> request,
-    scoped_ptr<ResourceHandler> handler,
-    ResourceLoaderDelegate* delegate,
-    scoped_ptr<net::ClientCertStore> client_cert_store)
-    : weak_ptr_factory_(this) {
-  Init(request.Pass(), handler.Pass(), delegate, client_cert_store.Pass());
-}
-
-void ResourceLoader::Init(scoped_ptr<net::URLRequest> request,
-                          scoped_ptr<ResourceHandler> handler,
-                          ResourceLoaderDelegate* delegate,
-                          scoped_ptr<net::ClientCertStore> client_cert_store) {
-  deferred_stage_ = DEFERRED_NONE;
-  request_ = request.Pass();
-  handler_ = handler.Pass();
-  delegate_ = delegate;
-  last_upload_position_ = 0;
-  waiting_for_upload_progress_ack_ = false;
-  is_transferring_ = false;
-  client_cert_store_ = client_cert_store.Pass();
-
-  request_->set_delegate(this);
-  handler_->SetController(this);
-}
-
 void ResourceLoader::OnReceivedRedirect(net::URLRequest* unused,
                                         const GURL& new_url,
                                         bool* defer) {
   DCHECK_EQ(request_.get(), unused);
 
   VLOG(1) << "OnReceivedRedirect: " << request_->url().spec();
   DCHECK(request_->status().is_success());
 
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
@@ skipping 54 matching lines @@
 void ResourceLoader::OnCertificateRequested(
     net::URLRequest* unused,
     net::SSLCertRequestInfo* cert_info) {
   DCHECK_EQ(request_.get(), unused);
 
   if (!delegate_->AcceptSSLClientCertificateRequest(this, cert_info)) {
     request_->Cancel();
     return;
   }
 
-#if !defined(USE_OPENSSL)
-  client_cert_store_->GetClientCerts(*cert_info, &cert_info->client_certs);
-  if (cert_info->client_certs.empty()) {
-    // No need to query the user if there are no certs to choose from.
-    request_->ContinueWithCertificate(NULL);
-    return;
-  }
-#endif
-
   DCHECK(!ssl_client_auth_handler_.get())
       << "OnCertificateRequested called with ssl_client_auth_handler pending";
-  ssl_client_auth_handler_ = new SSLClientAuthHandler(request_.get(),
-                                                      cert_info);
+  ssl_client_auth_handler_ = new SSLClientAuthHandler(
+      GetRequestInfo()->GetContext(), request_.get(), cert_info);
   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_view_id;
@@ skipping 338 matching lines @@
     // we resume.
     deferred_stage_ = DEFERRED_FINISH;
   }
 }
 
 void ResourceLoader::CallDidFinishLoading() {
   delegate_->DidFinishLoading(this);
 }
 
 }  // namespace content