Move the NSS functions out of CertDatabase into a new NSSCertDatabase class.

chrome/browser/ui/webui/options/certificate_manager_handler.cc

 // Copyright (c) 2012 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/webui/options/certificate_manager_handler.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 507 matching lines @@
   ShowCertificateViewer(web_ui()->GetWebContents(), GetParentWindow(), cert);
 }
 
 void CertificateManagerHandler::GetCATrust(const ListValue* args) {
   net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   if (!cert) {
     web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
     return;
   }
 
-  net::CertDatabase::TrustBits trust_bits =
-      certificate_manager_model_->cert_db().GetCertTrust(cert, net::CA_CERT);
+  net::NSSCertDatabase::TrustBits trust_bits =
+      certificate_manager_model_->cert_db()->GetCertTrust(cert, net::CA_CERT);
   base::FundamentalValue ssl_value(
-      static_cast<bool>(trust_bits & net::CertDatabase::TRUSTED_SSL));
+      static_cast<bool>(trust_bits & net::NSSCertDatabase::TRUSTED_SSL));
   base::FundamentalValue email_value(
-      static_cast<bool>(trust_bits & net::CertDatabase::TRUSTED_EMAIL));
+      static_cast<bool>(trust_bits & net::NSSCertDatabase::TRUSTED_EMAIL));
   base::FundamentalValue obj_sign_value(
-      static_cast<bool>(trust_bits & net::CertDatabase::TRUSTED_OBJ_SIGN));
+      static_cast<bool>(trust_bits & net::NSSCertDatabase::TRUSTED_OBJ_SIGN));
   web_ui()->CallJavascriptFunction(
       "CertificateEditCaTrustOverlay.populateTrust",
       ssl_value, email_value, obj_sign_value);
 }
 
 void CertificateManagerHandler::EditCATrust(const ListValue* args) {
   net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   bool fail = !cert;
   bool trust_ssl = false;
   bool trust_email = false;
   bool trust_obj_sign = false;
   fail |= !CallbackArgsToBool(args, 1, &trust_ssl);
   fail |= !CallbackArgsToBool(args, 2, &trust_email);
   fail |= !CallbackArgsToBool(args, 3, &trust_obj_sign);
   if (fail) {
     LOG(ERROR) << "EditCATrust args fail";
     web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
     return;
   }
 
   bool result = certificate_manager_model_->SetCertTrust(
       cert,
       net::CA_CERT,
-      trust_ssl * net::CertDatabase::TRUSTED_SSL +
-          trust_email * net::CertDatabase::TRUSTED_EMAIL +
-          trust_obj_sign * net::CertDatabase::TRUSTED_OBJ_SIGN);
+      trust_ssl * net::NSSCertDatabase::TRUSTED_SSL +
+          trust_email * net::NSSCertDatabase::TRUSTED_EMAIL +
+          trust_obj_sign * net::NSSCertDatabase::TRUSTED_OBJ_SIGN);
   web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
   if (!result) {
     // TODO(mattm): better error messages?
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_SET_TRUST_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR));
   }
 }
 
 void CertificateManagerHandler::EditServer(const ListValue* args) {
@@ skipping 50 matching lines @@
   browser::UnlockCertSlotIfNecessary(
       selected_cert_list_[0].get(),
       browser::kCryptoModulePasswordCertExport,
       "",  // unused.
       base::Bind(&CertificateManagerHandler::ExportPersonalSlotsUnlocked,
                  base::Unretained(this)));
 }
 
 void CertificateManagerHandler::ExportPersonalSlotsUnlocked() {
   std::string output;
-  int num_exported = certificate_manager_model_->cert_db().ExportToPKCS12(
+  int num_exported = certificate_manager_model_->cert_db()->ExportToPKCS12(
       selected_cert_list_,
       password_,
       &output);
   if (!num_exported) {
     web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_PKCS12_EXPORT_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR));
     ImportExportCleanup();
     return;
@@ skipping 70 matching lines @@
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_PKCS12_IMPORT_ERROR_TITLE),
         l10n_util::GetStringFUTF8(IDS_CERT_MANAGER_READ_ERROR_FORMAT,
                                   UTF8ToUTF16(safe_strerror(read_errno))));
     return;
   }
 
   file_data_ = data;
 
   if (use_hardware_backed_) {
-    module_ = certificate_manager_model_->cert_db().GetPrivateModule();
+    module_ = certificate_manager_model_->cert_db()->GetPrivateModule();
   } else {
-    module_ = certificate_manager_model_->cert_db().GetPublicModule();
+    module_ = certificate_manager_model_->cert_db()->GetPublicModule();
   }
 
   net::CryptoModuleList modules;
   modules.push_back(module_);
   browser::UnlockSlotsIfNecessary(
       modules,
       browser::kCryptoModulePasswordCertImport,
       "",  // unused.
       base::Bind(&CertificateManagerHandler::ImportPersonalSlotUnlocked,
                  base::Unretained(this)));
