content/browser/loader/resource_loader_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/loader/resource_loader.h"
   6
   7 #include "base/run_loop.h"
   8 #include "content/browser/browser_thread_impl.h"
   9 #include "content/browser/loader/resource_loader_delegate.h"
  10 #include "content/public/browser/resource_request_info.h"
  11 #include "content/public/test/mock_resource_context.h"
  12 #include "content/public/test/test_browser_thread_bundle.h"
  13 #include "content/test/test_content_browser_client.h"
  14 #include "ipc/ipc_message.h"
  15 #include "net/base/request_priority.h"
  16 #include "net/cert/x509_certificate.h"
  17 #include "net/ssl/client_cert_store.h"
  18 #include "net/ssl/ssl_cert_request_info.h"
  19 #include "net/url_request/url_request.h"
  20 #include "net/url_request/url_request_test_util.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 namespace content {
  24 namespace {
  25
  26 // Stub client certificate store that returns a preset list of certificates for
  27 // each request and records the arguments of the most recent request for later
  28 // inspection.
  29 class ClientCertStoreStub : public net::ClientCertStore {
  30  public:
  31   ClientCertStoreStub(const net::CertificateList& certs)
  32       : response_(certs),
  33         request_count_(0) {}
  34
  35   virtual ~ClientCertStoreStub() {}
  36
  37   // Returns |cert_authorities| field of the certificate request passed in the
  38   // most recent call to GetClientCerts().
  39   // TODO(ppi): Make the stub independent from the internal representation of
  40   // SSLCertRequestInfo. For now it seems that we cannot neither save the
  41   // scoped_refptr<> (since it is never passed to us) nor copy the entire
  42   // CertificateRequestInfo (since there is no copy constructor).
  43   std::vector<std::string> requested_authorities() {
  44     return requested_authorities_;
  45   }
  46
  47   // Returns the number of calls to GetClientCerts().
  48   int request_count() {
  49     return request_count_;
  50   }
  51
  52   // net::ClientCertStore:
  53   virtual void GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
  54                               net::CertificateList* selected_certs,
  55                               const base::Closure& callback) OVERRIDE {
  56     ++request_count_;
  57     requested_authorities_ = cert_request_info.cert_authorities;
  58     *selected_certs = response_;
  59     callback.Run();
  60   }
  61
  62  private:
  63   const net::CertificateList response_;
  64   int request_count_;
  65   std::vector<std::string> requested_authorities_;
  66 };
  67
  68 // Dummy implementation of ResourceHandler, instance of which is needed to
  69 // initialize ResourceLoader.
  70 class ResourceHandlerStub : public ResourceHandler {
  71  public:
  72   ResourceHandlerStub() : ResourceHandler(NULL) {}
  73
  74   virtual bool OnUploadProgress(int request_id,
  75                                 uint64 position,
  76                                 uint64 size) OVERRIDE {
  77     return true;
  78   }
  79
  80   virtual bool OnRequestRedirected(int request_id,
  81                                    const GURL& url,
  82                                    ResourceResponse* response,
  83                                    bool* defer) OVERRIDE {
  84     return true;
  85   }
  86
  87   virtual bool OnResponseStarted(int request_id,
  88                                  ResourceResponse* response,
  89                                  bool* defer) OVERRIDE { return true; }
  90
  91   virtual bool OnWillStart(int request_id,
  92                            const GURL& url,
  93                            bool* defer) OVERRIDE {
  94     return true;
  95   }
  96
  97   virtual bool OnBeforeNetworkStart(int request_id,
  98                                     const GURL& url,
  99                                     bool* defer) OVERRIDE {
 100     return true;
 101   }
 102
 103   virtual bool OnWillRead(int request_id,
 104                           scoped_refptr<net::IOBuffer>* buf,
 105                           int* buf_size,
 106                           int min_size) OVERRIDE {
 107     return true;
 108   }
 109
 110   virtual bool OnReadCompleted(int request_id,
 111                                int bytes_read,
 112                                bool* defer) OVERRIDE {
 113     return true;
 114   }
 115
 116   virtual void OnResponseCompleted(int request_id,
 117                                    const net::URLRequestStatus& status,
 118                                    const std::string& security_info,
 119                                    bool* defer) OVERRIDE {
 120   }
 121
 122   virtual void OnDataDownloaded(int request_id,
 123                                 int bytes_downloaded) OVERRIDE {}
 124 };
 125
 126 // Test browser client that captures calls to SelectClientCertificates and
 127 // records the arguments of the most recent call for later inspection.
 128 class SelectCertificateBrowserClient : public TestContentBrowserClient {
 129  public:
 130   SelectCertificateBrowserClient() : call_count_(0) {}
 131
 132   virtual void SelectClientCertificate(
 133       int render_process_id,
 134       int render_view_id,
 135       const net::HttpNetworkSession* network_session,
 136       net::SSLCertRequestInfo* cert_request_info,
 137       const base::Callback<void(net::X509Certificate*)>& callback) OVERRIDE {
 138     ++call_count_;
 139     passed_certs_ = cert_request_info->client_certs;
 140   }
 141
 142   int call_count() {
 143     return call_count_;
 144   }
 145
 146   net::CertificateList passed_certs() {
 147     return passed_certs_;
 148   }
 149
 150  private:
 151   net::CertificateList passed_certs_;
 152   int call_count_;
 153 };
 154
 155 class ResourceContextStub : public MockResourceContext {
 156  public:
 157   explicit ResourceContextStub(net::URLRequestContext* test_request_context)
 158       : MockResourceContext(test_request_context) {}
 159
 160   virtual scoped_ptr<net::ClientCertStore> CreateClientCertStore() OVERRIDE {
 161     return dummy_cert_store_.Pass();
 162   }
 163
 164   void SetClientCertStore(scoped_ptr<net::ClientCertStore> store) {
 165     dummy_cert_store_ = store.Pass();
 166   }
 167
 168  private:
 169   scoped_ptr<net::ClientCertStore> dummy_cert_store_;
 170 };
 171
 172 }  // namespace
 173
 174 class ResourceLoaderTest : public testing::Test,
 175                            public ResourceLoaderDelegate {
 176  protected:
 177   ResourceLoaderTest()
 178     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
 179       resource_context_(&test_url_request_context_) {
 180   }
 181
 182   // ResourceLoaderDelegate:
 183   virtual ResourceDispatcherHostLoginDelegate* CreateLoginDelegate(
 184       ResourceLoader* loader,
 185       net::AuthChallengeInfo* auth_info) OVERRIDE {
 186     return NULL;
 187   }
 188   virtual bool HandleExternalProtocol(ResourceLoader* loader,
 189                                       const GURL& url) OVERRIDE {
 190     return false;
 191   }
 192   virtual void DidStartRequest(ResourceLoader* loader) OVERRIDE {}
 193   virtual void DidReceiveRedirect(ResourceLoader* loader,
 194                                   const GURL& new_url) OVERRIDE {}
 195   virtual void DidReceiveResponse(ResourceLoader* loader) OVERRIDE {}
 196   virtual void DidFinishLoading(ResourceLoader* loader) OVERRIDE {}
 197
 198   content::TestBrowserThreadBundle thread_bundle_;
 199
 200   net::TestURLRequestContext test_url_request_context_;
 201   ResourceContextStub resource_context_;
 202 };
 203
 204 // Verifies if a call to net::UrlRequest::Delegate::OnCertificateRequested()
 205 // causes client cert store to be queried for certificates and if the returned
 206 // certificates are correctly passed to the content browser client for
 207 // selection.
 208 TEST_F(ResourceLoaderTest, ClientCertStoreLookup) {
 209   const int kRenderProcessId = 1;
 210   const int kRenderViewId = 2;
 211
 212   scoped_ptr<net::URLRequest> request(
 213       new net::URLRequest(GURL("dummy"),
 214                           net::DEFAULT_PRIORITY,
 215                           NULL,
 216                           resource_context_.GetRequestContext()));
 217   ResourceRequestInfo::AllocateForTesting(request.get(),
 218                                           ResourceType::MAIN_FRAME,
 219                                           &resource_context_,
 220                                           kRenderProcessId,
 221                                           kRenderViewId,
 222                                           MSG_ROUTING_NONE,
 223                                           false);
 224
 225   // Set up the test client cert store.
 226   net::CertificateList dummy_certs(1, scoped_refptr<net::X509Certificate>(
 227       new net::X509Certificate("test", "test", base::Time(), base::Time())));
 228   scoped_ptr<ClientCertStoreStub> test_store(
 229       new ClientCertStoreStub(dummy_certs));
 230   EXPECT_EQ(0, test_store->request_count());
 231
 232   // Ownership of the |request| and |test_store| is about to be turned over to
 233   // ResourceLoader. We need to keep raw pointer copies to access these objects
 234   // later.
 235   net::URLRequest* raw_ptr_to_request = request.get();
 236   ClientCertStoreStub* raw_ptr_to_store = test_store.get();
 237   resource_context_.SetClientCertStore(
 238       test_store.PassAs<net::ClientCertStore>());
 239
 240   scoped_ptr<ResourceHandler> resource_handler(new ResourceHandlerStub());
 241   ResourceLoader loader(request.Pass(), resource_handler.Pass(), this);
 242
 243   // Prepare a dummy certificate request.
 244   scoped_refptr<net::SSLCertRequestInfo> cert_request_info(
 245       new net::SSLCertRequestInfo());
 246   std::vector<std::string> dummy_authority(1, "dummy");
 247   cert_request_info->cert_authorities = dummy_authority;
 248
 249   // Plug in test content browser client.
 250   SelectCertificateBrowserClient test_client;
 251   ContentBrowserClient* old_client = SetBrowserClientForTesting(&test_client);
 252
 253   // Everything is set up. Trigger the resource loader certificate request event
 254   // and run the message loop.
 255   loader.OnCertificateRequested(raw_ptr_to_request, cert_request_info.get());
 256   base::RunLoop().RunUntilIdle();
 257
 258   // Restore the original content browser client.
 259   SetBrowserClientForTesting(old_client);
 260
 261   // Check if the test store was queried against correct |cert_authorities|.
 262   EXPECT_EQ(1, raw_ptr_to_store->request_count());
 263   EXPECT_EQ(dummy_authority, raw_ptr_to_store->requested_authorities());
 264
 265   // Check if the retrieved certificates were passed to the content browser
 266   // client.
 267   EXPECT_EQ(1, test_client.call_count());
 268   EXPECT_EQ(dummy_certs, test_client.passed_certs());
 269 }
 270
 271 // Verifies if a call to net::URLRequest::Delegate::OnCertificateRequested()
 272 // on a platform with a NULL client cert store still calls the content browser
 273 // client for selection.
 274 TEST_F(ResourceLoaderTest, ClientCertStoreNull) {
 275   const int kRenderProcessId = 1;
 276   const int kRenderViewId = 2;
 277
 278   scoped_ptr<net::URLRequest> request(
 279       new net::URLRequest(GURL("dummy"),
 280                           net::DEFAULT_PRIORITY,
 281                           NULL,
 282                           resource_context_.GetRequestContext()));
 283   ResourceRequestInfo::AllocateForTesting(request.get(),
 284                                           ResourceType::MAIN_FRAME,
 285                                           &resource_context_,
 286                                           kRenderProcessId,
 287                                           kRenderViewId,
 288                                           MSG_ROUTING_NONE,
 289                                           false);
 290
 291   // Ownership of the |request| is about to be turned over to ResourceLoader. We
 292   // need to keep a raw pointer copy to access this object later.
 293   net::URLRequest* raw_ptr_to_request = request.get();
 294
 295   scoped_ptr<ResourceHandler> resource_handler(new ResourceHandlerStub());
 296   ResourceLoader loader(request.Pass(), resource_handler.Pass(), this);
 297
 298   // Prepare a dummy certificate request.
 299   scoped_refptr<net::SSLCertRequestInfo> cert_request_info(
 300       new net::SSLCertRequestInfo());
 301   std::vector<std::string> dummy_authority(1, "dummy");
 302   cert_request_info->cert_authorities = dummy_authority;
 303
 304   // Plug in test content browser client.
 305   SelectCertificateBrowserClient test_client;
 306   ContentBrowserClient* old_client = SetBrowserClientForTesting(&test_client);
 307
 308   // Everything is set up. Trigger the resource loader certificate request event
 309   // and run the message loop.
 310   loader.OnCertificateRequested(raw_ptr_to_request, cert_request_info.get());
 311   base::RunLoop().RunUntilIdle();
 312
 313   // Restore the original content browser client.
 314   SetBrowserClientForTesting(old_client);
 315
 316   // Check if the SelectClientCertificate was called on the content browser
 317   // client.
 318   EXPECT_EQ(1, test_client.call_count());
 319   EXPECT_EQ(net::CertificateList(), test_client.passed_certs());
 320 }
 321
 322 }  // namespace content