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

content/common/gpu/gpu_channel.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
 #include <queue>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_factory.h"
@@ skipping 41 matching lines @@
 // - it handles the GpuCommandBufferMsg_InsertSyncPoint message on the IO
 //   thread, generating the sync point ID and responding immediately, and then
 //   posting a task to insert the GpuCommandBufferMsg_RetireSyncPoint message
 //   into the channel's queue.
 // - it generates mailbox names for clients of the GPU process on the IO thread.
 class GpuChannelMessageFilter : public IPC::MessageFilter {
  public:
   GpuChannelMessageFilter(
       base::WeakPtr<GpuChannel> gpu_channel,
       scoped_refptr<gpu::SyncPointManager> sync_point_manager,
-      scoped_refptr<base::MessageLoopProxy> message_loop,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       bool future_sync_points)
       : preemption_state_(IDLE),
         gpu_channel_(gpu_channel),
         sender_(NULL),
         sync_point_manager_(sync_point_manager),
-        message_loop_(message_loop),
+        task_runner_(task_runner),
         messages_forwarded_to_channel_(0),
         a_stub_is_descheduled_(false),
         future_sync_points_(future_sync_points) {}
 
   void OnFilterAdded(IPC::Sender* sender) override {
     DCHECK(!sender_);
     sender_ = sender;
   }
 
   void OnFilterRemoved() override {
@@ skipping 23 matching lines @@
       }
       if (!future_sync_points_ && !get<0>(retire)) {
         LOG(ERROR) << "Untrusted contexts can't create future sync points";
         reply->set_reply_error();
         Send(reply);
         return true;
       }
       uint32 sync_point = sync_point_manager_->GenerateSyncPoint();
       GpuCommandBufferMsg_InsertSyncPoint::WriteReplyParams(reply, sync_point);
       Send(reply);
-      message_loop_->PostTask(
+      task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&GpuChannelMessageFilter::InsertSyncPointOnMainThread,
-                     gpu_channel_,
-                     sync_point_manager_,
-                     message.routing_id(),
-                     get<0>(retire),
-                     sync_point));
+                     gpu_channel_, sync_point_manager_, message.routing_id(),
+                     get<0>(retire), sync_point));
       handled = true;
     }
 
     // All other messages get processed by the GpuChannel.
     messages_forwarded_to_channel_++;
     if (preempting_flag_.get())
       pending_messages_.push(PendingMessage(messages_forwarded_to_channel_));
     UpdatePreemptionState();
 
     return handled;
@@ skipping 228 matching lines @@
       }
     }
     manager->RetireSyncPoint(sync_point);
   }
 
   // NOTE: this weak pointer is never dereferenced on the IO thread, it's only
   // passed through - therefore the WeakPtr assumptions are respected.
   base::WeakPtr<GpuChannel> gpu_channel_;
   IPC::Sender* sender_;
   scoped_refptr<gpu::SyncPointManager> sync_point_manager_;
-  scoped_refptr<base::MessageLoopProxy> message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
 
   std::queue<PendingMessage> pending_messages_;
 
   // Count of the number of IPCs forwarded to the GpuChannel.
   uint64 messages_forwarded_to_channel_;
 
   base::OneShotTimer<GpuChannelMessageFilter> timer_;
 
   bool a_stub_is_descheduled_;
@@ skipping 33 matching lines @@
   subscription_ref_set_->AddObserver(this);
 }
 
 GpuChannel::~GpuChannel() {
   STLDeleteElements(&deferred_messages_);
   subscription_ref_set_->RemoveObserver(this);
   if (preempting_flag_.get())
     preempting_flag_->Reset();
 }
 
