Make CertificateProviderService vend ClientCertIdentities directly.

chrome/browser/chromeos/certificate_provider/certificate_requests.cc

 // Copyright 2015 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 "chrome/browser/chromeos/certificate_provider/certificate_requests.h"
 
 #include <memory>
 #include <set>
 #include <utility>
 
@@ skipping 21 matching lines @@
   base::Timer timeout;
 
   // Extensions that this request is still waiting for.
   std::set<std::string> pending_extensions;
 
   // For every extension that replied to this request, there is one entry from
   // extension id to the reported certificates.
   std::map<std::string, CertificateInfoList> extension_to_certificates;
 
   // The callback that must be run with the final list of certificates.
-  base::Callback<void(const net::CertificateList&)> callback;
+  base::Callback<void(net::ClientCertIdentityList)> callback;
 };
 
 CertificateRequests::CertificateRequests() {}
 
 CertificateRequests::~CertificateRequests() {}
 
 int CertificateRequests::AddRequest(
     const std::vector<std::string>& extension_ids,
-    const base::Callback<void(const net::CertificateList&)>& callback,
+    const base::Callback<void(net::ClientCertIdentityList)>& callback,
     const base::Callback<void(int)>& timeout_callback) {
   std::unique_ptr<CertificateRequestState> state(new CertificateRequestState);
   state->callback = callback;
   state->pending_extensions.insert(extension_ids.begin(), extension_ids.end());
 
   const int request_id = next_free_request_id_++;
   state->timeout.Start(
       FROM_HERE, base::TimeDelta::FromMinutes(kGetCertificatesTimeoutInMinutes),
       base::Bind(timeout_callback, request_id));
 
@@ skipping 18 matching lines @@
     return false;
 
   state.extension_to_certificates[extension_id] = certificate_infos;
   *completed = state.pending_extensions.empty();
   return true;
 }
 
 bool CertificateRequests::RemoveRequest(
     int request_id,
     std::map<std::string, CertificateInfoList>* certificates,
-    base::Callback<void(const net::CertificateList&)>* callback) {
+    base::Callback<void(net::ClientCertIdentityList)>* callback) {
   const auto it = requests_.find(request_id);
   if (it == requests_.end())
     return false;
 
   CertificateRequestState& state = *it->second;
   *certificates = state.extension_to_certificates;
   *callback = state.callback;
   requests_.erase(it);
   DVLOG(2) << "Completed certificate request " << request_id;
   return true;
 }
 
 std::vector<int> CertificateRequests::DropExtension(
     const std::string& extension_id) {
   std::vector<int> completed_requests;
   for (const auto& entry : requests_) {
     DVLOG(2) << "Remove extension " << extension_id
              << " from certificate request " << entry.first;
 
     CertificateRequestState& state = *entry.second.get();
     state.pending_extensions.erase(extension_id);
     if (state.pending_extensions.empty())
       completed_requests.push_back(entry.first);
   }
   return completed_requests;
 }
 
 }  // namespace certificate_provider
 }  // namespace chromeos