[chrome/browser/se*-ss*] favor DCHECK_CURRENTLY_ON for better logs

chrome/browser/spellchecker/spellcheck_custom_dictionary.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/spellchecker/spellcheck_custom_dictionary.h"
 
 #include <functional>
 
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
@@ skipping 39 matching lines @@
   DETECTED_DUPLICATE_WORDS = 2,
 
   // The change contained words to be removed that are not in the dictionary.
   DETECTED_MISSING_WORDS = 4,
 };
 
 // Loads the file at |file_path| into the |words| container. If the file has a
 // valid checksum, then returns ChecksumStatus::VALID. If the file has an
 // invalid checksum, then returns ChecksumStatus::INVALID and clears |words|.
 ChecksumStatus LoadFile(const base::FilePath& file_path, WordList& words) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   words.clear();
   std::string contents;
   base::ReadFileToString(file_path, &contents);
   size_t pos = contents.rfind(CHECKSUM_PREFIX);
   if (pos != std::string::npos) {
     std::string checksum = contents.substr(pos + strlen(CHECKSUM_PREFIX));
     contents = contents.substr(0, pos);
     if (checksum != base::MD5String(contents))
       return INVALID_CHECKSUM;
   }
@@ skipping 12 matching lines @@
       base::TRIM_NONE != base::TrimWhitespaceASCII(word, base::TRIM_ALL, &tmp);
 }
 
 // Loads the custom spellcheck dictionary from |path| into |custom_words|. If
 // the dictionary checksum is not valid, but backup checksum is valid, then
 // restores the backup and loads that into |custom_words| instead. If the backup
 // is invalid too, then clears |custom_words|. Must be called on the file
 // thread.
 void LoadDictionaryFileReliably(WordList& custom_words,
                                 const base::FilePath& path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   // Load the contents and verify the checksum.
   if (LoadFile(path, custom_words) == VALID_CHECKSUM)
     return;
   // Checksum is not valid. See if there's a backup.
   base::FilePath backup = path.AddExtension(BACKUP_EXTENSION);
   if (!base::PathExists(backup))
     return;
   // Load the backup and verify its checksum.
   if (LoadFile(backup, custom_words) != VALID_CHECKSUM)
     return;
   // Backup checksum is valid. Restore the backup.
   base::CopyFile(backup, path);
 }
 
 // Backs up the original dictionary, saves |custom_words| and its checksum into
 // the custom spellcheck dictionary at |path|.
 void SaveDictionaryFileReliably(
     const WordList& custom_words,
     const base::FilePath& path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   std::stringstream content;
   for (WordList::const_iterator it = custom_words.begin();
        it != custom_words.end();
        ++it) {
     content << *it << '\n';
   }
   std::string checksum = base::MD5String(content.str());
   content << CHECKSUM_PREFIX << checksum;
   base::CopyFile(path, path.AddExtension(BACKUP_EXTENSION));
   base::ImportantFileWriter::WriteFileAtomically(path, content.str());
@@ skipping 97 matching lines @@
       is_loaded_(false),
       weak_ptr_factory_(this) {
   custom_dictionary_path_ =
       path.Append(chrome::kCustomDictionaryFileName);
 }
 
 SpellcheckCustomDictionary::~SpellcheckCustomDictionary() {
 }
 
 const WordSet& SpellcheckCustomDictionary::GetWords() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return words_;
 }
 
 bool SpellcheckCustomDictionary::AddWord(const std::string& word) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   Change dictionary_change;
   dictionary_change.AddWord(word);
   int result = dictionary_change.Sanitize(GetWords());
   Apply(dictionary_change);
   Notify(dictionary_change);
   Sync(dictionary_change);
   Save(dictionary_change);
   return result == VALID_CHANGE;
 }
 
 bool SpellcheckCustomDictionary::RemoveWord(const std::string& word) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   Change dictionary_change;
   dictionary_change.RemoveWord(word);
   int result = dictionary_change.Sanitize(GetWords());
   Apply(dictionary_change);
   Notify(dictionary_change);
   Sync(dictionary_change);
   Save(dictionary_change);
   return result == VALID_CHANGE;
 }
 
 bool SpellcheckCustomDictionary::HasWord(const std::string& word) const {
   return !!words_.count(word);
 }
 
 void SpellcheckCustomDictionary::AddObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.AddObserver(observer);
 }
 
 void SpellcheckCustomDictionary::RemoveObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.RemoveObserver(observer);
 }
 
 bool SpellcheckCustomDictionary::IsLoaded() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return is_loaded_;
 }
 
 bool SpellcheckCustomDictionary::IsSyncing() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return !!sync_processor_.get();
 }
 
 void SpellcheckCustomDictionary::Load() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&SpellcheckCustomDictionary::LoadDictionaryFile,
                  custom_dictionary_path_),
       base::Bind(&SpellcheckCustomDictionary::OnLoaded,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 syncer::SyncMergeResult SpellcheckCustomDictionary::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> sync_error_handler) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!sync_processor_.get());
   DCHECK(!sync_error_handler_.get());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_handler.get());
   DCHECK_EQ(syncer::DICTIONARY, type);
   sync_processor_ = sync_processor.Pass();
   sync_error_handler_ = sync_error_handler.Pass();
 
   // Build a list of words to add locally.
   WordList to_add_locally;
