Handle cases when user cert database has NULL slots

chrome/browser/certificate_manager_model.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/certificate_manager_model.h"
 
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 46 matching lines @@
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&CertificateManagerModel::GetCertDBOnIOThread,
                  browser_context->GetResourceContext(),
                  observer,
                  callback));
 }
 
 CertificateManagerModel::CertificateManagerModel(
     net::NSSCertDatabase* nss_cert_database,
+    bool is_user_db_available,
     bool is_tpm_available,
     Observer* observer)
     : cert_db_(nss_cert_database),
+      is_user_db_available_(is_user_db_available),
       is_tpm_available_(is_tpm_available),
       observer_(observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 CertificateManagerModel::~CertificateManagerModel() {
 }
 
 void CertificateManagerModel::Refresh() {
   DVLOG(1) << "refresh started";
@@ skipping 120 matching lines @@
 }
 
 bool CertificateManagerModel::IsHardwareBacked(
     const net::X509Certificate* cert) const {
   return cert_db_->IsHardwareBacked(cert);
 }
 
 // static
 void CertificateManagerModel::DidGetCertDBOnUIThread(
     net::NSSCertDatabase* cert_db,
+    bool is_user_db_available,
     bool is_tpm_available,
     CertificateManagerModel::Observer* observer,
     const CreationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  scoped_ptr<CertificateManagerModel> model(
-      new CertificateManagerModel(cert_db, is_tpm_available, observer));
+  scoped_ptr<CertificateManagerModel> model(new CertificateManagerModel(
+      cert_db, is_user_db_available, is_tpm_available, observer));
   callback.Run(model.Pass());
 }
 
 // static
 void CertificateManagerModel::DidGetCertDBOnIOThread(
     CertificateManagerModel::Observer* observer,
     const CreationCallback& callback,
     net::NSSCertDatabase* cert_db) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  bool is_user_db_available = cert_db->GetPublicSlot();
   bool is_tpm_available = false;
 #if defined(OS_CHROMEOS)
   is_tpm_available = crypto::IsTPMTokenEnabledForNSS();
 #endif
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&CertificateManagerModel::DidGetCertDBOnUIThread,
                  cert_db,
+                 is_user_db_available,
                  is_tpm_available,
                  observer,
                  callback));
 }
 
 // static
 void CertificateManagerModel::GetCertDBOnIOThread(
     content::ResourceContext* context,
     CertificateManagerModel::Observer* observer,
     const CreationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::NSSCertDatabase* cert_db = GetNSSCertDatabaseForResourceContext(
       context,
       base::Bind(&CertificateManagerModel::DidGetCertDBOnIOThread,
                  observer,
                  callback));
   if (cert_db)
     DidGetCertDBOnIOThread(observer, callback, cert_db);
 }