@@ skipping 90 matching lines @@
   selected_cert_list_ = net::X509Certificate::CreateCertificateListFromBytes(
           data.data(), data.size(), net::X509Certificate::FORMAT_AUTO);
   if (selected_cert_list_.empty()) {
     ImportExportCleanup();
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_SERVER_IMPORT_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_CERT_PARSE_ERROR));
     return;
   }
 
-  net::CertDatabase::ImportCertFailureList not_imported;
+  net::NSSCertDatabase::ImportCertFailureList not_imported;
   // TODO(mattm): Add UI for trust. http://crbug.com/76274
   bool result = certificate_manager_model_->ImportServerCert(
       selected_cert_list_,
-      net::CertDatabase::TRUST_DEFAULT,
+      net::NSSCertDatabase::TRUST_DEFAULT,
       &not_imported);
   if (!result) {
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_SERVER_IMPORT_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR));
   } else if (!not_imported.empty()) {
     ShowImportErrors(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_SERVER_IMPORT_ERROR_TITLE),
         not_imported);
   }
@@ skipping 34 matching lines @@
           data.data(), data.size(), net::X509Certificate::FORMAT_AUTO);
   if (selected_cert_list_.empty()) {
     ImportExportCleanup();
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_CA_IMPORT_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_CERT_PARSE_ERROR));
     return;
   }
 
   scoped_refptr<net::X509Certificate> root_cert =
-      certificate_manager_model_->cert_db().FindRootInList(selected_cert_list_);
+      certificate_manager_model_->cert_db()->FindRootInList(
+          selected_cert_list_);
 
   // TODO(mattm): check here if root_cert is not a CA cert and show error.
 
   StringValue cert_name(root_cert->subject().GetDisplayName());
   web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.showImport",
                                    cert_name);
 }
 
 void CertificateManagerHandler::ImportCATrustSelected(const ListValue* args) {
   bool fail = false;
   bool trust_ssl = false;
   bool trust_email = false;
   bool trust_obj_sign = false;
   fail |= !CallbackArgsToBool(args, 0, &trust_ssl);
   fail |= !CallbackArgsToBool(args, 1, &trust_email);
   fail |= !CallbackArgsToBool(args, 2, &trust_obj_sign);
   if (fail) {
     LOG(ERROR) << "ImportCATrustSelected args fail";
     ImportExportCleanup();
     web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
     return;
   }
 
   // TODO(mattm): add UI for setting explicit distrust, too.
   // http://crbug.com/128411
-  net::CertDatabase::ImportCertFailureList not_imported;
+  net::NSSCertDatabase::ImportCertFailureList not_imported;
   bool result = certificate_manager_model_->ImportCACerts(
       selected_cert_list_,
-      trust_ssl * net::CertDatabase::TRUSTED_SSL +
-          trust_email * net::CertDatabase::TRUSTED_EMAIL +
-          trust_obj_sign * net::CertDatabase::TRUSTED_OBJ_SIGN,
+      trust_ssl * net::NSSCertDatabase::TRUSTED_SSL +
+          trust_email * net::NSSCertDatabase::TRUSTED_EMAIL +
+          trust_obj_sign * net::NSSCertDatabase::TRUSTED_OBJ_SIGN,
       &not_imported);
   web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
   if (!result) {
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_CA_IMPORT_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR));
   } else if (!not_imported.empty()) {
     ShowImportErrors(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_CA_IMPORT_ERROR_TITLE),
         not_imported);
