Refactor client cert private key handling.

chrome/browser/ui/views/certificate_selector.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/ui/views/certificate_selector.h"
 
 #include <stddef.h>  // For size_t.
 #include <string>
 #include <vector>
 
@@ skipping 28 matching lines @@
 #endif
 
 namespace chrome {
 
 const int CertificateSelector::kTableViewWidth = 500;
 const int CertificateSelector::kTableViewHeight = 150;
 
 class CertificateSelector::CertificateTableModel : public ui::TableModel {
  public:
   // |certs| and |provider_names| must have the same size.
-  CertificateTableModel(const net::CertificateList& certs,
+  CertificateTableModel(const net::ClientCertIdentityList& certs,
                         const std::vector<std::string>& provider_names);
 
   // ui::TableModel:
   int RowCount() override;
   base::string16 GetText(int index, int column_id) override;
   void SetObserver(ui::TableModelObserver* observer) override;
 
  private:
   struct Row {
     base::string16 subject;
     base::string16 issuer;
     base::string16 provider;
     base::string16 serial;
   };
   std::vector<Row> rows_;
 
   DISALLOW_COPY_AND_ASSIGN(CertificateTableModel);
 };
 
 CertificateSelector::CertificateTableModel::CertificateTableModel(
-    const net::CertificateList& certs,
+    const net::ClientCertIdentityList& certs,
     const std::vector<std::string>& provider_names) {
   DCHECK_EQ(certs.size(), provider_names.size());
   for (size_t i = 0; i < certs.size(); i++) {
-    net::X509Certificate* cert = certs[i].get();
+    net::X509Certificate* cert = certs[i]->certificate();
     Row row;
     row.subject = base::UTF8ToUTF16(cert->subject().GetDisplayName());
     row.issuer = base::UTF8ToUTF16(cert->issuer().GetDisplayName());
     row.provider = base::UTF8ToUTF16(provider_names[i]);
     if (cert->serial_number().size() < std::numeric_limits<size_t>::max() / 2) {
       row.serial = base::UTF8ToUTF16(base::HexEncode(
           cert->serial_number().data(), cert->serial_number().size()));
     }
     rows_.push_back(row);
   }
@@ skipping 22 matching lines @@
     default:
       NOTREACHED();
   }
   return base::string16();
 }
 
 void CertificateSelector::CertificateTableModel::SetObserver(
     ui::TableModelObserver* observer) {}
 
 CertificateSelector::CertificateSelector(
-    const net::CertificateList& certificates,
+    net::ClientCertIdentityList certificates,
     content::WebContents* web_contents)
     : web_contents_(web_contents), table_(nullptr), view_cert_button_(nullptr) {
   CHECK(web_contents_);
 
   // |provider_names| and |certificates_| are parallel arrays.
   // The entry at index |i| is the provider name for |certificates_[i]|.
   std::vector<std::string> provider_names;
 #if defined(OS_CHROMEOS)
   chromeos::CertificateProviderService* service =
       chromeos::CertificateProviderServiceFactory::GetForBrowserContext(
           web_contents->GetBrowserContext());
   extensions::ExtensionRegistry* extension_registry =
       extensions::ExtensionRegistryFactory::GetForBrowserContext(
           web_contents->GetBrowserContext());
 
-  for (const auto& cert : certificates) {
+  for (auto& cert : certificates) {
     std::string provider_name;
     bool has_extension = false;
     std::string extension_id;
-    if (service->LookUpCertificate(*cert, &has_extension, &extension_id)) {
+    // XXX UGH.
+    if (service->LookUpCertificate(*cert->certificate(), &has_extension,
+                                   &extension_id)) {
       if (!has_extension) {
         // This certificate was provided by an extension but isn't provided by
         // any extension currently. Don't expose it to the user.
         continue;
       }
       const auto* extension = extension_registry->GetExtensionById(
           extension_id, extensions::ExtensionRegistry::ENABLED);
       if (!extension) {
         // This extension was unloaded in the meantime. Don't show the
         // certificate.
         continue;
       }
       provider_name = extension->short_name();
       show_provider_column_ = true;
     }  // Otherwise the certificate is provided by the platform.
 
-    certificates_.push_back(cert);
+    certificates_.push_back(std::move(cert));
     provider_names.push_back(provider_name);
   }
 #else
   provider_names.assign(certificates.size(), std::string());
-  certificates_ = certificates;
+  certificates_ = std::move(certificates);
 #endif
 
   model_.reset(new CertificateTableModel(certificates_, provider_names));
 }
 
 CertificateSelector::~CertificateSelector() {
   table_->SetModel(nullptr);
 }
 
 // static
@@ skipping 62 matching lines @@
                   views::GridLayout::FILL, views::GridLayout::FILL,
                   kTableViewWidth, kTableViewHeight);
 
   layout->AddPaddingRow(0, vertical_spacing);
 }
 
 ui::TableModel* CertificateSelector::table_model_for_testing() const {
   return model_.get();
 }
 
-net::X509Certificate* CertificateSelector::GetSelectedCert() const {
+net::ClientCertIdentity* CertificateSelector::GetSelectedCert() const {
   const int selected = table_->FirstSelectedRow();
   if (selected < 0)  // Nothing is selected in |table_|.
     return nullptr;
   CHECK_LT(static_cast<size_t>(selected), certificates_.size());
   return certificates_[selected].get();
 }
 
 bool CertificateSelector::CanResize() const {
   return true;
 }
@@ skipping 17 matching lines @@
       this, l10n_util::GetStringUTF16(IDS_PAGE_INFO_CERT_INFO_BUTTON));
   return view_cert_button_;
 }
 
 ui::ModalType CertificateSelector::GetModalType() const {
   return ui::MODAL_TYPE_CHILD;
 }
 
 void CertificateSelector::ButtonPressed(views::Button* sender,
                                         const ui::Event& event) {
-  if (sender == view_cert_button_) {
-    net::X509Certificate* const cert = GetSelectedCert();
-    if (cert)
-      ShowCertificateViewer(web_contents_,
-                            web_contents_->GetTopLevelNativeWindow(), cert);
+  if (sender == view_cert_button_ && GetSelectedCert()) {
+    ShowCertificateViewer(web_contents_,
+                          web_contents_->GetTopLevelNativeWindow(),
+                          GetSelectedCert()->certificate());
   }
 }
 
 void CertificateSelector::OnSelectionChanged() {
   GetDialogClientView()->ok_button()->SetEnabled(GetSelectedCert() != nullptr);
 }
 
 void CertificateSelector::OnDoubleClick() {
   if (GetSelectedCert())
     GetDialogClientView()->AcceptWindow();
 }
 
 }  // namespace chrome