Get ClientCertStore through ResourceContext.

content/browser/loader/resource_loader_unittest.cc

 // Copyright (c) 2013 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/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/loader/resource_loader_delegate.h"
 #include "content/public/browser/resource_request_info.h"
@@ skipping 30 matching lines @@
   std::vector<std::string> requested_authorities() {
     return requested_authorities_;
   }
 
   // Returns the number of calls to GetClientCerts().
   int request_count() {
     return request_count_;
   }
 
   // net::ClientCertStore:
-  virtual bool GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
-                              net::CertificateList* selected_certs) OVERRIDE {
+  virtual void GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
+                              net::CertificateList* selected_certs,
+                              const base::Closure& callback) OVERRIDE {
     ++request_count_;
     requested_authorities_ = cert_request_info.cert_authorities;
     *selected_certs = response_;
-    return true;
+    callback.Run();
   }
 
  private:
   const net::CertificateList response_;
   int request_count_;
   std::vector<std::string> requested_authorities_;
 };
 
 // Dummy implementation of ResourceHandler, instance of which is needed to
 // initialize ResourceLoader.
@@ skipping 69 matching lines @@
 
   net::CertificateList passed_certs() {
     return passed_certs_;
   }
 
  private:
   net::CertificateList passed_certs_;
   int call_count_;
 };
 
+class ResourceContextStub : public MockResourceContext {
+ public:
+  explicit ResourceContextStub(net::URLRequestContext* test_request_context)
+      : MockResourceContext(test_request_context) {}
+
+  virtual scoped_ptr<net::ClientCertStore> CreateClientCertStore() OVERRIDE {
+    return dummy_cert_store_.Pass();
+  }
+
+  void SetClientCertStore(scoped_ptr<net::ClientCertStore> store) {
+    dummy_cert_store_ = store.Pass();
+  }
+
+ private:
+  scoped_ptr<net::ClientCertStore> dummy_cert_store_;
+};
+
 }  // namespace
 
 class ResourceLoaderTest : public testing::Test,
                            public ResourceLoaderDelegate {
  protected:
   ResourceLoaderTest()
     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
       resource_context_(&test_url_request_context_) {
   }
 
@@ skipping 19 matching lines @@
   }
   virtual void DidStartRequest(ResourceLoader* loader) OVERRIDE {}
   virtual void DidReceiveRedirect(ResourceLoader* loader,
                                   const GURL& new_url) OVERRIDE {}
   virtual void DidReceiveResponse(ResourceLoader* loader) OVERRIDE {}
   virtual void DidFinishLoading(ResourceLoader* loader) OVERRIDE {}
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   net::TestURLRequestContext test_url_request_context_;
-  content::MockResourceContext resource_context_;
+  ResourceContextStub resource_context_;
 };
 
