Copy some x509_certificate_model_nss functions to src/chromeos

chrome/browser/chromeos/options/cert_library.cc

 // Copyright 2013 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/options/cert_library.h"
 
 #include <algorithm>
 
-#include "base/command_line.h"
 #include "base/i18n/string_compare.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list_threadsafe.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"  // g_browser_process
-#include "chrome/common/chrome_switches.h"
-#include "chrome/common/net/x509_certificate_model.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/login_state.h"
+#include "chromeos/network/certificate_helper.h"
 #include "chromeos/network/onc/onc_utils.h"
-#include "content/public/browser/browser_thread.h"
 #include "crypto/nss_util.h"
 #include "net/cert/cert_database.h"
 #include "net/cert/nss_cert_database.h"
 #include "third_party/icu/source/i18n/unicode/coll.h"  // icu::Collator
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_collator.h"
 
 namespace chromeos {
 
 namespace {
 
 // Root CA certificates that are built into Chrome use this token name.
 const char kRootCertificateTokenName[] = "Builtin Object Token";
 
 base::string16 GetDisplayString(net::X509Certificate* cert,
                                 bool hardware_backed) {
-  std::string org;
+  std::string alt_text;
   if (!cert->subject().organization_names.empty())
-    org = cert->subject().organization_names[0];
-  if (org.empty())
-    org = cert->subject().GetDisplayName();
+    alt_text = cert->subject().organization_names[0];
+  if (alt_text.empty())
+    alt_text = cert->subject().GetDisplayName();
   base::string16 issued_by = base::UTF8ToUTF16(
-      x509_certificate_model::GetIssuerCommonName(cert->os_cert_handle(),
-                                                  org));  // alternative text
+      certificate::GetIssuerCommonName(cert->os_cert_handle(), alt_text));
+
   base::string16 issued_to = base::UTF8ToUTF16(
-      x509_certificate_model::GetCertNameOrNickname(cert->os_cert_handle()));
+      certificate::GetCertNameOrNickname(cert->os_cert_handle()));
+  base::string16 issued_to_ascii = base::UTF8ToUTF16(
+      certificate::GetCertAsciiNameOrNickname(cert->os_cert_handle()));
+  if (issued_to_ascii != issued_to) {
+    // Input contained encoded data, show original and decoded forms.
+    issued_to = l10n_util::GetStringFUTF16(IDS_CERT_INFO_IDN_VALUE_FORMAT,
+                                           issued_to_ascii, issued_to);
+  }
 
   if (hardware_backed) {
     return l10n_util::GetStringFUTF16(
         IDS_CERT_MANAGER_HARDWARE_BACKED_KEY_FORMAT_LONG,
         issued_by,
         issued_to,
         l10n_util::GetStringUTF16(IDS_CERT_MANAGER_HARDWARE_BACKED));
   } else {
     return l10n_util::GetStringFUTF16(
         IDS_CERT_MANAGER_KEY_FORMAT_LONG,
@@ skipping 130 matching lines @@
     int slot_id = -1;
     std::string id = CertLoader::GetPkcs11IdAndSlotForCert(*cert, &slot_id);
     if (id == pkcs11_id)
       return index;
   }
   return -1;  // Not found.
 }
 
 void CertLibrary::OnCertificatesLoaded(const net::CertificateList& cert_list,
                                        bool initial_load) {
-  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   VLOG(1) << "CertLibrary::OnCertificatesLoaded: " << cert_list.size();
   certs_.clear();
   user_certs_.clear();
   server_certs_.clear();
   server_ca_certs_.clear();
 
   // Add certificates to the appropriate list.
   for (net::CertificateList::const_iterator iter = cert_list.begin();
        iter != cert_list.end(); ++iter) {
     certs_.push_back(iter->get());
     net::X509Certificate::OSCertHandle cert_handle =
         iter->get()->os_cert_handle();
-    net::CertType type = x509_certificate_model::GetType(cert_handle);
+    net::CertType type = certificate::GetCertType(cert_handle);
     switch (type) {
       case net::USER_CERT:
         user_certs_.push_back(iter->get());
         break;
       case net::SERVER_CERT:
         server_certs_.push_back(iter->get());
         break;
       case net::CA_CERT: {
         // Exclude root CA certificates that are built into Chrome.
-        std::string token_name =
-            x509_certificate_model::GetTokenName(cert_handle);
+        std::string token_name = certificate::GetCertTokenName(cert_handle);
         if (token_name != kRootCertificateTokenName)
           server_ca_certs_.push_back(iter->get());
         break;
       }
       default:
         break;
     }
   }
 
   // Perform locale-sensitive sorting by certificate name.
@@ skipping 32 matching lines @@
     return user_certs_;
   if (type == CERT_TYPE_SERVER)
     return server_certs_;
   if (type == CERT_TYPE_SERVER_CA)
     return server_ca_certs_;
   DCHECK(type == CERT_TYPE_DEFAULT);
   return certs_;
 }
 
 }  // namespace chromeos