content/child: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/child/web_data_consumer_handle_impl_unittest.cc

 // Copyright 2014 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 "content/child/web_data_consumer_handle_impl.h"
 
 #include <algorithm>
 #include <string>
 #include "base/bind.h"
+#include "base/location.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/mojo/src/mojo/public/cpp/system/data_pipe.h"
 
 namespace content {
 
 namespace {
 
 using blink::WebDataConsumerHandle;
 
@@ skipping 10 matching lines @@
   static const WebDataConsumerHandle::Result kShouldWait =
       WebDataConsumerHandle::ShouldWait;
 };
 
 class ClientImpl final : public WebDataConsumerHandle::Client {
  public:
   explicit ClientImpl(ReadDataOperationBase* operation)
       : operation_(operation) {}
 
   void didGetReadable() override {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&ReadDataOperationBase::ReadMore,
-                   base::Unretained(operation_)));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&ReadDataOperationBase::ReadMore,
+                              base::Unretained(operation_)));
   }
 
  private:
   ReadDataOperationBase* operation_;
 };
 
 class ReadDataOperation : public ReadDataOperationBase {
  public:
   typedef WebDataConsumerHandle::Result Result;
   ReadDataOperation(mojo::ScopedDataPipeConsumerHandle handle,
@@ skipping 28 matching lines @@
       // Wait a while...
       return;
     }
 
     if (rv != kDone) {
       // Something is wrong.
       result_ = "error";
     }
 
     // The operation is done.
-    main_message_loop_->PostTask(FROM_HERE, on_done_);
+    main_message_loop_->task_runner()->PostTask(FROM_HERE, on_done_);
   }
 
  private:
   scoped_ptr<WebDataConsumerHandle> handle_;
   scoped_ptr<WebDataConsumerHandle::Client> client_;
   base::MessageLoop* main_message_loop_;
   base::Closure on_done_;
   std::string result_;
 };
 
@@ skipping 26 matching lines @@
       if (rv != kOk)
         break;
       // In order to verify endRead, we read at most one byte for each time.
       size_t read_size = std::max(static_cast<size_t>(1), size);
       result_.insert(result_.size(), static_cast<const char*>(buffer),
                      read_size);
       rv = handle_->endRead(read_size);
       if (rv != kOk) {
         // Something is wrong.
         result_ = "error";
-        main_message_loop_->PostTask(FROM_HERE, on_done_);
+        main_message_loop_->task_runner()->PostTask(FROM_HERE, on_done_);
         return;
       }
     }
 
     if (rv == kShouldWait) {
       // Wait a while...
       return;
     }
 
     if (rv != kDone) {
       // Something is wrong.
       result_ = "error";
     }
 
     // The operation is done.
-    main_message_loop_->PostTask(FROM_HERE, on_done_);
+    main_message_loop_->task_runner()->PostTask(FROM_HERE, on_done_);
   }
 
  private:
   scoped_ptr<WebDataConsumerHandle> handle_;
   scoped_ptr<WebDataConsumerHandle::Client> client_;
   base::MessageLoop* main_message_loop_;
   base::Closure on_done_;
   std::string result_;
 };
 
@@ skipping 50 matching lines @@
 TEST_F(WebDataConsumerHandleImplTest, ReadData) {
   base::RunLoop run_loop;
   auto operation = make_scoped_ptr(new ReadDataOperation(
       consumer_.Pass(),
       &message_loop_,
       run_loop.QuitClosure()));
 
   base::Thread t("DataConsumerHandle test thread");
   ASSERT_TRUE(t.Start());
 
-  t.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&ReadDataOperation::ReadData,
-                 base::Unretained(operation.get())));
+  t.task_runner()->PostTask(FROM_HERE,
+                            base::Bind(&ReadDataOperation::ReadData,
+                                       base::Unretained(operation.get())));
 
   std::string expected = ProduceData(24 * 1024);
   producer_.reset();
 
   run_loop.Run();
   t.Stop();
 
   EXPECT_EQ(expected, operation->result());
 }
 
 TEST_F(WebDataConsumerHandleImplTest, TwoPhaseReadData) {
   base::RunLoop run_loop;
   auto operation = make_scoped_ptr(new TwoPhaseReadDataOperation(
       consumer_.Pass(),
       &message_loop_,
       run_loop.QuitClosure()));
 
   base::Thread t("DataConsumerHandle test thread");
   ASSERT_TRUE(t.Start());
 
-  t.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&TwoPhaseReadDataOperation::ReadData,
-                 base::Unretained(operation.get())));
+  t.task_runner()->PostTask(FROM_HERE,
+                            base::Bind(&TwoPhaseReadDataOperation::ReadData,
+                                       base::Unretained(operation.get())));
 
   std::string expected = ProduceData(24 * 1024);
   producer_.reset();
 
   run_loop.Run();
   t.Stop();
 
   EXPECT_EQ(expected, operation->result());
 }
 
 }  // namespace
 
 }  // namespace content