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

content/child/threaded_data_provider.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/threaded_data_provider.h"
 
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "components/scheduler/child/webthread_impl_for_worker_scheduler.h"
 #include "content/child/child_process.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/resource_dispatcher.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/resource_messages.h"
 #include "ipc/ipc_sync_channel.h"
 #include "third_party/WebKit/public/platform/WebThread.h"
 #include "third_party/WebKit/public/platform/WebThreadedDataReceiver.h"
 
 namespace content {
 
 namespace {
 
 class DataProviderMessageFilter : public IPC::MessageFilter {
  public:
   DataProviderMessageFilter(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
       const scheduler::WebThreadImplForWorkerScheduler& background_thread,
       const base::WeakPtr<ThreadedDataProvider>&
           background_thread_resource_provider,
       const base::WeakPtr<ThreadedDataProvider>& main_thread_resource_provider,
       int request_id);
 
   // IPC::ChannelProxy::MessageFilter
   void OnFilterAdded(IPC::Sender* sender) final;
   bool OnMessageReceived(const IPC::Message& message) final;
 
  private:
   ~DataProviderMessageFilter() override {}
 
   void OnReceivedData(int request_id, int data_offset, int data_length,
                       int encoded_data_length);
 
-  const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
   const scheduler::WebThreadImplForWorkerScheduler& background_thread_;
   // This weakptr can only be dereferenced on the background thread.
   base::WeakPtr<ThreadedDataProvider>
       background_thread_resource_provider_;
   // This weakptr can only be dereferenced on the main thread.
   base::WeakPtr<ThreadedDataProvider>
       main_thread_resource_provider_;
   int request_id_;
 };
 
 DataProviderMessageFilter::DataProviderMessageFilter(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
     const scheduler::WebThreadImplForWorkerScheduler& background_thread,
     const base::WeakPtr<ThreadedDataProvider>&
         background_thread_resource_provider,
     const base::WeakPtr<ThreadedDataProvider>& main_thread_resource_provider,
     int request_id)
-    : io_message_loop_(io_message_loop),
+    : io_task_runner_(io_task_runner),
       main_thread_task_runner_(main_thread_task_runner),
       background_thread_(background_thread),
       background_thread_resource_provider_(background_thread_resource_provider),
       main_thread_resource_provider_(main_thread_resource_provider),
       request_id_(request_id) {
   DCHECK(main_thread_task_runner_.get());
 }
 
 void DataProviderMessageFilter::OnFilterAdded(IPC::Sender* sender) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ThreadedDataProvider::OnResourceMessageFilterAddedMainThread,
                  main_thread_resource_provider_));
 }
 
 bool DataProviderMessageFilter::OnMessageReceived(
     const IPC::Message& message) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (message.type() != ResourceMsg_DataReceived::ID)
     return false;
 
   int request_id;
 
   PickleIterator iter(message);
   if (!iter.ReadInt(&request_id)) {
     NOTREACHED() << "malformed resource message";
     return true;
   }
 
   if (request_id == request_id_) {
     ResourceMsg_DataReceived::Schema::Param arg;
     if (ResourceMsg_DataReceived::Read(&message, &arg)) {
       OnReceivedData(get<0>(arg), get<1>(arg), get<2>(arg), get<3>(arg));
       return true;
     }
   }
 
   return false;
 }
 
 void DataProviderMessageFilter::OnReceivedData(int request_id,
                                                int data_offset,
                                                int data_length,
                                                int encoded_data_length) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   background_thread_.TaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadedDataProvider::OnReceivedDataOnBackgroundThread,
                  background_thread_resource_provider_, data_offset, data_length,
                  encoded_data_length));
 }
 
 }  // anonymous namespace
 
 ThreadedDataProvider::ThreadedDataProvider(
@@ skipping 15 matching lines @@
       main_thread_weak_factory_(this) {
   DCHECK(ChildThreadImpl::current());
   DCHECK(ipc_channel_);
   DCHECK(threaded_data_receiver_);
   DCHECK(main_thread_task_runner_.get());
 
   background_thread_weak_factory_.reset(
       new base::WeakPtrFactory<ThreadedDataProvider>(this));
 
   filter_ = new DataProviderMessageFilter(
-      ChildProcess::current()->io_message_loop_proxy(),
-      main_thread_task_runner_, background_thread_,
-      background_thread_weak_factory_->GetWeakPtr(),
+      ChildProcess::current()->io_task_runner(), main_thread_task_runner_,
+      background_thread_, background_thread_weak_factory_->GetWeakPtr(),
       main_thread_weak_factory_.GetWeakPtr(), request_id);
 
   ChildThreadImpl::current()->channel()->AddFilter(filter_.get());
 }
 
 ThreadedDataProvider::~ThreadedDataProvider() {
   DCHECK(ChildThreadImpl::current());
 
   ChildThreadImpl::current()->channel()->RemoveFilter(filter_.get());
 
@@ skipping 181 matching lines @@
     DCHECK(threaded_data_receiver_->needsMainthreadDataCopy());
     DCHECK_EQ((size_t)data_length, data_copy->size());
   }
 
   threaded_data_receiver_->acceptMainthreadDataNotification(
       (data_copy && !data_copy->empty()) ? &data_copy->front() : NULL,
       data_length, encoded_data_length);
 }
 
 }  // namespace content