favor DCHECK_CURRENTLY_ON for better logs in chrome/browser/chromeos/

chrome/browser/chromeos/platform_keys/platform_keys_nss.cc

 // Copyright 2014 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/platform_keys/platform_keys.h"
 
 #include <cert.h>
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <secder.h>
@@ skipping 76 matching lines @@
 typedef base::Callback<void(net::NSSCertDatabase* cert_db)> GetCertDBCallback;
 
 // Used by GetCertDatabaseOnIOThread and called back with the requested
 // NSSCertDatabase.
 // If |token_id| is not empty, sets |slot_| of |state| accordingly and calls
 // |callback| if the database was successfully retrieved.
 void DidGetCertDBOnIOThread(const std::string& token_id,
                             const GetCertDBCallback& callback,
                             NSSOperationState* state,
                             net::NSSCertDatabase* cert_db) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!cert_db) {
     LOG(ERROR) << "Couldn't get NSSCertDatabase.";
     state->OnError(FROM_HERE, kErrorInternal);
     return;
   }
 
   if (!token_id.empty()) {
     if (token_id == kTokenIdUser)
       state->slot_ = cert_db->GetPrivateSlot();
     else if (token_id == kTokenIdSystem)
       state->slot_ = cert_db->GetSystemSlot();
 
     if (!state->slot_) {
       LOG(ERROR) << "Slot for token id '" << token_id << "' not available.";
       state->OnError(FROM_HERE, kErrorInternal);
       return;
     }
   }
 
   callback.Run(cert_db);
 }
 
 // Retrieves the NSSCertDatabase from |context| and, if |token_id| is not empty,
 // the slot for |token_id|.
 // Must be called on the IO thread.
 void GetCertDatabaseOnIOThread(const std::string& token_id,
                                const GetCertDBCallback& callback,
                                content::ResourceContext* context,
                                NSSOperationState* state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::NSSCertDatabase* cert_db = GetNSSCertDatabaseForResourceContext(
       context, base::Bind(&DidGetCertDBOnIOThread, token_id, callback, state));
 
   if (cert_db)
     DidGetCertDBOnIOThread(token_id, callback, state, cert_db);
 }
 
 // Asynchronously fetches the NSSCertDatabase for |browser_context| and, if
 // |token_id| is not empty, the slot for |token_id|. Stores the slot in |state|
 // and passes the database to |callback|. Will run |callback| on the IO thread.
