components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/sessions/base_session_service.cc

 // Copyright 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 "components/sessions/base_session_service.h"
 
 #include "base/bind.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "components/sessions/base_session_service_delegate.h"
 #include "components/sessions/session_backend.h"
 
 // BaseSessionService ---------------------------------------------------------
 
 namespace sessions {
 namespace {
 
 // Helper used by ScheduleGetLastSessionCommands. It runs callback on TaskRunner
@@ skipping 87 matching lines @@
 }
 
 void BaseSessionService::ClearPendingCommands() {
   pending_commands_.clear();
 }
 
 void BaseSessionService::StartSaveTimer() {
   // Don't start a timer when testing.
   if (delegate_->ShouldUseDelayedSave() && base::MessageLoop::current() &&
       !weak_factory_.HasWeakPtrs()) {
-    base::MessageLoop::current()->PostDelayedTask(
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
-        base::Bind(&BaseSessionService::Save,
-                   weak_factory_.GetWeakPtr()),
+        base::Bind(&BaseSessionService::Save, weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kSaveDelayMS));
   }
 }
 
 void BaseSessionService::Save() {
   // Inform the delegate that we will save the commands now, giving it the
   // opportunity to append more commands.
   delegate_->OnWillSaveCommands();
 
   if (pending_commands_.empty())
@@ skipping 21 matching lines @@
     base::CancelableTaskTracker* tracker) {
   base::CancelableTaskTracker::IsCanceledCallback is_canceled;
   base::CancelableTaskTracker::TaskId id =
       tracker->NewTrackedTaskId(&is_canceled);
 
   GetCommandsCallback run_if_not_canceled =
       base::Bind(&RunIfNotCanceled, is_canceled, callback);
 
   GetCommandsCallback callback_runner =
       base::Bind(&PostOrRunInternalGetCommandsCallback,
-                 base::MessageLoopProxy::current(), run_if_not_canceled);
+                 base::ThreadTaskRunnerHandle::Get(), run_if_not_canceled);
 
   RunTaskOnBackendThread(
       FROM_HERE,
       base::Bind(&SessionBackend::ReadLastSessionCommands, backend_,
                  is_canceled, callback_runner));
   return id;
 }
 
 void BaseSessionService::RunTaskOnBackendThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
   base::SequencedWorkerPool* pool = delegate_->GetBlockingPool();
   if (!pool->IsShutdownInProgress()) {
     pool->PostSequencedWorkerTask(sequence_token_, from_here, task);
   } else {
     // Fall back to executing on the main thread if the sequence
     // worker pool has been requested to shutdown (around shutdown
     // time).
     task.Run();
   }
 }
 
 }  // namespace sessions