favor DCHECK_CURRENTLY_ON for better logs in components/ (part 2)

components/nacl/browser/nacl_browser.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 "components/nacl/browser/nacl_browser.h"
 
 #include "base/command_line.h"
 #include "base/files/file_proxy.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 150 matching lines @@
 }
 
 NaClBrowserDelegate* NaClBrowser::GetDelegate() {
   // The delegate is not owned by the IO thread.  This accessor method can be
   // called from other threads.
   DCHECK(GetInstance()->browser_delegate_.get() != NULL);
   return GetInstance()->browser_delegate_.get();
 }
 
 void NaClBrowser::EarlyStartup() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   InitIrtFilePath();
   InitValidationCacheFilePath();
 }
 
 NaClBrowser::~NaClBrowser() {
 }
 
 void NaClBrowser::InitIrtFilePath() {
   // Allow the IRT library to be overridden via an environment
   // variable.  This allows the NaCl/Chromium integration bot to
@@ skipping 36 matching lines @@
   return (IsOk() &&
           irt_state_ == NaClResourceReady &&
           validation_cache_state_ == NaClResourceReady);
 }
 
 bool NaClBrowser::IsOk() const {
   return ok_;
 }
 
 const base::File& NaClBrowser::IrtFile() const {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   CHECK_EQ(irt_state_, NaClResourceReady);
   CHECK(irt_file_.IsValid());
   return irt_file_;
 }
 
 void NaClBrowser::EnsureAllResourcesAvailable() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   EnsureIrtAvailable();
   EnsureValidationCacheAvailable();
 }
 
 // Load the IRT async.
 void NaClBrowser::EnsureIrtAvailable() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (IsOk() && irt_state_ == NaClResourceUninitialized) {
     irt_state_ = NaClResourceRequested;
     // TODO(ncbray) use blocking pool.
     scoped_ptr<base::FileProxy> file_proxy(new base::FileProxy(
         content::BrowserThread::GetMessageLoopProxyForThread(
                 content::BrowserThread::FILE).get()));
     base::FileProxy* proxy = file_proxy.get();
     if (!proxy->CreateOrOpen(irt_filepath_,
                              base::File::FLAG_OPEN | base::File::FLAG_READ,
                              base::Bind(&NaClBrowser::OnIrtOpened,
                                         weak_factory_.GetWeakPtr(),
                                         Passed(&file_proxy)))) {
       LOG(ERROR) << "Internal error, NaCl disabled.";
       MarkAsFailed();
     }
   }
 }
 
 void NaClBrowser::OnIrtOpened(scoped_ptr<base::FileProxy> file_proxy,
                               base::File::Error error_code) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK_EQ(irt_state_, NaClResourceRequested);
   if (file_proxy->IsValid()) {
     irt_file_ = file_proxy->TakeFile();
   } else {
     LOG(ERROR) << "Failed to open NaCl IRT file \""
                << irt_filepath_.LossyDisplayName()
                << "\": " << error_code;
     MarkAsFailed();
   }
   irt_state_ = NaClResourceReady;