@@ skipping 56 matching lines @@
       ListValue* subnodes = new ListValue;
       for (net::CertificateList::const_iterator org_cert_it = i->second.begin();
            org_cert_it != i->second.end(); ++org_cert_it) {
         DictionaryValue* cert_dict = new DictionaryValue;
         net::X509Certificate* cert = org_cert_it->get();
         cert_dict->SetString(kKeyId, cert_id_map_->CertToId(cert));
         cert_dict->SetString(kNameId, certificate_manager_model_->GetColumnText(
             *cert, CertificateManagerModel::COL_SUBJECT_NAME));
         cert_dict->SetBoolean(
             kReadOnlyId,
-            certificate_manager_model_->cert_db().IsReadOnly(cert));
+            certificate_manager_model_->cert_db()->IsReadOnly(cert));
         cert_dict->SetBoolean(
             kUntrustedId,
-            certificate_manager_model_->cert_db().IsUntrusted(cert));
+            certificate_manager_model_->cert_db()->IsUntrusted(cert));
         // TODO(hshi): This should be determined by testing for PKCS #11
         // CKA_EXTRACTABLE attribute. We may need to use the NSS function
         // PK11_ReadRawAttribute to do that.
         cert_dict->SetBoolean(
             kExtractableId,
             !certificate_manager_model_->IsHardwareBacked(cert));
         // TODO(mattm): Other columns.
         subnodes->Append(cert_dict);
       }
       std::sort(subnodes->begin(), subnodes->end(), comparator);
@@ skipping 17 matching lines @@
   args.push_back(Value::CreateStringValue(error));
   args.push_back(Value::CreateStringValue(l10n_util::GetStringUTF8(IDS_OK)));
   args.push_back(Value::CreateNullValue());  // cancelTitle
   args.push_back(Value::CreateNullValue());  // okCallback
   args.push_back(Value::CreateNullValue());  // cancelCallback
   web_ui()->CallJavascriptFunction("AlertOverlay.show", args.get());
 }
 
 void CertificateManagerHandler::ShowImportErrors(
     const std::string& title,
-    const net::CertDatabase::ImportCertFailureList& not_imported) const {
+    const net::NSSCertDatabase::ImportCertFailureList& not_imported) const {
   std::string error;
   if (selected_cert_list_.size() == 1)
     error = l10n_util::GetStringUTF8(
         IDS_CERT_MANAGER_IMPORT_SINGLE_NOT_IMPORTED);
   else if (not_imported.size() == selected_cert_list_.size())
     error = l10n_util::GetStringUTF8(IDS_CERT_MANAGER_IMPORT_ALL_NOT_IMPORTED);
   else
     error = l10n_util::GetStringUTF8(IDS_CERT_MANAGER_IMPORT_SOME_NOT_IMPORTED);
 
   ListValue cert_error_list;
   for (size_t i = 0; i < not_imported.size(); ++i) {
-    const net::CertDatabase::ImportCertFailure& failure = not_imported[i];
+    const net::NSSCertDatabase::ImportCertFailure& failure = not_imported[i];
     DictionaryValue* dict = new DictionaryValue;
     dict->SetString(kNameId, failure.certificate->subject().GetDisplayName());
     dict->SetString(kErrorId, NetErrorToString(failure.net_error));
     cert_error_list.Append(dict);
   }
 
   StringValue title_value(title);
   StringValue error_value(error);
   web_ui()->CallJavascriptFunction("CertificateImportErrorOverlay.show",
                                    title_value,
@@ skipping 18 matching lines @@
   web_ui()->CallJavascriptFunction("CertificateManager.onCheckTpmTokenReady",
                                    ready);
 }
 #endif
 
 gfx::NativeWindow CertificateManagerHandler::GetParentWindow() const {
   return web_ui()->GetWebContents()->GetView()->GetTopLevelNativeWindow();
 }
 
 }  // namespace options