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

chrome/browser/chromeos/drive/job_scheduler.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/job_scheduler.h"
 
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
@@ skipping 153 matching lines @@
 // Metadata jobs are cheap, so we run them concurrently. File jobs run serially.
 const int JobScheduler::kMaxJobCount[] = {
   5,  // METADATA_QUEUE
   1,  // FILE_QUEUE
 };
 
 JobScheduler::JobEntry::JobEntry(JobType type)
     : job_info(type),
       context(ClientContext(USER_INITIATED)),
       retry_count(0) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 JobScheduler::JobEntry::~JobEntry() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 struct JobScheduler::ResumeUploadParams {
   base::FilePath drive_file_path;
   base::FilePath local_file_path;
   std::string content_type;
 };
 
 JobScheduler::JobScheduler(PrefService* pref_service,
                            EventLogger* logger,
                            DriveServiceInterface* drive_service,
                            base::SequencedTaskRunner* blocking_task_runner)
     : throttle_count_(0),
       wait_until_(base::Time::Now()),
       disable_throttling_(false),
       logger_(logger),
       drive_service_(drive_service),
       blocking_task_runner_(blocking_task_runner),
       uploader_(new DriveUploader(drive_service, blocking_task_runner)),
       pref_service_(pref_service),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   for (int i = 0; i < NUM_QUEUES; ++i)
     queue_[i].reset(new JobQueue(kMaxJobCount[i], NUM_CONTEXT_TYPES));
 
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
 }
 
 JobScheduler::~JobScheduler() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   size_t num_queued_jobs = 0;
   for (int i = 0; i < NUM_QUEUES; ++i)
     num_queued_jobs += queue_[i]->GetNumberOfJobs();
   DCHECK_EQ(num_queued_jobs, job_map_.size());
 
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
 std::vector<JobInfo> JobScheduler::GetJobInfoList() {
   std::vector<JobInfo> job_info_list;
   for (JobIDMap::iterator iter(&job_map_); !iter.IsAtEnd(); iter.Advance())
     job_info_list.push_back(iter.GetCurrentValue()->job_info);
   return job_info_list;
 }
 
 void JobScheduler::AddObserver(JobListObserver* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observer_list_.AddObserver(observer);
 }
 
 void JobScheduler::RemoveObserver(JobListObserver* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observer_list_.RemoveObserver(observer);
 }
 
 void JobScheduler::CancelJob(JobID job_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   JobEntry* job = job_map_.Lookup(job_id);
   if (job) {
     if (job->job_info.state == STATE_RUNNING) {
       // If the job is running an HTTP request, cancel it via |cancel_callback|
       // returned from the request, and wait for termination in the normal
       // callback handler, OnJobDone.
       if (!job->cancel_callback.is_null())
         job->cancel_callback.Run();
     } else {
       AbortNotRunningJob(job, google_apis::DRIVE_CANCELLED);
     }
   }
 }
 
 void JobScheduler::CancelAllJobs() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // CancelJob may remove the entry from |job_map_|. That's OK. IDMap supports
   // removable during iteration.
   for (JobIDMap::iterator iter(&job_map_); !iter.IsAtEnd(); iter.Advance())
     CancelJob(iter.GetCurrentKey());
 }
 
 void JobScheduler::GetAboutResource(
     const google_apis::AboutResourceCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_ABOUT_RESOURCE);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetAboutResource,
       base::Unretained(drive_service_),
       base::Bind(&JobScheduler::OnGetAboutResourceJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetAppList(const google_apis::AppListCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_APP_LIST);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetAppList,
       base::Unretained(drive_service_),
       base::Bind(&JobScheduler::OnGetAppListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetAllFileList(
     const google_apis::FileListCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_ALL_RESOURCE_LIST);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetAllFileList,
       base::Unretained(drive_service_),
       base::Bind(&JobScheduler::OnGetFileListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetFileListInDirectory(
     const std::string& directory_resource_id,
     const google_apis::FileListCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(
       TYPE_GET_RESOURCE_LIST_IN_DIRECTORY);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetFileListInDirectory,
       base::Unretained(drive_service_),
       directory_resource_id,
       base::Bind(&JobScheduler::OnGetFileListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::Search(const std::string& search_query,
                           const google_apis::FileListCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_SEARCH);
   new_job->task = base::Bind(
       &DriveServiceInterface::Search,
       base::Unretained(drive_service_),
       search_query,
       base::Bind(&JobScheduler::OnGetFileListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetChangeList(
     int64 start_changestamp,
     const google_apis::ChangeListCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_CHANGE_LIST);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetChangeList,
       base::Unretained(drive_service_),
       start_changestamp,
       base::Bind(&JobScheduler::OnGetChangeListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetRemainingChangeList(
     const GURL& next_link,
     const google_apis::ChangeListCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_REMAINING_CHANGE_LIST);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetRemainingChangeList,
       base::Unretained(drive_service_),
       next_link,
       base::Bind(&JobScheduler::OnGetChangeListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetRemainingFileList(
     const GURL& next_link,
     const google_apis::FileListCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_REMAINING_FILE_LIST);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetRemainingFileList,
       base::Unretained(drive_service_),
       next_link,
       base::Bind(&JobScheduler::OnGetFileListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetFileResource(
     const std::string& resource_id,
     const ClientContext& context,
     const google_apis::FileResourceCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_RESOURCE_ENTRY);
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::GetFileResource,
       base::Unretained(drive_service_),
       resource_id,
       base::Bind(&JobScheduler::OnGetFileResourceJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetShareUrl(
     const std::string& resource_id,
     const GURL& embed_origin,
     const ClientContext& context,
     const google_apis::GetShareUrlCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_SHARE_URL);
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::GetShareUrl,
       base::Unretained(drive_service_),
       resource_id,
       embed_origin,
       base::Bind(&JobScheduler::OnGetShareUrlJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::TrashResource(
     const std::string& resource_id,
     const ClientContext& context,
     const google_apis::EntryActionCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_TRASH_RESOURCE);
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::TrashResource,
       base::Unretained(drive_service_),
       resource_id,
       base::Bind(&JobScheduler::OnEntryActionJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = callback;
   StartJob(new_job);
 }
 
 void JobScheduler::CopyResource(
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& new_title,
     const base::Time& last_modified,
     const google_apis::FileResourceCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_COPY_RESOURCE);
   new_job->task = base::Bind(
       &DriveServiceInterface::CopyResource,
       base::Unretained(drive_service_),
       resource_id,
       parent_resource_id,
       new_title,
       last_modified,
       base::Bind(&JobScheduler::OnGetFileResourceJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::UpdateResource(
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& new_title,
     const base::Time& last_modified,
     const base::Time& last_viewed_by_me,
     const google_apis::drive::Properties& properties,
     const ClientContext& context,
     const google_apis::FileResourceCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_UPDATE_RESOURCE);
   new_job->context = context;
   new_job->task = base::Bind(&DriveServiceInterface::UpdateResource,
                              base::Unretained(drive_service_), resource_id,
                              parent_resource_id, new_title, last_modified,
                              last_viewed_by_me, properties,
                              base::Bind(&JobScheduler::OnGetFileResourceJobDone,
                                         weak_ptr_factory_.GetWeakPtr(),
                                         new_job->job_info.job_id, callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::AddResourceToDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const google_apis::EntryActionCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_ADD_RESOURCE_TO_DIRECTORY);
   new_job->task = base::Bind(
       &DriveServiceInterface::AddResourceToDirectory,
       base::Unretained(drive_service_),
       parent_resource_id,
       resource_id,
       base::Bind(&JobScheduler::OnEntryActionJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = callback;
   StartJob(new_job);
 }
 
 void JobScheduler::RemoveResourceFromDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const ClientContext& context,
     const google_apis::EntryActionCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   JobEntry* new_job = CreateNewJob(TYPE_REMOVE_RESOURCE_FROM_DIRECTORY);
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::RemoveResourceFromDirectory,
       base::Unretained(drive_service_),
       parent_resource_id,
       resource_id,
       base::Bind(&JobScheduler::OnEntryActionJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = callback;
   StartJob(new_job);
 }
 
 void JobScheduler::AddNewDirectory(
     const std::string& parent_resource_id,
     const std::string& directory_title,
     const DriveServiceInterface::AddNewDirectoryOptions& options,
     const ClientContext& context,
     const google_apis::FileResourceCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   JobEntry* new_job = CreateNewJob(TYPE_ADD_NEW_DIRECTORY);
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::AddNewDirectory,
       base::Unretained(drive_service_),
       parent_resource_id,
       directory_title,
       options,
       base::Bind(&JobScheduler::OnGetFileResourceJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 JobID JobScheduler::DownloadFile(
     const base::FilePath& virtual_path,
     int64 expected_file_size,
     const base::FilePath& local_cache_path,
     const std::string& resource_id,
     const ClientContext& context,
     const google_apis::DownloadActionCallback& download_action_callback,
     const google_apis::GetContentCallback& get_content_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Temporary histogram for crbug.com/229650.
   CollectCopyHistogramSample("Drive.DownloadFromDriveFileSize",
                              expected_file_size);
 
   JobEntry* new_job = CreateNewJob(TYPE_DOWNLOAD_FILE);
   new_job->job_info.file_path = virtual_path;
   new_job->job_info.num_total_bytes = expected_file_size;
   new_job->context = context;
   new_job->task = base::Bind(
@@ skipping 16 matching lines @@
 
 void JobScheduler::UploadNewFile(
     const std::string& parent_resource_id,
     const base::FilePath& drive_file_path,
     const base::FilePath& local_file_path,
     const std::string& title,
     const std::string& content_type,
     const DriveUploader::UploadNewFileOptions& options,
     const ClientContext& context,
     const google_apis::FileResourceCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   JobEntry* new_job = CreateNewJob(TYPE_UPLOAD_NEW_FILE);
   new_job->job_info.file_path = drive_file_path;
   new_job->context = context;
 
   GetFileSizeForJob(
       blocking_task_runner_, local_file_path,
       base::Bind(&JobScheduler::OnGotFileSizeForJob,
                  weak_ptr_factory_.GetWeakPtr(), new_job->job_info.job_id,
                  "Drive.UploadToDriveFileSize"));
@@ skipping 23 matching lines @@
 }
 
 void JobScheduler::UploadExistingFile(
     const std::string& resource_id,
     const base::FilePath& drive_file_path,
     const base::FilePath& local_file_path,
     const std::string& content_type,
     const DriveUploader::UploadExistingFileOptions& options,
     const ClientContext& context,
     const google_apis::FileResourceCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   JobEntry* new_job = CreateNewJob(TYPE_UPLOAD_EXISTING_FILE);
   new_job->job_info.file_path = drive_file_path;
   new_job->context = context;
 
   GetFileSizeForJob(
       blocking_task_runner_, local_file_path,
       base::Bind(&JobScheduler::OnGotFileSizeForJob,
                  weak_ptr_factory_.GetWeakPtr(), new_job->job_info.job_id,
                  "Drive.UploadToDriveFileSize"));
@@ skipping 19 matching lines @@
   new_job->task = base::Bind(&RunUploadExistingFile, uploader_.get(), params);
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::AddPermission(
     const std::string& resource_id,
     const std::string& email,
     google_apis::drive::PermissionRole role,
     const google_apis::EntryActionCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_ADD_PERMISSION);
   new_job->task = base::Bind(&DriveServiceInterface::AddPermission,
                              base::Unretained(drive_service_),
                              resource_id,
                              email,
                              role,
                              base::Bind(&JobScheduler::OnEntryActionJobDone,
                                         weak_ptr_factory_.GetWeakPtr(),
@@ skipping 11 matching lines @@
 
 void JobScheduler::StartJob(JobEntry* job) {
   DCHECK(!job->task.is_null());
 
   QueueJob(job->job_info.job_id);
   NotifyJobAdded(job->job_info);
   DoJobLoop(GetJobQueueType(job->job_info.job_type));
 }
 
 void JobScheduler::QueueJob(JobID job_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   JobEntry* job_entry = job_map_.Lookup(job_id);
   DCHECK(job_entry);
   const JobInfo& job_info = job_entry->job_info;
 
   const QueueType queue_type = GetJobQueueType(job_info.job_type);
   queue_[queue_type]->Push(job_id, job_entry->context.type);
 
   // Temporary histogram for crbug.com/229650.
   if (job_info.job_type == TYPE_DOWNLOAD_FILE ||
@@ skipping 12 matching lines @@
   const std::string retry_prefix = job_entry->retry_count > 0 ?
       base::StringPrintf(" (retry %d)", job_entry->retry_count) : "";
   logger_->Log(logging::LOG_INFO,
                "Job queued%s: %s - %s",
                retry_prefix.c_str(),
                job_info.ToString().c_str(),
                GetQueueInfo(queue_type).c_str());
 }
 
 void JobScheduler::DoJobLoop(QueueType queue_type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   const int accepted_priority = GetCurrentAcceptedPriority(queue_type);
 
   // Abort all USER_INITAITED jobs when not accepted.
   if (accepted_priority < USER_INITIATED) {
     std::vector<JobID> jobs;
     queue_[queue_type]->GetQueuedJobs(USER_INITIATED, &jobs);
     for (size_t i = 0; i < jobs.size(); ++i) {
       JobEntry* job = job_map_.Lookup(jobs[i]);
       DCHECK(job);
@@ skipping 30 matching lines @@
 
   UpdateWait();
 
   logger_->Log(logging::LOG_INFO,
                "Job started: %s - %s",
                job_info->ToString().c_str(),
                GetQueueInfo(queue_type).c_str());
 }
 
 int JobScheduler::GetCurrentAcceptedPriority(QueueType queue_type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   const int kNoJobShouldRun = -1;
 
   // Should stop if Drive was disabled while running the fetch loop.
   if (pref_service_->GetBoolean(prefs::kDisableDrive))
     return kNoJobShouldRun;
 
   // Should stop if the network is not online.
   if (net::NetworkChangeNotifier::IsOffline())
     return kNoJobShouldRun;
 
   // For the file queue, if it is on cellular network, only user initiated
   // operations are allowed to start.
   if (queue_type == FILE_QUEUE &&
       pref_service_->GetBoolean(prefs::kDisableDriveOverCellular) &&
       net::NetworkChangeNotifier::IsConnectionCellular(
           net::NetworkChangeNotifier::GetConnectionType()))
     return USER_INITIATED;
 
   // Otherwise, every operations including background tasks are allowed.
   return BACKGROUND;
 }
 
 void JobScheduler::UpdateWait() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (disable_throttling_ || throttle_count_ == 0)
     return;
 
   // Exponential backoff: https://developers.google.com/drive/handle-errors.
   base::TimeDelta delay =
       base::TimeDelta::FromSeconds(1 << (throttle_count_ - 1)) +
       base::TimeDelta::FromMilliseconds(base::RandInt(0, 1000));
   VLOG(1) << "Throttling for " << delay.InMillisecondsF();
 
   wait_until_ = std::max(wait_until_, base::Time::Now() + delay);
 }
 
 bool JobScheduler::OnJobDone(JobID job_id,
                              google_apis::DriveApiErrorCode error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   JobEntry* job_entry = job_map_.Lookup(job_id);
   DCHECK(job_entry);
   JobInfo* job_info = &job_entry->job_info;
   QueueType queue_type = GetJobQueueType(job_info->job_type);
   queue_[queue_type]->MarkFinished(job_id);
 
   const base::TimeDelta elapsed = base::Time::Now() - job_info->start_time;
   bool success = (GDataToFileError(error) == FILE_ERROR_OK);
   logger_->Log(success ? logging::LOG_INFO : logging::LOG_WARNING,
@@ skipping 40 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  queue_type));
   return !should_retry;
 }
 
 void JobScheduler::OnGetFileListJobDone(
     JobID job_id,
     const google_apis::FileListCallback& callback,
     google_apis::DriveApiErrorCode error,
     scoped_ptr<google_apis::FileList> file_list) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (OnJobDone(job_id, error))
     callback.Run(error, file_list.Pass());
 }
 
 void JobScheduler::OnGetChangeListJobDone(
     JobID job_id,
     const google_apis::ChangeListCallback& callback,
     google_apis::DriveApiErrorCode error,
     scoped_ptr<google_apis::ChangeList> change_list) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (OnJobDone(job_id, error))
     callback.Run(error, change_list.Pass());
 }
 
 void JobScheduler::OnGetFileResourceJobDone(
     JobID job_id,
     const google_apis::FileResourceCallback& callback,
     google_apis::DriveApiErrorCode error,
     scoped_ptr<google_apis::FileResource> entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (OnJobDone(job_id, error))
     callback.Run(error, entry.Pass());
 }
 
 void JobScheduler::OnGetAboutResourceJobDone(
     JobID job_id,
     const google_apis::AboutResourceCallback& callback,
     google_apis::DriveApiErrorCode error,
     scoped_ptr<google_apis::AboutResource> about_resource) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (OnJobDone(job_id, error))
     callback.Run(error, about_resource.Pass());
 }
 
 void JobScheduler::OnGetShareUrlJobDone(
     JobID job_id,
     const google_apis::GetShareUrlCallback& callback,
     google_apis::DriveApiErrorCode error,
     const GURL& share_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (OnJobDone(job_id, error))
     callback.Run(error, share_url);
 }
 
 void JobScheduler::OnGetAppListJobDone(
     JobID job_id,
     const google_apis::AppListCallback& callback,
     google_apis::DriveApiErrorCode error,
     scoped_ptr<google_apis::AppList> app_list) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (OnJobDone(job_id, error))
     callback.Run(error, app_list.Pass());
 }
 
 void JobScheduler::OnEntryActionJobDone(
     JobID job_id,
     const google_apis::EntryActionCallback& callback,
     google_apis::DriveApiErrorCode error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (OnJobDone(job_id, error))
     callback.Run(error);
 }
 
 void JobScheduler::OnDownloadActionJobDone(
     JobID job_id,
     const google_apis::DownloadActionCallback& callback,
     google_apis::DriveApiErrorCode error,
     const base::FilePath& temp_file) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (OnJobDone(job_id, error))
     callback.Run(error, temp_file);
 }
 
 void JobScheduler::OnUploadCompletionJobDone(
     JobID job_id,
     const ResumeUploadParams& resume_params,
     const google_apis::FileResourceCallback& callback,
     google_apis::DriveApiErrorCode error,
     const GURL& upload_location,
     scoped_ptr<google_apis::FileResource> entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (!upload_location.is_empty()) {
     // If upload_location is available, update the task to resume the
     // upload process from the terminated point.
     // When we need to retry, the error code should be HTTP_SERVICE_UNAVAILABLE
     // so OnJobDone called below will be in charge to re-queue the job.
     JobEntry* job_entry = job_map_.Lookup(job_id);
     DCHECK(job_entry);
 
@@ skipping 16 matching lines @@
     callback.Run(error, entry.Pass());
 }
 
 void JobScheduler::OnResumeUploadFileDone(
     JobID job_id,
     const base::Callback<google_apis::CancelCallback()>& original_task,
     const google_apis::FileResourceCallback& callback,
     google_apis::DriveApiErrorCode error,
     const GURL& upload_location,
     scoped_ptr<google_apis::FileResource> entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!original_task.is_null());
   DCHECK(!callback.is_null());
 
   if (upload_location.is_empty()) {
     // If upload_location is not available, we should discard it and stop trying
     // to resume. Restore the original task.
     JobEntry* job_entry = job_map_.Lookup(job_id);
     DCHECK(job_entry);
     job_entry->task = original_task;
   }
 
   if (OnJobDone(job_id, error))
     callback.Run(error, entry.Pass());
 }
 
 void JobScheduler::UpdateProgress(JobID job_id, int64 progress, int64 total) {
   JobEntry* job_entry = job_map_.Lookup(job_id);
   DCHECK(job_entry);
 
   job_entry->job_info.num_completed_bytes = progress;
   if (total != -1)
     job_entry->job_info.num_total_bytes = total;
   NotifyJobUpdated(job_entry->job_info);
 }
 
 void JobScheduler::OnConnectionTypeChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Resume the job loop.
   // Note that we don't need to check the network connection status as it will
   // be checked in GetCurrentAcceptedPriority().
   for (int i = METADATA_QUEUE; i < NUM_QUEUES; ++i)
     DoJobLoop(static_cast<QueueType>(i));
 }
 
 void JobScheduler::OnGotFileSizeForJob(JobID job_id,
                                        const std::string& histogram_name,
                                        int64* size) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (*size == -1)
     return;
 
   // Temporary histogram for crbug.com/229650.
   CollectCopyHistogramSample(histogram_name, *size);
 
   JobEntry* const job_entry = job_map_.Lookup(job_id);
   if (!job_entry)
     return;
 
@@ skipping 26 matching lines @@
     case TYPE_UPLOAD_NEW_FILE:
     case TYPE_UPLOAD_EXISTING_FILE:
       return FILE_QUEUE;
   }
   NOTREACHED();
   return FILE_QUEUE;
 }
 
 void JobScheduler::AbortNotRunningJob(JobEntry* job,
                                       google_apis::DriveApiErrorCode error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   const base::TimeDelta elapsed = base::Time::Now() - job->job_info.start_time;
   const QueueType queue_type = GetJobQueueType(job->job_info.job_type);
   logger_->Log(logging::LOG_INFO,
                "Job aborted: %s => %s (elapsed time: %sms) - %s",
                job->job_info.ToString().c_str(),
                DriveApiErrorCodeToString(error).c_str(),
                base::Int64ToString(elapsed.InMilliseconds()).c_str(),
                GetQueueInfo(queue_type).c_str());
 
   base::Callback<void(google_apis::DriveApiErrorCode)> callback =
       job->abort_callback;
   queue_[GetJobQueueType(job->job_info.job_type)]->Remove(job->job_info.job_id);
   NotifyJobDone(job->job_info, error);
   job_map_.Remove(job->job_info.job_id);
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
                                               base::Bind(callback, error));
 }
 
 void JobScheduler::NotifyJobAdded(const JobInfo& job_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   FOR_EACH_OBSERVER(JobListObserver, observer_list_, OnJobAdded(job_info));
 }
 
 void JobScheduler::NotifyJobDone(const JobInfo& job_info,
                                  google_apis::DriveApiErrorCode error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   FOR_EACH_OBSERVER(JobListObserver, observer_list_,
                     OnJobDone(job_info, GDataToFileError(error)));
 }
 
 void JobScheduler::NotifyJobUpdated(const JobInfo& job_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   FOR_EACH_OBSERVER(JobListObserver, observer_list_, OnJobUpdated(job_info));
 }
 
 std::string JobScheduler::GetQueueInfo(QueueType type) const {
   return QueueTypeToString(type) + " " + queue_[type]->ToString();
 }
 
 // static
 std::string JobScheduler::QueueTypeToString(QueueType type) {
   switch (type) {
     case METADATA_QUEUE:
       return "METADATA_QUEUE";
     case FILE_QUEUE:
       return "FILE_QUEUE";
     case NUM_QUEUES:
       break;  // This value is just a sentinel. Should never be used.
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace drive