Revert "content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs"

This reverts commit 422456f9d53f0bf936a64f21a1463fd0abd3df84.

TBR=zea@chromium.org
BUG=465354
NOTRY=true
NOTREECHECKS=true

Review URL: https://codereview.chromium.org/1170623003

Cr-Commit-Position: refs/heads/master@{#333086}

5 files changed, 60 insertions, 52 deletions

diff --git a/content/browser/dom_storage/dom_storage_area_unittest.cc b/content/browser/dom_storage/dom_storage_area_unittest.cc
index ba91f26..aa5653d 100644
--- a/content/browser/dom_storage/dom_storage_area_unittest.cc
+++ b/content/browser/dom_storage/dom_storage_area_unittest.cc
@@ -5,9 +5,7 @@
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/location.h"
 #include "base/message_loop/message_loop.h"
-#include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ -47,10 +45,11 @@ class DOMStorageAreaTest : public testing::Test {
     // At this point the StartCommitTimer task has run and
     // the OnCommitTimer task is queued. We want to inject after
     // that.
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&DOMStorageAreaTest::InjectedCommitSequencingTask2,
-                   base::Unretained(this), area));
+                   base::Unretained(this),
+                   area));
   }
 
   void InjectedCommitSequencingTask2(
@@ -174,10 +173,10 @@ TEST_F(DOMStorageAreaTest, BackingDatabaseOpened) {
 
   // This should set up a DOMStorageArea that is correctly backed to disk.
   {
-    scoped_refptr<DOMStorageArea> area(
-        new DOMStorageArea(kOrigin, temp_dir.path(),
-                           new MockDOMStorageTaskRunner(
-                               base::ThreadTaskRunnerHandle::Get().get())));
+    scoped_refptr<DOMStorageArea> area(new DOMStorageArea(
+        kOrigin,
+        temp_dir.path(),
+        new MockDOMStorageTaskRunner(base::MessageLoopProxy::current().get())));
 
     EXPECT_TRUE(area->backing_.get());
     DOMStorageDatabase* database = static_cast<LocalStorageDatabaseAdapter*>(
@@ -222,8 +221,9 @@ TEST_F(DOMStorageAreaTest, CommitTasks) {
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   scoped_refptr<DOMStorageArea> area(new DOMStorageArea(
-      kOrigin, temp_dir.path(),
-      new MockDOMStorageTaskRunner(base::ThreadTaskRunnerHandle::Get().get())));
+      kOrigin,
+      temp_dir.path(),
+      new MockDOMStorageTaskRunner(base::MessageLoopProxy::current().get())));
   // Inject an in-memory db to speed up the test.
   area->backing_.reset(new LocalStorageDatabaseAdapter());
 
@@ -300,8 +300,9 @@ TEST_F(DOMStorageAreaTest, CommitChangesAtShutdown) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   scoped_refptr<DOMStorageArea> area(new DOMStorageArea(
-      kOrigin, temp_dir.path(),
-      new MockDOMStorageTaskRunner(base::ThreadTaskRunnerHandle::Get().get())));
+      kOrigin,
+      temp_dir.path(),
+      new MockDOMStorageTaskRunner(base::MessageLoopProxy::current().get())));
 
   // Inject an in-memory db to speed up the test and also to verify
   // the final changes are commited in it's dtor.
@@ -326,8 +327,9 @@ TEST_F(DOMStorageAreaTest, DeleteOrigin) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   scoped_refptr<DOMStorageArea> area(new DOMStorageArea(
-      kOrigin, temp_dir.path(),
-      new MockDOMStorageTaskRunner(base::ThreadTaskRunnerHandle::Get().get())));
+      kOrigin,
+      temp_dir.path(),
+      new MockDOMStorageTaskRunner(base::MessageLoopProxy::current().get())));
 
   // This test puts files on disk.
   base::FilePath db_file_path = static_cast<LocalStorageDatabaseAdapter*>(
@@ -386,8 +388,9 @@ TEST_F(DOMStorageAreaTest, PurgeMemory) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   scoped_refptr<DOMStorageArea> area(new DOMStorageArea(
-      kOrigin, temp_dir.path(),
-      new MockDOMStorageTaskRunner(base::ThreadTaskRunnerHandle::Get().get())));
+      kOrigin,
+      temp_dir.path(),
+      new MockDOMStorageTaskRunner(base::MessageLoopProxy::current().get())));
 
   // Inject an in-memory db to speed up the test.
   area->backing_.reset(new LocalStorageDatabaseAdapter());