@@ skipping 41 matching lines @@
   // The cache directory may or may not be the user data directory.
   base::FilePath cache_file_path;
   browser_delegate_->GetCacheDirectory(&cache_file_path);
   // Append the base file name to the cache directory.
 
   validation_cache_file_path_ =
       cache_file_path.Append(kValidationCacheFileName);
 }
 
 void NaClBrowser::EnsureValidationCacheAvailable() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (IsOk() && validation_cache_state_ == NaClResourceUninitialized) {
     if (ValidationCacheIsEnabled()) {
       validation_cache_state_ = NaClResourceRequested;
 
       // Structure for carrying data between the callbacks.
       std::string* data = new std::string();
       // We can get away not giving this a sequence ID because this is the first
       // task and further file access will not occur until after we get a
       // response.
       if (!content::BrowserThread::PostBlockingPoolTaskAndReply(
               FROM_HERE,
               base::Bind(ReadCache, validation_cache_file_path_, data),
               base::Bind(&NaClBrowser::OnValidationCacheLoaded,
                          weak_factory_.GetWeakPtr(),
                          base::Owned(data)))) {
         RunWithoutValidationCache();
       }
     } else {
       RunWithoutValidationCache();
     }
   }
 }
 
 void NaClBrowser::OnValidationCacheLoaded(const std::string *data) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   // Did the cache get cleared before the load completed?  If so, ignore the
   // incoming data.
   if (validation_cache_state_ == NaClResourceReady)
     return;
 
   if (data->size() == 0) {
     // No file found.
     validation_cache_.Reset();
   } else {
     Pickle pickle(data->data(), data->size());
     validation_cache_.Deserialize(&pickle);
   }
   validation_cache_state_ = NaClResourceReady;
   CheckWaiting();
 }
 
 void NaClBrowser::RunWithoutValidationCache() {
   // Be paranoid.
   validation_cache_.Reset();
   validation_cache_is_enabled_ = false;
   validation_cache_state_ = NaClResourceReady;
   CheckWaiting();
 }
 
 void NaClBrowser::CheckWaiting() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (!IsOk() || IsReady()) {
     // Queue the waiting tasks into the message loop.  This helps avoid
     // re-entrancy problems that could occur if the closure was invoked
     // directly.  For example, this could result in use-after-free of the
     // process host.
     for (std::vector<base::Closure>::iterator iter = waiting_.begin();
          iter != waiting_.end(); ++iter) {
       base::MessageLoop::current()->PostTask(FROM_HERE, *iter);
     }
     waiting_.clear();
@@ skipping 10 matching lines @@
   EnsureAllResourcesAvailable();
   CheckWaiting();
 }
 
 const base::FilePath& NaClBrowser::GetIrtFilePath() {
   return irt_filepath_;
 }
 
 void NaClBrowser::PutFilePath(const base::FilePath& path, uint64* file_token_lo,
                               uint64* file_token_hi) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   while (true) {
     uint64 file_token[2] = {base::RandUint64(), base::RandUint64()};
     // A zero file_token indicates there is no file_token, if we get zero, ask
     // for another number.
     if (file_token[0] != 0 || file_token[1] != 0) {
       // If the file_token is in use, ask for another number.
       std::string key(reinterpret_cast<char*>(file_token), sizeof(file_token));
       PathCacheType::iterator iter = path_cache_.Peek(key);
       if (iter == path_cache_.end()) {
         path_cache_.Put(key, path);
         *file_token_lo = file_token[0];
         *file_token_hi = file_token[1];
         break;
       }
     }
   }
 }
 
 bool NaClBrowser::GetFilePath(uint64 file_token_lo, uint64 file_token_hi,
                               base::FilePath* path) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   uint64 file_token[2] = {file_token_lo, file_token_hi};
   std::string key(reinterpret_cast<char*>(file_token), sizeof(file_token));
   PathCacheType::iterator iter = path_cache_.Peek(key);
   if (iter == path_cache_.end()) {
     *path = base::FilePath(FILE_PATH_LITERAL(""));
     return false;
   }
   *path = iter->second;
   path_cache_.Erase(iter);
   return true;
 }
 
 
 bool NaClBrowser::QueryKnownToValidate(const std::string& signature,
                                        bool off_the_record) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (off_the_record) {
     // If we're off the record, don't reorder the main cache.
     return validation_cache_.QueryKnownToValidate(signature, false) ||
         off_the_record_validation_cache_.QueryKnownToValidate(signature, true);
   } else {
     bool result = validation_cache_.QueryKnownToValidate(signature, true);
     LogCacheQuery(result ? CACHE_HIT : CACHE_MISS);
     // Queries can modify the MRU order of the cache.
     MarkValidationCacheAsModified();
     return result;
   }
 }
 
 void NaClBrowser::SetKnownToValidate(const std::string& signature,
                                      bool off_the_record) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (off_the_record) {
     off_the_record_validation_cache_.SetKnownToValidate(signature);
   } else {
     validation_cache_.SetKnownToValidate(signature);
     // The number of sets should be equal to the number of cache misses, minus
     // validation failures and successful validations where stubout occurs.
     LogCacheSet(CACHE_HIT);
     MarkValidationCacheAsModified();
   }
 }
 
 void NaClBrowser::ClearValidationCache(const base::Closure& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   // Note: this method may be called before EnsureValidationCacheAvailable has
   // been invoked.  In other words, this method may be called before any NaCl
   // processes have been created.  This method must succeed and invoke the
   // callback in such a case.  If it does not invoke the callback, Chrome's UI
   // will hang in that case.
   validation_cache_.Reset();
   off_the_record_validation_cache_.Reset();
 
   if (validation_cache_file_path_.empty()) {
     // Can't figure out what file to remove, but don't drop the callback.
@@ skipping 31 matching lines @@
     base::MessageLoop::current()->PostDelayedTask(
          FROM_HERE,
          base::Bind(&NaClBrowser::PersistValidationCache,
                     weak_factory_.GetWeakPtr()),
          base::TimeDelta::FromMilliseconds(kValidationCacheCoalescingTimeMS));
     validation_cache_is_modified_ = true;
   }
 }
 
 void NaClBrowser::PersistValidationCache() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   // validation_cache_is_modified_ may be false if the cache was cleared while
   // this delayed task was pending.
   // validation_cache_file_path_ may be empty if something went wrong during
   // initialization.
   if (validation_cache_is_modified_ && !validation_cache_file_path_.empty()) {
     Pickle* pickle = new Pickle();
     validation_cache_.Serialize(pickle);
 
     // Pass the serialized data to another thread to write to disk.  File IO is
     // not allowed on the IO thread (which is the thread this method runs on)
     // because it can degrade the responsiveness of the browser.
     // The task is sequenced so that multiple writes happen in order.
     content::BrowserThread::PostBlockingPoolSequencedTask(
         kValidationCacheSequenceName,
         FROM_HERE,
         base::Bind(WriteCache, validation_cache_file_path_,
                    base::Owned(pickle)));
   }
   validation_cache_is_modified_ = false;
 }
 
 void NaClBrowser::OnProcessEnd(int process_id) {
   gdb_debug_stub_port_map_.erase(process_id);
 }
 
 void NaClBrowser::OnProcessCrashed() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (crash_times_.size() == kMaxCrashesPerInterval) {
     crash_times_.pop_front();
   }
   base::Time time = base::Time::Now();
   crash_times_.push_back(time);
 }
 
 bool NaClBrowser::IsThrottled() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (crash_times_.size() != kMaxCrashesPerInterval) {
     return false;
   }
   base::TimeDelta delta = base::Time::Now() - crash_times_.front();
   return delta.InSeconds() <= kCrashesIntervalInSeconds;
 }
 
 }  // namespace nacl