Remove client_certs from SSLCertRequestInfo.

chrome/browser/chromeos/platform_keys/platform_keys_nss.cc

 // Copyright 2014 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 <cert.h>
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <secder.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 225 matching lines @@
                 std::unique_ptr<net::CertificateList> matches,
                 const std::string& error_message) {
     origin_task_runner_->PostTask(
         from, base::Bind(callback_, base::Passed(&matches), error_message));
   }
 
   const std::string username_hash_;
   const bool use_system_key_slot_;
   scoped_refptr<net::SSLCertRequestInfo> cert_request_info_;
   std::unique_ptr<net::ClientCertStore> cert_store_;
-  std::unique_ptr<net::CertificateList> certs_;
 
  private:
   // Must be called on origin thread, therefore use CallBack().
   subtle::SelectCertificatesCallback callback_;
 };
 
 class GetCertificatesState : public NSSOperationState {
  public:
   explicit GetCertificatesState(const GetCertificatesCallback& callback);
   ~GetCertificatesState() override {}
 
   void OnError(const tracked_objects::Location& from,
                const std::string& error_message) override {
     CallBack(from,
              std::unique_ptr<net::CertificateList>() /* no certificates */,
              error_message);
   }
 
   void CallBack(const tracked_objects::Location& from,
                 std::unique_ptr<net::CertificateList> certs,
                 const std::string& error_message) {
     origin_task_runner_->PostTask(
         from, base::Bind(callback_, base::Passed(&certs), error_message));
   }
-

[davidben, 2017/04/26 02:37:56]

Stray change?

[mattm, 2017/04/26 04:46:15]

Done.

   std::unique_ptr<net::CertificateList> certs_;
 
  private:
   // Must be called on origin thread, therefore use CallBack().
   GetCertificatesCallback callback_;
 };
 
 class ImportCertificateState : public NSSOperationState {
  public:
   ImportCertificateState(const scoped_refptr<net::X509Certificate>& certificate,
@@ skipping 261 matching lines @@
                      .WithPriority(base::TaskPriority::BACKGROUND)
                      .WithShutdownBehavior(
                          base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
       base::Bind(&SignRSAOnWorkerThread, base::Passed(&state)));
 }
 
 // Called when ClientCertStoreChromeOS::GetClientCerts is done. Builds the list
 // of net::CertificateList and calls back. Used by
 // SelectCertificatesOnIOThread().
 void DidSelectCertificatesOnIOThread(
-    std::unique_ptr<SelectCertificatesState> state) {
+    std::unique_ptr<SelectCertificatesState> state,
+    net::CertificateList certs) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  state->CallBack(FROM_HERE, std::move(state->certs_),
+  state->CallBack(FROM_HERE,
+                  base::MakeUnique<net::CertificateList>(std::move(certs)),
                   std::string() /* no error */);
 }
 
 // Continues selecting certificates on the IO thread. Used by
 // SelectClientCertificates().
 void SelectCertificatesOnIOThread(
     std::unique_ptr<SelectCertificatesState> state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state->cert_store_.reset(new ClientCertStoreChromeOS(
       nullptr,  // no additional provider
       base::MakeUnique<ClientCertFilterChromeOS>(state->use_system_key_slot_,
                                                  state->username_hash_),
       ClientCertStoreChromeOS::PasswordDelegateFactory()));
 
-  state->certs_.reset(new net::CertificateList);
-
   SelectCertificatesState* state_ptr = state.get();
   state_ptr->cert_store_->GetClientCerts(
-      *state_ptr->cert_request_info_, state_ptr->certs_.get(),
+      *state_ptr->cert_request_info_,
       base::Bind(&DidSelectCertificatesOnIOThread, base::Passed(&state)));
 }
 
 // Filters the obtained certificates on a worker thread. Used by
 // DidGetCertificates().
 void FilterCertificatesOnWorkerThread(
     std::unique_ptr<GetCertificatesState> state) {
   std::unique_ptr<net::CertificateList> client_certs(new net::CertificateList);
   for (net::CertificateList::const_iterator it = state->certs_->begin();
        it != state->certs_->end();
@@ skipping 321 matching lines @@
   NSSOperationState* state_ptr = state.get();
   GetCertDatabase(std::string() /* don't get any specific slot */,
                   base::Bind(&GetTokensWithDB, base::Passed(&state)),
                   browser_context,
                   state_ptr);
 }
 
 }  // namespace platform_keys
 
 }  // namespace chromeos