CertificateProviderService: Expose certificate lookup.

chrome/browser/chromeos/certificate_provider/certificate_provider_service.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_provider_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
@@ skipping 133 matching lines @@
     certificate_provider::ThreadSafeCertificateMap* certificate_map)
     : service_task_runner_(service_task_runner),
       service_(service),
       certificate_map_(certificate_map) {}
 
 CertificateProviderService::CertKeyProviderImpl::~CertKeyProviderImpl() {}
 
 bool CertificateProviderService::CertKeyProviderImpl::GetCertificateKey(
     const net::X509Certificate& cert,
     scoped_ptr<net::SSLPrivateKey>* private_key) {
+  bool is_currently_provided = false;
   CertificateInfo info;
   std::string extension_id;
-  if (!certificate_map_->LookUpCertificate(cert, &info, &extension_id))
+  certificate_map_->LookUpCertificate(cert, &is_currently_provided, &info,
+                                      &extension_id);
+  if (!is_currently_provided)
     return false;
 
   private_key->reset(
       new SSLPrivateKey(extension_id, info, service_task_runner_, service_));
   return true;
 }
 
 CertificateProviderService::CertificateProviderImpl::CertificateProviderImpl(
     const scoped_refptr<base::SequencedTaskRunner>& service_task_runner,
     const base::WeakPtr<CertificateProviderService>& service)
@@ skipping 176 matching lines @@
   if (!sign_requests_.RemoveRequest(extension_id, sign_request_id, &callback)) {
     LOG(ERROR) << "request id unknown.";
     // Maybe multiple replies to the same request.
     return;
   }
 
   const net::Error error_code = signature.empty() ? net::ERR_FAILED : net::OK;
   callback.Run(error_code, signature);
 }
 
+bool CertificateProviderService::LookUpCertificate(
+    const net::X509Certificate& cert,
+    bool* has_extension,
+    std::string* extension_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  CertificateInfo unused_info;
+  return certificate_map_.LookUpCertificate(cert, has_extension, &unused_info,
+                                            extension_id);
+}
+
 scoped_ptr<CertificateProvider>
 CertificateProviderService::CreateCertificateProvider() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return make_scoped_ptr(new CertificateProviderImpl(
       base::ThreadTaskRunnerHandle::Get(), weak_factory_.GetWeakPtr()));
 }
 
 void CertificateProviderService::OnExtensionUnloaded(
     const std::string& extension_id) {
@@ skipping 82 matching lines @@
   const int sign_request_id = sign_requests_.AddRequest(extension_id, callback);
   if (!delegate_->DispatchSignRequestToExtension(extension_id, sign_request_id,
                                                  hash, certificate, digest)) {
     sign_requests_.RemoveRequest(extension_id, sign_request_id,
                                  nullptr /* callback */);
     callback.Run(net::ERR_FAILED, std::vector<uint8_t>());
   }
 }
 
 }  // namespace chromeos