[chrome/browser/net] favor DCHECK_CURRENTLY_ON for better logs

chrome/browser/net/crl_set_fetcher.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/net/crl_set_fetcher.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/rand_util.h"
@@ skipping 18 matching lines @@
 void CRLSetFetcher::SetCRLSetFilePath(const base::FilePath& path) {
   crl_path_ = path.Append(chrome::kCRLSetFilename);
 }
 
 base::FilePath CRLSetFetcher::GetCRLSetFilePath() const {
   return crl_path_;
 }
 
 void CRLSetFetcher::StartInitialLoad(ComponentUpdateService* cus,
                                      const base::FilePath& path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (path.empty())
     return;
   SetCRLSetFilePath(path);
   cus_ = cus;
 
   if (!BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           base::Bind(&CRLSetFetcher::DoInitialLoadFromDisk, this))) {
     NOTREACHED();
   }
 }
 
 void CRLSetFetcher::DeleteFromDisk(const base::FilePath& path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (path.empty())
     return;
   SetCRLSetFilePath(path);
   if (!BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           base::Bind(&CRLSetFetcher::DoDeleteFromDisk, this))) {
     NOTREACHED();
   }
 }
 
 void CRLSetFetcher::DoInitialLoadFromDisk() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   LoadFromDisk(GetCRLSetFilePath(), &crl_set_);
 
   uint32 sequence_of_loaded_crl = 0;
   if (crl_set_.get())
     sequence_of_loaded_crl = crl_set_->sequence();
 
   // Get updates, advertising the sequence number of the CRL set that we just
   // loaded, if any.
   if (!BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(
               &CRLSetFetcher::RegisterComponent,
               this,
               sequence_of_loaded_crl))) {
     NOTREACHED();
   }
 }
 
 void CRLSetFetcher::LoadFromDisk(base::FilePath path,
                                  scoped_refptr<net::CRLSet>* out_crl_set) {
   TRACE_EVENT0("CRLSetFetcher", "LoadFromDisk");
 
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   std::string crl_set_bytes;
   {
     TRACE_EVENT0("CRLSetFetcher", "ReadFileToString");
     if (!base::ReadFileToString(path, &crl_set_bytes))
       return;
   }
 
   if (!net::CRLSetStorage::Parse(crl_set_bytes, out_crl_set)) {
     LOG(WARNING) << "Failed to parse CRL set from " << path.MaybeAsASCII();
     return;
   }
 
   VLOG(1) << "Loaded " << crl_set_bytes.size() << " bytes of CRL set from disk";
 
   if (!BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(
               &CRLSetFetcher::SetCRLSetIfNewer, this, *out_crl_set))) {
     NOTREACHED();
   }
 }
 
 void CRLSetFetcher::SetCRLSetIfNewer(
     scoped_refptr<net::CRLSet> crl_set) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   scoped_refptr<net::CRLSet> old_crl_set(net::SSLConfigService::GetCRLSet());
   if (old_crl_set.get() && old_crl_set->sequence() > crl_set->sequence()) {
     LOG(WARNING) << "Refusing to downgrade CRL set from #"
                  << old_crl_set->sequence()
                  << "to #"
                  << crl_set->sequence();
   } else {
     net::SSLConfigService::SetCRLSet(crl_set);
     VLOG(1) << "Installed CRL set #" << crl_set->sequence();
   }
 }
 
 // kPublicKeySHA256 is the SHA256 hash of the SubjectPublicKeyInfo of the key
 // that's used to sign generated CRL sets.
 static const uint8 kPublicKeySHA256[32] = {
   0x75, 0xda, 0xf8, 0xcb, 0x77, 0x68, 0x40, 0x33,
   0x65, 0x4c, 0x97, 0xe5, 0xc5, 0x1b, 0xcd, 0x81,
   0x7b, 0x1e, 0xeb, 0x11, 0x2c, 0xe1, 0xa4, 0x33,
   0x8c, 0xf5, 0x72, 0x5e, 0xed, 0xb8, 0x43, 0x97,
 };
 
 void CRLSetFetcher::RegisterComponent(uint32 sequence_of_loaded_crl) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   update_client::CrxComponent component;
   component.pk_hash.assign(kPublicKeySHA256,
                            kPublicKeySHA256 + sizeof(kPublicKeySHA256));
   component.installer = this;
   component.name = "CRLSet";
   component.version = Version(base::UintToString(sequence_of_loaded_crl));
   component.allow_background_download = false;
   if (!component.version.IsValid()) {
     NOTREACHED();
     component.version = Version("0");
   }
 
   if (cus_->RegisterComponent(component) !=
       ComponentUpdateService::Status::kOk) {
     NOTREACHED() << "RegisterComponent returned error";
   }
 }
 
 void CRLSetFetcher::DoDeleteFromDisk() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   DeleteFile(GetCRLSetFilePath(), false /* not recursive */);
 }
 
 void CRLSetFetcher::OnUpdateError(int error) {
   LOG(WARNING) << "CRLSetFetcher got error " << error
                << " from component installer";
 }
 
 bool CRLSetFetcher::Install(const base::DictionaryValue& manifest,
@@ skipping 67 matching lines @@
 bool CRLSetFetcher::GetInstalledFile(
     const std::string& file, base::FilePath* installed_file) {
   return false;
 }
 
 bool CRLSetFetcher::Uninstall() {
   return false;
 }
 
 CRLSetFetcher::~CRLSetFetcher() {}