favor DCHECK_CURRENTLY_ON for better logs in chrome/browser/devtools

chrome/browser/devtools/devtools_file_system_indexer.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/devtools/devtools_file_system_indexer.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 119 matching lines @@
 
 Index::Index() : last_file_id_(0) {
   index_.resize(kTrigramCount);
   is_normalized_.resize(kTrigramCount);
   std::fill(is_normalized_.begin(), is_normalized_.end(), true);
 }
 
 Index::~Index() {}
 
 Time Index::LastModifiedTimeForFile(const FilePath& file_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   Time last_modified_time;
   if (index_times_.find(file_path) != index_times_.end())
     last_modified_time = index_times_[file_path];
   return last_modified_time;
 }
 
 void Index::SetTrigramsForFile(const FilePath& file_path,
                                const vector<Trigram>& index,
                                const Time& time) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   FileId file_id = GetFileId(file_path);
   vector<Trigram>::const_iterator it = index.begin();
   for (; it != index.end(); ++it) {
     Trigram trigram = *it;
     index_[trigram].push_back(file_id);
     is_normalized_[trigram] = false;
   }
   index_times_[file_path] = time;
 }
 
 vector<FilePath> Index::Search(string query) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   const char* data = query.c_str();
   vector<TrigramChar> trigram_chars;
   trigram_chars.reserve(query.size());
   for (size_t i = 0; i < query.size(); ++i) {
       TrigramChar trigram_char = TrigramCharForChar(data[i]);
       if (trigram_char == kBinaryTrigramChar)
         trigram_char = kUndefinedTrigramChar;
       trigram_chars.push_back(trigram_char);
   }
   vector<Trigram> trigrams;
@@ skipping 23 matching lines @@
   for (; ids_it != file_ids_.end(); ++ids_it) {
     if (trigrams.size() == 0 ||
         file_ids.find(ids_it->second) != file_ids.end()) {
       result.push_back(ids_it->first);
     }
   }
   return result;
 }
 
 FileId Index::GetFileId(const FilePath& file_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   string file_path_str = file_path.AsUTF8Unsafe();
   if (file_ids_.find(file_path) != file_ids_.end())
     return file_ids_[file_path];
   file_ids_[file_path] = ++last_file_id_;
   return last_file_id_;
 }
 
 void Index::NormalizeVectors() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   for (size_t i = 0; i < kTrigramCount; ++i) {
     if (!is_normalized_[i]) {
       std::sort(index_[i].begin(), index_[i].end());
       if (index_[i].capacity() > index_[i].size())
         vector<FileId>(index_[i]).swap(index_[i]);
       is_normalized_[i] = true;
     }
   }
 }
 
 void Index::PrintStats() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   LOG(ERROR) << "Index stats:";
   size_t size = 0;
   size_t maxSize = 0;
   size_t capacity = 0;
   for (size_t i = 0; i < kTrigramCount; ++i) {
     if (index_[i].size() > maxSize)
       maxSize = index_[i].size();
     size += index_[i].size();
     capacity += index_[i].capacity();
   }
@@ skipping 22 matching lines @@
                         BrowserThread::FILE).get()),
       files_indexed_(0),
       stopped_(false) {
   current_trigrams_set_.resize(kTrigramCount);
   current_trigrams_.reserve(kTrigramCount);
 }
 
 DevToolsFileSystemIndexer::FileSystemIndexingJob::~FileSystemIndexingJob() {}
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::Start() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       Bind(&FileSystemIndexingJob::CollectFilesToIndex, this));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::Stop() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(BrowserThread::FILE,
                           FROM_HERE,
                           Bind(&FileSystemIndexingJob::StopOnFileThread, this));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::StopOnFileThread() {
   stopped_ = true;
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::CollectFilesToIndex() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (stopped_)
     return;
   if (!file_enumerator_) {
     file_enumerator_.reset(
         new FileEnumerator(file_system_path_, true, FileEnumerator::FILES));
   }
   FilePath file_path = file_enumerator_->Next();
   if (file_path.empty()) {
     BrowserThread::PostTask(
         BrowserThread::UI,
@@ skipping 10 matching lines @@
   if (current_last_modified_time > saved_last_modified_time) {
     file_path_times_[file_path] = current_last_modified_time;
   }
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       Bind(&FileSystemIndexingJob::CollectFilesToIndex, this));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::IndexFiles() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (stopped_)
     return;
   if (indexing_it_ == file_path_times_.end()) {
     g_trigram_index.Get().NormalizeVectors();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done_callback_);
     return;
   }
   FilePath file_path = indexing_it_->first;
   current_file_.CreateOrOpen(
         file_path,
@@ skipping 55 matching lines @@
       current_trigrams_set_[trigram] = true;
       current_trigrams_.push_back(trigram);
     }
   }
   current_file_offset_ += bytes_read - 2;
   ReadFromFile();
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::FinishFileIndexing(
     bool success) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   CloseFile();
   if (success) {
     FilePath file_path = indexing_it_->first;
     g_trigram_index.Get().SetTrigramsForFile(
         file_path, current_trigrams_, file_path_times_[file_path]);
   }
   ReportWorked();
   ++indexing_it_;
   IndexFiles();
 }
@@ skipping 27 matching lines @@
 }
 
 DevToolsFileSystemIndexer::~DevToolsFileSystemIndexer() {}
 
 scoped_refptr<DevToolsFileSystemIndexer::FileSystemIndexingJob>
 DevToolsFileSystemIndexer::IndexPath(
     const string& file_system_path,
     const TotalWorkCallback& total_work_callback,
     const WorkedCallback& worked_callback,
     const DoneCallback& done_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_refptr<FileSystemIndexingJob> indexing_job =
       new FileSystemIndexingJob(FilePath::FromUTF8Unsafe(file_system_path),
                                 total_work_callback,
                                 worked_callback,
                                 done_callback);
   indexing_job->Start();
   return indexing_job;
 }
 
 void DevToolsFileSystemIndexer::SearchInPath(const string& file_system_path,
                                              const string& query,
                                              const SearchCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       Bind(&DevToolsFileSystemIndexer::SearchInPathOnFileThread,
            this,
            file_system_path,
            query,
            callback));
 }
 
 void DevToolsFileSystemIndexer::SearchInPathOnFileThread(
     const string& file_system_path,
     const string& query,
     const SearchCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   vector<FilePath> file_paths = g_trigram_index.Get().Search(query);
   vector<string> result;
   FilePath path = FilePath::FromUTF8Unsafe(file_system_path);
   vector<FilePath>::const_iterator it = file_paths.begin();
   for (; it != file_paths.end(); ++it) {
     if (path.IsParent(*it))
       result.push_back(it->AsUTF8Unsafe());
   }
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, Bind(callback, result));
 }