diff --git a/content/browser/dom_storage/dom_storage_context_impl_unittest.cc b/content/browser/dom_storage/dom_storage_context_impl_unittest.cc
index fe99fbf..9ea4602 100644
--- a/content/browser/dom_storage/dom_storage_context_impl_unittest.cc
+++ b/content/browser/dom_storage/dom_storage_context_impl_unittest.cc
@@ -6,8 +6,8 @@
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
@@ -43,7 +43,7 @@ class DOMStorageContextImplTest : public testing::Test {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     storage_policy_ = new MockSpecialStoragePolicy;
     task_runner_ =
-        new MockDOMStorageTaskRunner(base::ThreadTaskRunnerHandle::Get().get());
+        new MockDOMStorageTaskRunner(base::MessageLoopProxy::current().get());
     context_ = new DOMStorageContextImpl(temp_dir_.path(),
                                          base::FilePath(),
                                          storage_policy_.get(),
diff --git a/content/browser/dom_storage/dom_storage_context_wrapper.cc b/content/browser/dom_storage/dom_storage_context_wrapper.cc
index db486f3..fef44e8 100644
--- a/content/browser/dom_storage/dom_storage_context_wrapper.cc
+++ b/content/browser/dom_storage/dom_storage_context_wrapper.cc
@@ -10,9 +10,7 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
-#include "base/location.h"
-#include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_context_impl.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
@@ -34,15 +32,16 @@ void InvokeLocalStorageUsageCallbackHelper(
 }
 
 void GetLocalStorageUsageHelper(
-    base::SingleThreadTaskRunner* reply_task_runner,
+    base::MessageLoopProxy* reply_loop,
     DOMStorageContextImpl* context,
     const DOMStorageContext::GetLocalStorageUsageCallback& callback) {
   std::vector<LocalStorageUsageInfo>* infos =
       new std::vector<LocalStorageUsageInfo>;
   context->GetLocalStorageUsage(infos, true);
-  reply_task_runner->PostTask(
-      FROM_HERE, base::Bind(&InvokeLocalStorageUsageCallbackHelper, callback,
-                            base::Owned(infos)));
+  reply_loop->PostTask(
+      FROM_HERE,
+      base::Bind(&InvokeLocalStorageUsageCallbackHelper,
+                 callback, base::Owned(infos)));
 }
 
 void InvokeSessionStorageUsageCallbackHelper(
@@ -52,15 +51,16 @@ void InvokeSessionStorageUsageCallbackHelper(
 }
 
 void GetSessionStorageUsageHelper(
-    base::SingleThreadTaskRunner* reply_task_runner,
+    base::MessageLoopProxy* reply_loop,
     DOMStorageContextImpl* context,
     const DOMStorageContext::GetSessionStorageUsageCallback& callback) {
   std::vector<SessionStorageUsageInfo>* infos =
       new std::vector<SessionStorageUsageInfo>;
   context->GetSessionStorageUsage(infos);
-  reply_task_runner->PostTask(
-      FROM_HERE, base::Bind(&InvokeSessionStorageUsageCallbackHelper, callback,
-                            base::Owned(infos)));
+  reply_loop->PostTask(
+      FROM_HERE,
+      base::Bind(&InvokeSessionStorageUsageCallbackHelper,
+                 callback, base::Owned(infos)));
 }
 
 }  // namespace
@@ -89,19 +89,25 @@ DOMStorageContextWrapper::~DOMStorageContextWrapper() {
 void DOMStorageContextWrapper::GetLocalStorageUsage(
     const GetLocalStorageUsageCallback& callback) {
   DCHECK(context_.get());
-  context_->task_runner()->PostShutdownBlockingTask(
-      FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
-      base::Bind(&GetLocalStorageUsageHelper,
-                 base::ThreadTaskRunnerHandle::Get(), context_, callback));
+  context_->task_runner()
+      ->PostShutdownBlockingTask(FROM_HERE,
+                                 DOMStorageTaskRunner::PRIMARY_SEQUENCE,
+                                 base::Bind(&GetLocalStorageUsageHelper,
+                                            base::MessageLoopProxy::current(),
+                                            context_,
+                                            callback));
 }
 
 void DOMStorageContextWrapper::GetSessionStorageUsage(
     const GetSessionStorageUsageCallback& callback) {
   DCHECK(context_.get());
-  context_->task_runner()->PostShutdownBlockingTask(
-      FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
-      base::Bind(&GetSessionStorageUsageHelper,
-                 base::ThreadTaskRunnerHandle::Get(), context_, callback));
+  context_->task_runner()
+      ->PostShutdownBlockingTask(FROM_HERE,
+                                 DOMStorageTaskRunner::PRIMARY_SEQUENCE,
+                                 base::Bind(&GetSessionStorageUsageHelper,
+                                            base::MessageLoopProxy::current(),
+                                            context_,
+                                            callback));
 }
 
 void DOMStorageContextWrapper::DeleteLocalStorage(const GURL& origin) {
diff --git a/content/browser/dom_storage/dom_storage_task_runner.cc b/content/browser/dom_storage/dom_storage_task_runner.cc
index cf2204d..aa75c3c 100644
--- a/content/browser/dom_storage/dom_storage_task_runner.cc
+++ b/content/browser/dom_storage/dom_storage_task_runner.cc
@@ -6,7 +6,7 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/location.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/tracked_objects.h"
 
 namespace content {
@@ -23,8 +23,8 @@ DOMStorageWorkerPoolTaskRunner::DOMStorageWorkerPoolTaskRunner(
     base::SequencedWorkerPool* sequenced_worker_pool,
     base::SequencedWorkerPool::SequenceToken primary_sequence_token,
     base::SequencedWorkerPool::SequenceToken commit_sequence_token,
-    base::SingleThreadTaskRunner* delayed_task_task_runner)
-    : task_runner_(delayed_task_task_runner),
+    base::MessageLoopProxy* delayed_task_loop)
+    : message_loop_(delayed_task_loop),
       sequenced_worker_pool_(sequenced_worker_pool),
       primary_sequence_token_(primary_sequence_token),
       commit_sequence_token_(commit_sequence_token) {
@@ -46,7 +46,7 @@ bool DOMStorageWorkerPoolTaskRunner::PostDelayedTask(
         base::SequencedWorkerPool::BLOCK_SHUTDOWN);
   }
   // Post a task to call this->PostTask() after the delay.
-  return task_runner_->PostDelayedTask(
+  return message_loop_->PostDelayedTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&DOMStorageWorkerPoolTaskRunner::PostTask),
                  this, from_here, task),
@@ -79,8 +79,8 @@ DOMStorageWorkerPoolTaskRunner::IDtoToken(SequenceID id) const {
 // MockDOMStorageTaskRunner
 
 MockDOMStorageTaskRunner::MockDOMStorageTaskRunner(
-    base::SingleThreadTaskRunner* task_runner)
-    : task_runner_(task_runner) {
+    base::MessageLoopProxy* message_loop)
+    : message_loop_(message_loop) {
 }
 
 MockDOMStorageTaskRunner::~MockDOMStorageTaskRunner() {
@@ -90,18 +90,18 @@ bool MockDOMStorageTaskRunner::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     base::TimeDelta delay) {
-  return task_runner_->PostTask(from_here, task);
+  return message_loop_->PostTask(from_here, task);
 }
 
 bool MockDOMStorageTaskRunner::PostShutdownBlockingTask(
     const tracked_objects::Location& from_here,
     SequenceID sequence_id,
     const base::Closure& task) {
-  return task_runner_->PostTask(from_here, task);
+  return message_loop_->PostTask(from_here, task);
 }
 
 bool MockDOMStorageTaskRunner::IsRunningOnSequence(SequenceID) const {
-  return task_runner_->RunsTasksOnCurrentThread();
+  return message_loop_->RunsTasksOnCurrentThread();
 }
 
 }  // namespace content
diff --git a/content/browser/dom_storage/dom_storage_task_runner.h b/content/browser/dom_storage/dom_storage_task_runner.h
index f71c9c8..1d4485c 100644
--- a/content/browser/dom_storage/dom_storage_task_runner.h
+++ b/content/browser/dom_storage/dom_storage_task_runner.h
@@ -7,13 +7,12 @@
 
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
-#include "base/single_thread_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "content/common/content_export.h"
 
 namespace base {
-class SingleThreadTaskRunner;
+class MessageLoopProxy;
 }
 
 namespace content {
@@ -74,7 +73,7 @@ class CONTENT_EXPORT DOMStorageWorkerPoolTaskRunner :
       base::SequencedWorkerPool* sequenced_worker_pool,
       base::SequencedWorkerPool::SequenceToken primary_sequence_token,
       base::SequencedWorkerPool::SequenceToken commit_sequence_token,
-      base::SingleThreadTaskRunner* delayed_task_task_runner);
+      base::MessageLoopProxy* delayed_task_loop);
 
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
@@ -93,7 +92,7 @@ class CONTENT_EXPORT DOMStorageWorkerPoolTaskRunner :
 
   base::SequencedWorkerPool::SequenceToken IDtoToken(SequenceID id) const;
 
-  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  const scoped_refptr<base::MessageLoopProxy> message_loop_;
   const scoped_refptr<base::SequencedWorkerPool> sequenced_worker_pool_;
   base::SequencedWorkerPool::SequenceToken primary_sequence_token_;
   base::SequencedWorkerPool::SequenceToken commit_sequence_token_;
@@ -107,7 +106,7 @@ class CONTENT_EXPORT DOMStorageWorkerPoolTaskRunner :
 class CONTENT_EXPORT MockDOMStorageTaskRunner :
       public DOMStorageTaskRunner {
  public:
-  explicit MockDOMStorageTaskRunner(base::SingleThreadTaskRunner* task_runner);
+  explicit MockDOMStorageTaskRunner(base::MessageLoopProxy* message_loop);
 
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
@@ -123,7 +122,7 @@ class CONTENT_EXPORT MockDOMStorageTaskRunner :
   ~MockDOMStorageTaskRunner() override;
 
  private:
-  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  const scoped_refptr<base::MessageLoopProxy> message_loop_;
 };
 
 }  // namespace content