@@ skipping 17 matching lines @@
                                                               to_add_locally);
 
   // Send local changes to the sync server.
   Change to_change_remotely(to_add_remotely);
   syncer::SyncMergeResult result(type);
   result.set_error(Sync(to_change_remotely));
   return result;
 }
 
 void SpellcheckCustomDictionary::StopSyncing(syncer::ModelType type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(syncer::DICTIONARY, type);
   sync_processor_.reset();
   sync_error_handler_.reset();
 }
 
 syncer::SyncDataList SpellcheckCustomDictionary::GetAllSyncData(
     syncer::ModelType type) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(syncer::DICTIONARY, type);
   syncer::SyncDataList data;
   std::string word;
   size_t i = 0;
   for (WordSet::const_iterator it = words_.begin();
        it != words_.end() &&
            i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
        ++it, ++i) {
     word = *it;
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_dictionary()->set_word(word);
     data.push_back(syncer::SyncData::CreateLocalData(word, word, specifics));
   }
   return data;
 }
 
 syncer::SyncError SpellcheckCustomDictionary::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   Change dictionary_change;
   for (syncer::SyncChangeList::const_iterator it = change_list.begin();
        it != change_list.end();
        ++it) {
     DCHECK(it->IsValid());
     std::string word = it->sync_data().GetSpecifics().dictionary().word();
     switch (it->change_type()) {
       case syncer::SyncChange::ACTION_ADD:
         dictionary_change.AddWord(word);
         break;
@@ skipping 12 matching lines @@
   Apply(dictionary_change);
   Notify(dictionary_change);
   Save(dictionary_change);
 
   return syncer::SyncError();
 }
 
 // static
 WordList SpellcheckCustomDictionary::LoadDictionaryFile(
     const base::FilePath& path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   WordList words;
   LoadDictionaryFileReliably(words, path);
   if (!words.empty() && VALID_CHANGE != SanitizeWordsToAdd(WordSet(), words))
     SaveDictionaryFileReliably(words, path);
   SpellCheckHostMetrics::RecordCustomWordCountStats(words.size());
   return words;
 }
 
 // static
 void SpellcheckCustomDictionary::UpdateDictionaryFile(
     const SpellcheckCustomDictionary::Change& dictionary_change,
     const base::FilePath& path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (dictionary_change.empty())
     return;
 
   WordList custom_words;
   LoadDictionaryFileReliably(custom_words, path);
 
   // Add words.
   custom_words.insert(custom_words.end(),
                       dictionary_change.to_add().begin(),
                       dictionary_change.to_add().end());
 
   // Remove words.
   std::sort(custom_words.begin(), custom_words.end());
   WordList remaining =
       base::STLSetDifference<WordList>(custom_words,
                                        dictionary_change.to_remove());
   std::swap(custom_words, remaining);
 
   SaveDictionaryFileReliably(custom_words, path);
 }
 
 void SpellcheckCustomDictionary::OnLoaded(WordList custom_words) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   Change dictionary_change(custom_words);
   dictionary_change.Sanitize(GetWords());
   Apply(dictionary_change);
   Sync(dictionary_change);
   is_loaded_ = true;
   FOR_EACH_OBSERVER(Observer, observers_, OnCustomDictionaryLoaded());
 }
 
 void SpellcheckCustomDictionary::Apply(
     const SpellcheckCustomDictionary::Change& dictionary_change) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!dictionary_change.to_add().empty()) {
     words_.insert(dictionary_change.to_add().begin(),
                   dictionary_change.to_add().end());
   }
   if (!dictionary_change.to_remove().empty()) {
     WordSet updated_words =
         base::STLSetDifference<WordSet>(words_,
                                         dictionary_change.to_remove());
     std::swap(words_, updated_words);
   }
 }
 
 void SpellcheckCustomDictionary::Save(
     const SpellcheckCustomDictionary::Change& dictionary_change) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&SpellcheckCustomDictionary::UpdateDictionaryFile,
                  dictionary_change,
                  custom_dictionary_path_));
 }
 
 syncer::SyncError SpellcheckCustomDictionary::Sync(
     const SpellcheckCustomDictionary::Change& dictionary_change) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   syncer::SyncError error;
   if (!IsSyncing() || dictionary_change.empty())
     return error;
 
   // The number of words on the sync server should not exceed the limits.
   int server_size = static_cast<int>(words_.size()) -
       static_cast<int>(dictionary_change.to_add().size());
   int max_upload_size = std::max(
       0,
       static_cast<int>(
@@ skipping 38 matching lines @@
   // Turn off syncing of this dictionary if the server already has the maximum
   // number of words.
   if (words_.size() > chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS)
     StopSyncing(syncer::DICTIONARY);
 
   return error;
 }
 
 void SpellcheckCustomDictionary::Notify(
     const SpellcheckCustomDictionary::Change& dictionary_change) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!IsLoaded() || dictionary_change.empty())
     return;
   FOR_EACH_OBSERVER(Observer,
                     observers_,
                     OnCustomDictionaryChanged(dictionary_change));
 }