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

chrome/browser/chromeos/drive/sync_client.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/chromeos/drive/sync_client.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 147 matching lines @@
           temporary_file_directory)),
       entry_update_performer_(new EntryUpdatePerformer(blocking_task_runner,
                                                        delegate,
                                                        scheduler,
                                                        metadata,
                                                        cache,
                                                        loader_controller)),
       delay_(base::TimeDelta::FromSeconds(kDelaySeconds)),
       long_delay_(base::TimeDelta::FromSeconds(kLongDelaySeconds)),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 SyncClient::~SyncClient() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 void SyncClient::StartProcessingBacklog() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::vector<std::string>* to_fetch = new std::vector<std::string>;
   std::vector<std::string>* to_update = new std::vector<std::string>;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&CollectBacklog, metadata_, to_fetch, to_update),
       base::Bind(&SyncClient::OnGetLocalIdsOfBacklog,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(to_fetch),
                  base::Owned(to_update)));
 }
 
 void SyncClient::StartCheckingExistingPinnedFiles() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::vector<std::string>* local_ids = new std::vector<std::string>;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&CheckExistingPinnedFiles,
                  metadata_,
                  cache_,
                  local_ids),
       base::Bind(&SyncClient::AddFetchTasks,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(local_ids)));
 }
 
 void SyncClient::AddFetchTask(const std::string& local_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   AddFetchTaskInternal(local_id, delay_);
 }
 
 void SyncClient::RemoveFetchTask(const std::string& local_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   SyncTasks::iterator it = tasks_.find(SyncTasks::key_type(FETCH, local_id));
   if (it == tasks_.end())
     return;
 
   SyncTask* task = &it->second;
   switch (task->state) {
     case SUSPENDED:
     case PENDING:
       OnTaskComplete(FETCH, local_id, FILE_ERROR_ABORT);
       break;
     case RUNNING:
       if (!task->cancel_closure.is_null())
         task->cancel_closure.Run();
       break;
   }
 }
 
 void SyncClient::AddUpdateTask(const ClientContext& context,
                                const std::string& local_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   AddUpdateTaskInternal(context, local_id, delay_);
 }
 
 bool SyncClient:: WaitForUpdateTaskToComplete(
     const std::string& local_id,
     const FileOperationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   SyncTasks::iterator it = tasks_.find(SyncTasks::key_type(UPDATE, local_id));
   if (it == tasks_.end())
     return false;
 
   SyncTask* task = &it->second;
   task->waiting_callbacks.push_back(callback);
   return true;
 }
 
 base::Closure SyncClient::PerformFetchTask(const std::string& local_id,
                                            const ClientContext& context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return download_operation_->EnsureFileDownloadedByLocalId(
       local_id,
       context,
       GetFileContentInitializedCallback(),
       google_apis::GetContentCallback(),
       base::Bind(&SyncClient::OnFetchFileComplete,
                  weak_ptr_factory_.GetWeakPtr(),
                  local_id));
 }
 
 void SyncClient::AddFetchTaskInternal(const std::string& local_id,
                                       const base::TimeDelta& delay) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   SyncTask task;
   task.state = PENDING;
   task.context = ClientContext(BACKGROUND);
   task.task = base::Bind(&SyncClient::PerformFetchTask,
                          base::Unretained(this),
                          local_id);
   AddTask(SyncTasks::key_type(FETCH, local_id), task, delay);
 }
 
 base::Closure SyncClient::PerformUpdateTask(const std::string& local_id,
                                             const ClientContext& context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   entry_update_performer_->UpdateEntry(
       local_id,
       context,
       base::Bind(&SyncClient::OnTaskComplete,
                  weak_ptr_factory_.GetWeakPtr(),
                  UPDATE,
                  local_id));
   return base::Closure();
 }
 
 void SyncClient::AddUpdateTaskInternal(const ClientContext& context,
                                        const std::string& local_id,
                                        const base::TimeDelta& delay) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   SyncTask task;
   task.state = PENDING;
   task.context = context;
   task.task = base::Bind(&SyncClient::PerformUpdateTask,
                          base::Unretained(this),
                          local_id);
   AddTask(SyncTasks::key_type(UPDATE, local_id), task, delay);
 }
 
 void SyncClient::AddTask(const SyncTasks::key_type& key,
                          const SyncTask& task,
                          const base::TimeDelta& delay) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   SyncTasks::iterator it = tasks_.find(key);
   if (it != tasks_.end()) {
     switch (it->second.state) {
       case SUSPENDED:
         // Activate the task.
         it->second.state = PENDING;
         break;
       case PENDING:
         // The same task will run, do nothing.
@@ skipping 68 matching lines @@
   }
 
   // Run the task.
   task->state = RUNNING;
   task->cancel_closure = task->task.Run(task->context);
 }
 
 void SyncClient::OnGetLocalIdsOfBacklog(
     const std::vector<std::string>* to_fetch,
     const std::vector<std::string>* to_update) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Give priority to upload tasks over fetch tasks, so that dirty files are
   // uploaded as soon as possible.
   for (size_t i = 0; i < to_update->size(); ++i) {
     const std::string& local_id = (*to_update)[i];
     DVLOG(1) << "Queuing to update: " << local_id;
     AddUpdateTask(ClientContext(BACKGROUND), local_id);
   }
 
   for (size_t i = 0; i < to_fetch->size(); ++i) {
     const std::string& local_id = (*to_fetch)[i];
     DVLOG(1) << "Queuing to fetch: " << local_id;
     AddFetchTaskInternal(local_id, delay_);
   }
 }
 
 void SyncClient::AddFetchTasks(const std::vector<std::string>* local_ids) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   for (size_t i = 0; i < local_ids->size(); ++i)
     AddFetchTask((*local_ids)[i]);
 }
 
 void SyncClient::OnTaskComplete(SyncType type,
                                 const std::string& local_id,
                                 FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   const SyncTasks::key_type key(type, local_id);
   SyncTasks::iterator it = tasks_.find(key);
   DCHECK(it != tasks_.end());
 
   base::TimeDelta retry_delay = base::TimeDelta::FromSeconds(0);
 
   switch (error) {
     case FILE_ERROR_OK:
       DVLOG(1) << "Completed: type = " << type << ", id = " << local_id;
@@ skipping 39 matching lines @@
     for (size_t i = 0; i < it->second.dependent_tasks.size(); ++i)
       StartTask(it->second.dependent_tasks[i]);
     tasks_.erase(it);
   }
 }
 
 void SyncClient::OnFetchFileComplete(const std::string& local_id,
                                      FileError error,
                                      const base::FilePath& local_path,
                                      scoped_ptr<ResourceEntry> entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   OnTaskComplete(FETCH, local_id, error);
   if (error == FILE_ERROR_ABORT) {
     // If user cancels download, unpin the file so that we do not sync the file
     // again.
     base::PostTaskAndReplyWithResult(
         blocking_task_runner_.get(),
         FROM_HERE,
         base::Bind(&FileCache::Unpin, base::Unretained(cache_), local_id),
         base::Bind(&util::EmptyFileOperationCallback));
   }
 }
 
 }  // namespace internal
 }  // namespace drive