-// When OpenSSL is used, client cert store is not being queried in
-// ResourceLoader.
-#if !defined(USE_OPENSSL)
 // Verifies if a call to net::UrlRequest::Delegate::OnCertificateRequested()
 // causes client cert store to be queried for certificates and if the returned
 // certificates are correctly passed to the content browser client for
 // selection.
 TEST_F(ResourceLoaderTest, ClientCertStoreLookup) {
   const int kRenderProcessId = 1;
   const int kRenderViewId = 2;
 
   scoped_ptr<net::URLRequest> request(new net::URLRequest(
       GURL("dummy"), NULL,
@@ skipping 10 matching lines @@
       new net::X509Certificate("test", "test", base::Time(), base::Time())));
   scoped_ptr<ClientCertStoreStub> test_store(
       new ClientCertStoreStub(dummy_certs));
   EXPECT_EQ(0, test_store->request_count());
 
   // Ownership of the |request| and |test_store| is about to be turned over to
   // ResourceLoader. We need to keep raw pointer copies to access these objects
   // later.
   net::URLRequest* raw_ptr_to_request = request.get();
   ClientCertStoreStub* raw_ptr_to_store = test_store.get();
+  resource_context_.SetClientCertStore(
+      test_store.PassAs<net::ClientCertStore>());
 
   scoped_ptr<ResourceHandler> resource_handler(new ResourceHandlerStub());
-  ResourceLoader loader(request.Pass(), resource_handler.Pass(), this,
-                        test_store.PassAs<net::ClientCertStore>());
+  ResourceLoader loader(request.Pass(), resource_handler.Pass(), this);
 
   // Prepare a dummy certificate request.
   scoped_refptr<net::SSLCertRequestInfo> cert_request_info(
       new net::SSLCertRequestInfo());
   std::vector<std::string> dummy_authority(1, "dummy");
   cert_request_info->cert_authorities = dummy_authority;
 
   // Plug in test content browser client.
   SelectCertificateBrowserClient test_client;
   ContentBrowserClient* old_client = SetBrowserClientForTesting(&test_client);
 
   // Everything is set up. Trigger the resource loader certificate request event
   // and run the message loop.
   loader.OnCertificateRequested(raw_ptr_to_request, cert_request_info.get());
   base::RunLoop().RunUntilIdle();
 
   // Restore the original content browser client.
   SetBrowserClientForTesting(old_client);
 
   // Check if the test store was queried against correct |cert_authorities|.
   EXPECT_EQ(1, raw_ptr_to_store->request_count());
   EXPECT_EQ(dummy_authority, raw_ptr_to_store->requested_authorities());
 
   // Check if the retrieved certificates were passed to the content browser
   // client.
   EXPECT_EQ(1, test_client.call_count());
   EXPECT_EQ(dummy_certs, test_client.passed_certs());
 }
-#endif  // !defined(OPENSSL)
+
+// Verifies if a call to net::URLRequest::Delegate::OnCertificateRequested()
+// on a platform with a NULL client cert store still calls the content browser
+// client for selection.
+TEST_F(ResourceLoaderTest, ClientCertStoreNull) {
+  const int kRenderProcessId = 1;
+  const int kRenderViewId = 2;
+
+  scoped_ptr<net::URLRequest> request(new net::URLRequest(
+      GURL("dummy"), NULL, resource_context_.GetRequestContext()));
+  ResourceRequestInfo::AllocateForTesting(request.get(),
+                                          ResourceType::MAIN_FRAME,
+                                          &resource_context_,
+                                          kRenderProcessId,
+                                          kRenderViewId,
+                                          false);
+
+  // Ownership of the |request| is about to be turned over to ResourceLoader. We
+  // need to keep a raw pointer copy to access this object later.
+  net::URLRequest* raw_ptr_to_request = request.get();
+
+  scoped_ptr<ResourceHandler> resource_handler(new ResourceHandlerStub());
+  ResourceLoader loader(request.Pass(), resource_handler.Pass(), this);
+
+  // Prepare a dummy certificate request.
+  scoped_refptr<net::SSLCertRequestInfo> cert_request_info(
+      new net::SSLCertRequestInfo());
+  std::vector<std::string> dummy_authority(1, "dummy");
+  cert_request_info->cert_authorities = dummy_authority;
+
+  // Plug in test content browser client.
+  SelectCertificateBrowserClient test_client;
+  ContentBrowserClient* old_client = SetBrowserClientForTesting(&test_client);
+
+  // Everything is set up. Trigger the resource loader certificate request event
+  // and run the message loop.
+  loader.OnCertificateRequested(raw_ptr_to_request, cert_request_info.get());
+  base::RunLoop().RunUntilIdle();
+
+  // Restore the original content browser client.
+  SetBrowserClientForTesting(old_client);
+
+  // Check if the SelectClientCertificate was called on the content browser
+  // client.
+  EXPECT_EQ(1, test_client.call_count());
+  EXPECT_EQ(net::CertificateList(), test_client.passed_certs());
+}
 
 }  // namespace content