-void GpuChannel::Init(base::MessageLoopProxy* io_message_loop,
+void GpuChannel::Init(base::SingleThreadTaskRunner* io_task_runner,
                       base::WaitableEvent* shutdown_event) {
   DCHECK(!channel_.get());
 
   // Map renderer ID to a (single) channel to that process.
-  channel_ = IPC::SyncChannel::Create(channel_id_,
-                                      IPC::Channel::MODE_SERVER,
-                                      this,
-                                      io_message_loop,
-                                      false,
-                                      shutdown_event);
+  channel_ =
+      IPC::SyncChannel::Create(channel_id_, IPC::Channel::MODE_SERVER, this,
+                               io_task_runner, false, shutdown_event);
 
-  filter_ =
-      new GpuChannelMessageFilter(weak_factory_.GetWeakPtr(),
-                                  gpu_channel_manager_->sync_point_manager(),
-                                  base::MessageLoopProxy::current(),
-                                  allow_future_sync_points_);
-  io_message_loop_ = io_message_loop;
+  filter_ = new GpuChannelMessageFilter(
+      weak_factory_.GetWeakPtr(), gpu_channel_manager_->sync_point_manager(),
+      base::ThreadTaskRunnerHandle::Get(), allow_future_sync_points_);
+  io_task_runner_ = io_task_runner;
   channel_->AddFilter(filter_.get());
   pending_valuebuffer_state_ = new gpu::ValueStateMap();
 }
 
 std::string GpuChannel::GetChannelName() {
   return channel_id_;
 }
 
 #if defined(OS_POSIX)
 base::ScopedFD GpuChannel::TakeRendererFileDescriptor() {
@@ skipping 65 matching lines @@
 }
 
 void GpuChannel::OnScheduled() {
   if (handle_messages_scheduled_)
     return;
   // Post a task to handle any deferred messages. The deferred message queue is
   // not emptied here, which ensures that OnMessageReceived will continue to
   // defer newly received messages until the ones in the queue have all been
   // handled by HandleMessage. HandleMessage is invoked as a
   // task to prevent reentrancy.
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&GpuChannel::HandleMessage, weak_factory_.GetWeakPtr()));
   handle_messages_scheduled_ = true;
 }
 
 void GpuChannel::StubSchedulingChanged(bool scheduled) {
   bool a_stub_was_descheduled = num_stubs_descheduled_ > 0;
   if (scheduled) {
     num_stubs_descheduled_--;
     OnScheduled();
   } else {
     num_stubs_descheduled_++;
   }
   DCHECK_LE(num_stubs_descheduled_, stubs_.size());
   bool a_stub_is_descheduled = num_stubs_descheduled_ > 0;
 
   if (a_stub_is_descheduled != a_stub_was_descheduled) {
     if (preempting_flag_.get()) {
-      io_message_loop_->PostTask(
+      io_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&GpuChannelMessageFilter::UpdateStubSchedulingState,
-                     filter_,
-                     a_stub_is_descheduled));
+                     filter_, a_stub_is_descheduled));
     }
   }
 }
 
 CreateCommandBufferResult GpuChannel::CreateViewCommandBuffer(
     const gfx::GLSurfaceHandle& window,
     int32 surface_id,
     const GPUCreateCommandBufferConfig& init_params,
     int32 route_id) {
   TRACE_EVENT1("gpu",
@@ skipping 58 matching lines @@
   return router_.AddRoute(route_id, listener);
 }
 
 void GpuChannel::RemoveRoute(int32 route_id) {
   router_.RemoveRoute(route_id);
 }
 
 gpu::PreemptionFlag* GpuChannel::GetPreemptionFlag() {
   if (!preempting_flag_.get()) {
     preempting_flag_ = new gpu::PreemptionFlag;
-    io_message_loop_->PostTask(
-        FROM_HERE, base::Bind(
+    io_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(
             &GpuChannelMessageFilter::SetPreemptingFlagAndSchedulingState,
             filter_, preempting_flag_, num_stubs_descheduled_ > 0));
   }
   return preempting_flag_.get();
 }
 
 void GpuChannel::SetPreemptByFlag(
     scoped_refptr<gpu::PreemptionFlag> preempted_flag) {
   preempted_flag_ = preempted_flag;
 
@@ skipping 132 matching lines @@
   // stub, we need to make sure to reschedule the GpuChannel here.
   if (need_reschedule) {
     // This stub won't get a chance to reschedule, so update the count now.
     StubSchedulingChanged(true);
   }
 }
 
 void GpuChannel::MessageProcessed() {
   messages_processed_++;
   if (preempting_flag_.get()) {
-    io_message_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&GpuChannelMessageFilter::MessageProcessed,
-                   filter_,
-                   messages_processed_));
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&GpuChannelMessageFilter::MessageProcessed,
+                              filter_, messages_processed_));
   }
 }
 
 void GpuChannel::CacheShader(const std::string& key,
                              const std::string& shader) {
   gpu_channel_manager_->Send(
       new GpuHostMsg_CacheShader(client_id_, key, shader));
 }
 
 void GpuChannel::AddFilter(IPC::MessageFilter* filter) {
@@ skipping 42 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content