@@ skipping 281 matching lines @@
   state->CallBack(
       FROM_HERE,
       std::string(public_key_spki_der.begin(), public_key_spki_der.end()),
       std::string() /* no error */);
 }
 
 // Continues generating a RSA key with the obtained NSSCertDatabase. Used by
 // GenerateRSAKey().
 void GenerateRSAKeyWithDB(scoped_ptr<GenerateRSAKeyState> state,
                           net::NSSCertDatabase* cert_db) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Only the slot and not the NSSCertDatabase is required. Ignore |cert_db|.
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&GenerateRSAKeyOnWorkerThread, base::Passed(&state)),
       true /*task is slow*/);
 }
 
 // Does the actual signing on a worker thread. Used by SignRSAWithDB().
 void SignRSAOnWorkerThread(scoped_ptr<SignRSAState> state) {
   const uint8* public_key_uint8 =
@@ skipping 70 matching lines @@
     state->OnError(FROM_HERE, kErrorInternal);
     return;
   }
 
   state->CallBack(FROM_HERE, signature_str, std::string() /* no error */);
 }
 
 // Continues signing with the obtained NSSCertDatabase. Used by Sign().
 void SignRSAWithDB(scoped_ptr<SignRSAState> state,
                    net::NSSCertDatabase* cert_db) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Only the slot and not the NSSCertDatabase is required. Ignore |cert_db|.
   base::WorkerPool::PostTask(
       FROM_HERE, base::Bind(&SignRSAOnWorkerThread, base::Passed(&state)),
       true /*task is slow*/);
 }
 
 // Called when ClientCertStoreChromeOS::GetClientCerts is done. Builds the list
 // of net::CertificateList and calls back. Used by
 // SelectCertificatesOnIOThread().
 void DidSelectCertificatesOnIOThread(
     scoped_ptr<SelectCertificatesState> state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state->CallBack(FROM_HERE, state->certs_.Pass(),
                   std::string() /* no error */);
 }
 
 // Continues selecting certificates on the IO thread. Used by
 // SelectClientCertificates().
 void SelectCertificatesOnIOThread(scoped_ptr<SelectCertificatesState> state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state->cert_store_.reset(new net::ClientCertStoreChromeOS(
       make_scoped_ptr(new chromeos::ClientCertFilterChromeOS(
           state->use_system_key_slot_, state->username_hash_)),
       net::ClientCertStoreChromeOS::PasswordDelegateFactory()));
 
   state->certs_.reset(new net::CertificateList);
 
   SelectCertificatesState* state_ptr = state.get();
   state_ptr->cert_store_->GetClientCerts(
       *state_ptr->cert_request_info_, state_ptr->certs_.get(),
@@ skipping 20 matching lines @@
     client_certs->push_back(*it);
   }
 
   state->CallBack(FROM_HERE, client_certs.Pass(), std::string() /* no error */);
 }
 
 // Passes the obtained certificates to the worker thread for filtering. Used by
 // GetCertificatesWithDB().
 void DidGetCertificates(scoped_ptr<GetCertificatesState> state,
                         scoped_ptr<net::CertificateList> all_certs) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state->certs_ = all_certs.Pass();
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&FilterCertificatesOnWorkerThread, base::Passed(&state)),
       true /*task is slow*/);
 }
 
 // Continues getting certificates with the obtained NSSCertDatabase. Used by
 // GetCertificates().
 void GetCertificatesWithDB(scoped_ptr<GetCertificatesState> state,
                            net::NSSCertDatabase* cert_db) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Get the pointer to slot before base::Passed releases |state|.
   PK11SlotInfo* slot = state->slot_.get();
   cert_db->ListCertsInSlot(
       base::Bind(&DidGetCertificates, base::Passed(&state)), slot);
 }
 
 // Does the actual certificate importing on the IO thread. Used by
 // ImportCertificate().
 void ImportCertificateWithDB(scoped_ptr<ImportCertificateState> state,
                              net::NSSCertDatabase* cert_db) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(pneubeck): Use |state->slot_| to verify that we're really importing to
   // the correct token.
   // |cert_db| is not required, ignore it.
   net::CertDatabase* db = net::CertDatabase::GetInstance();
 
   const net::Error cert_status =
       static_cast<net::Error>(db->CheckUserCert(state->certificate_.get()));
   if (cert_status == net::ERR_NO_PRIVATE_KEY_FOR_CERT) {
     state->OnError(FROM_HERE, kErrorKeyNotFound);
     return;
@@ skipping 18 matching lines @@
     return;
   }
 
   state->CallBack(FROM_HERE, std::string() /* no error */);
 }
 
 // Called on IO thread after the certificate removal is finished.
 void DidRemoveCertificate(scoped_ptr<RemoveCertificateState> state,
                           bool certificate_found,
                           bool success) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // CertificateNotFound error has precedence over an internal error.
   if (!certificate_found) {
     state->OnError(FROM_HERE, kErrorCertificateNotFound);
     return;
   }
   if (!success) {
     state->OnError(FROM_HERE, kErrorInternal);
     return;
   }
 
   state->CallBack(FROM_HERE, std::string() /* no error */);
 }
 
 // Does the actual certificate removal on the IO thread. Used by
 // RemoveCertificate().
 void RemoveCertificateWithDB(scoped_ptr<RemoveCertificateState> state,
                              net::NSSCertDatabase* cert_db) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Get the pointer before base::Passed clears |state|.
   scoped_refptr<net::X509Certificate> certificate = state->certificate_;
   bool certificate_found = certificate->os_cert_handle()->isperm;
   cert_db->DeleteCertAndKeyAsync(
       certificate,
       base::Bind(
           &DidRemoveCertificate, base::Passed(&state), certificate_found));
 }
 
 // Does the actual work to determine which tokens are available.
 void GetTokensWithDB(scoped_ptr<GetTokensState> state,
                      net::NSSCertDatabase* cert_db) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   scoped_ptr<std::vector<std::string> > token_ids(new std::vector<std::string>);
 
   // The user's token is always available.
   token_ids->push_back(kTokenIdUser);
   if (cert_db->GetSystemSlot())
     token_ids->push_back(kTokenIdSystem);
 
   state->CallBack(FROM_HERE, token_ids.Pass(), std::string() /* no error */);
 }
 
 }  // namespace
 
 namespace subtle {
 
 void GenerateRSAKey(const std::string& token_id,
                     unsigned int modulus_length_bits,
                     const GenerateKeyCallback& callback,
                     BrowserContext* browser_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<GenerateRSAKeyState> state(
       new GenerateRSAKeyState(modulus_length_bits, callback));
 
   if (modulus_length_bits > kMaxRSAModulusLengthBits) {
     state->OnError(FROM_HERE, kErrorAlgorithmNotSupported);
     return;
   }
 
   // Get the pointer to |state| before base::Passed releases |state|.
   NSSOperationState* state_ptr = state.get();
   GetCertDatabase(token_id,
                   base::Bind(&GenerateRSAKeyWithDB, base::Passed(&state)),
                   browser_context,
                   state_ptr);
 }
 
 void SignRSAPKCS1Digest(const std::string& token_id,
                         const std::string& data,
                         const std::string& public_key,
                         HashAlgorithm hash_algorithm,
                         const SignCallback& callback,
                         content::BrowserContext* browser_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<SignRSAState> state(
       new SignRSAState(data, public_key, false /* digest before signing */,
                        hash_algorithm, callback));
   // Get the pointer to |state| before base::Passed releases |state|.
   NSSOperationState* state_ptr = state.get();
 
   // The NSSCertDatabase object is not required. But in case it's not available
   // we would get more informative error messages and we can double check that
   // we use a key of the correct token.
   GetCertDatabase(token_id, base::Bind(&SignRSAWithDB, base::Passed(&state)),
                   browser_context, state_ptr);
 }
 
 void SignRSAPKCS1Raw(const std::string& token_id,
                      const std::string& data,
                      const std::string& public_key,
                      const SignCallback& callback,
                      content::BrowserContext* browser_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<SignRSAState> state(new SignRSAState(
       data, public_key, true /* sign directly without hashing */,
       HASH_ALGORITHM_NONE, callback));
   // Get the pointer to |state| before base::Passed releases |state|.
   NSSOperationState* state_ptr = state.get();
 
   // The NSSCertDatabase object is not required. But in case it's not available
   // we would get more informative error messages and we can double check that
   // we use a key of the correct token.
   GetCertDatabase(token_id, base::Bind(&SignRSAWithDB, base::Passed(&state)),
                   browser_context, state_ptr);
 }
 
 void SelectClientCertificates(const ClientCertificateRequest& request,
                               const SelectCertificatesCallback& callback,
                               content::BrowserContext* browser_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   scoped_refptr<net::SSLCertRequestInfo> cert_request_info(
       new net::SSLCertRequestInfo);
   cert_request_info->cert_key_types = request.certificate_key_types;
   cert_request_info->cert_authorities = request.certificate_authorities;
 
   const user_manager::User* user =
       chromeos::ProfileHelper::Get()->GetUserByProfile(
           Profile::FromBrowserContext(browser_context));
 
@@ skipping 51 matching lines @@
   }
 
   *key_type = key_type_tmp;
   *key_size_bits = key_size_bits_tmp;
   return true;
 }
 
 void GetCertificates(const std::string& token_id,
                      const GetCertificatesCallback& callback,
                      BrowserContext* browser_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<GetCertificatesState> state(new GetCertificatesState(callback));
   // Get the pointer to |state| before base::Passed releases |state|.
   NSSOperationState* state_ptr = state.get();
   GetCertDatabase(token_id,
                   base::Bind(&GetCertificatesWithDB, base::Passed(&state)),
                   browser_context,
                   state_ptr);
 }
 
 void ImportCertificate(const std::string& token_id,
                        const scoped_refptr<net::X509Certificate>& certificate,
                        const ImportCertificateCallback& callback,
                        BrowserContext* browser_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<ImportCertificateState> state(
       new ImportCertificateState(certificate, callback));
   // Get the pointer to |state| before base::Passed releases |state|.
   NSSOperationState* state_ptr = state.get();
 
   // The NSSCertDatabase object is not required. But in case it's not available
   // we would get more informative error messages and we can double check that
   // we use a key of the correct token.
   GetCertDatabase(token_id,
                   base::Bind(&ImportCertificateWithDB, base::Passed(&state)),
                   browser_context,
                   state_ptr);
 }
 
 void RemoveCertificate(const std::string& token_id,
                        const scoped_refptr<net::X509Certificate>& certificate,
                        const RemoveCertificateCallback& callback,
                        BrowserContext* browser_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<RemoveCertificateState> state(
       new RemoveCertificateState(certificate, callback));
   // Get the pointer to |state| before base::Passed releases |state|.
   NSSOperationState* state_ptr = state.get();
 
   // The NSSCertDatabase object is not required. But in case it's not available
   // we would get more informative error messages.
   GetCertDatabase(token_id,
                   base::Bind(&RemoveCertificateWithDB, base::Passed(&state)),
                   browser_context,
                   state_ptr);
 }
 
 void GetTokens(const GetTokensCallback& callback,
                content::BrowserContext* browser_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<GetTokensState> state(new GetTokensState(callback));
   // Get the pointer to |state| before base::Passed releases |state|.
   NSSOperationState* state_ptr = state.get();
   GetCertDatabase(std::string() /* don't get any specific slot */,
                   base::Bind(&GetTokensWithDB, base::Passed(&state)),
                   browser_context,
                   state_ptr);
 }
 
 }  // namespace platform_keys
 
 }  // namespace chromeos