Remove client_certs from SSLCertRequestInfo.

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 <stddef.h>
 #include <stdint.h>
 
 #include <deque>
@@ skipping 72 matching lines @@
         requested_authorities_(requested_authorities),
         request_count_(request_count) {
     requested_authorities_->clear();
     *request_count_ = 0;
   }
 
   ~ClientCertStoreStub() override {}
 
   // net::ClientCertStore:
   void GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
-                      net::CertificateList* selected_certs,
-                      const base::Closure& callback) override {
+                      const ClientCertListCallback& callback) override {
     *requested_authorities_ = cert_request_info.cert_authorities;
     ++(*request_count_);
 
-    *selected_certs = response_;
-    callback.Run();
+    callback.Run(response_);
   }
 
  private:
   const net::CertificateList response_;
   std::vector<std::string>* requested_authorities_;
   int* request_count_;
 };
 
 // Client certificate store which destroys its resource loader before the
 // asynchronous GetClientCerts callback is called.
 class LoaderDestroyingCertStore : public net::ClientCertStore {
  public:
   // Creates a client certificate store which, when looked up, posts a task to
   // reset |loader| and then call the callback. The caller is responsible for
   // ensuring the pointers remain valid until the process is complete.
   LoaderDestroyingCertStore(std::unique_ptr<ResourceLoader>* loader,
                             const base::Closure& on_loader_deleted_callback)
       : loader_(loader),
         on_loader_deleted_callback_(on_loader_deleted_callback) {}
 
   // net::ClientCertStore:
-  void GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
-                      net::CertificateList* selected_certs,
-                      const base::Closure& cert_selected_callback) override {
+  void GetClientCerts(
+      const net::SSLCertRequestInfo& cert_request_info,
+      const ClientCertListCallback& cert_selected_callback) override {
     // Don't destroy |loader_| while it's on the stack.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&LoaderDestroyingCertStore::DoCallback,
-                              base::Unretained(loader_),
-                              cert_selected_callback,
+                              base::Unretained(loader_), cert_selected_callback,
                               on_loader_deleted_callback_));
   }
 
  private:
   // This needs to be static because |loader| owns the
   // LoaderDestroyingCertStore (ClientCertStores are actually handles, and not
   // global cert stores).
   static void DoCallback(std::unique_ptr<ResourceLoader>* loader,
-                         const base::Closure& cert_selected_callback,
+                         const ClientCertListCallback& cert_selected_callback,
                          const base::Closure& on_loader_deleted_callback) {
     loader->reset();
-    cert_selected_callback.Run();
+    cert_selected_callback.Run(net::CertificateList());
     on_loader_deleted_callback.Run();
   }
 
   std::unique_ptr<ResourceLoader>* loader_;
   base::Closure on_loader_deleted_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(LoaderDestroyingCertStore);
 };
 
 // A mock URLRequestJob which simulates an SSL client auth request.
@@ skipping 122 matching lines @@
   void WaitForSelectCertificate() {
     select_certificate_run_loop_.Run();
     // Process any pending messages - just so tests can check if
     // SelectClientCertificate was called more than once.
     base::RunLoop().RunUntilIdle();
   }
 
   void SelectClientCertificate(
       WebContents* web_contents,
       net::SSLCertRequestInfo* cert_request_info,
+      net::CertificateList client_certs,
       std::unique_ptr<ClientCertificateDelegate> delegate) override {
     EXPECT_FALSE(delegate_.get());
 
     ++call_count_;
-    passed_certs_ = cert_request_info->client_certs;
+    passed_certs_ = std::move(client_certs);
     delegate_ = std::move(delegate);
     select_certificate_run_loop_.Quit();
   }
 
   int call_count() { return call_count_; }
   net::CertificateList passed_certs() { return passed_certs_; }
 
   void ContinueWithCertificate(net::X509Certificate* cert) {
     delegate_->ContinueWithCertificate(cert);
     delegate_.reset();
@@ skipping 1261 matching lines @@
 
 // Tests that the effective connection type is not set on non-main frame
 // requests.
 TEST_F(EffectiveConnectionTypeResourceLoaderTest, DoesNotBelongToMainFrame) {
   VerifyEffectiveConnectionType(RESOURCE_TYPE_OBJECT, false,
                                 net::EFFECTIVE_CONNECTION_TYPE_3G,
                                 net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
 }
 
 }  // namespace content