[chrome/browser/chromeos/drive] Avoid use of MessageLoopProxy by use of TTRH

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"
+#include "base/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
 #include "chrome/browser/chromeos/drive/file_system/download_operation.h"
 #include "chrome/browser/chromeos/drive/file_system/operation_delegate.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/sync/entry_update_performer.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/task_util.h"
 
@@ skipping 295 matching lines @@
         return;
       case RUNNING:
         // Something has changed since the task started. Schedule rerun.
         it->second.should_run_again = true;
         return;
     }
   } else {
     tasks_[key] = task;
   }
   DCHECK_EQ(PENDING, task.state);
-  base::MessageLoopProxy::current()->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&SyncClient::StartTask, weak_ptr_factory_.GetWeakPtr(), key),
       delay);
 }
 
 void SyncClient::StartTask(const SyncTasks::key_type& key) {
   ResourceEntry* parent = new ResourceEntry;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
@@ skipping 110 matching lines @@
           file_system::DRIVE_SYNC_ERROR_SERVICE_UNAVAILABLE, local_id);
       break;
     default:
       operation_delegate_->OnDriveSyncError(
           file_system::DRIVE_SYNC_ERROR_MISC, local_id);
       LOG(WARNING) << "Failed: type = " << type << ", id = " << local_id
                    << ": " << FileErrorToString(error);
   }
 
   for (size_t i = 0; i < it->second.waiting_callbacks.size(); ++i) {
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(it->second.waiting_callbacks[i], error));
   }
   it->second.waiting_callbacks.clear();
 
   if (it->second.should_run_again) {
     DVLOG(1) << "Running again: type = " << type << ", id = " << local_id;
     it->second.state = PENDING;
     it->second.should_run_again = false;
-    base::MessageLoopProxy::current()->PostDelayedTask(
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&SyncClient::StartTask, weak_ptr_factory_.GetWeakPtr(), key),
         retry_delay);
   } else {
     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_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