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

content/common/gpu/gpu_channel_manager_unittest.cc

 // Copyright (c) 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 "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_simple_task_runner.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_messages.h"
@@ skipping 26 matching lines @@
   void Release() { }
   bool Send(Message* msg) override { return channel_->Send(msg); }
 
   virtual void Start() {
     StartThread(&ipc_thread_, base::MessageLoop::TYPE_IO);
     channel_.reset(CreateChannel());
   }
 
   virtual void Shutdown() {
     WaitableEvent ipc_done(false, false);
-    ipc_thread_.message_loop()->PostTask(
+    ipc_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&SimpleWorker::OnShutdown, this, &ipc_done));
 
     channel_.reset();
 
     ipc_done.Wait();
     ipc_thread_.Stop();
   }
 
  protected:
   SyncChannel* CreateChannel() {
     scoped_ptr<SyncChannel> channel = SyncChannel::Create(
-        channel_name_, mode_, this, ipc_thread_.message_loop_proxy().get(),
-        true, &shutdown_event_);
+        channel_name_, mode_, this, ipc_thread_.task_runner().get(), true,
+        &shutdown_event_);
     return channel.release();
   }
 
   void OnShutdown(WaitableEvent* ipc_event) {
     base::RunLoop().RunUntilIdle();
     ipc_event->Signal();
   }
 
   const base::Thread& ipc_thread() const { return ipc_thread_; }
 
@@ skipping 33 matching lines @@
 class SimpleGpuClient : public IPC::SimpleWorker {
  public:
   SimpleGpuClient()
    : IPC::SimpleWorker(IPC::Channel::MODE_CLIENT, "simple_client"),
      router_(this) {
   }
 
   void Start() override {
     IPC::SimpleWorker::Start();
     gpu_channel_manager_.reset(
-        new GpuChannelManager(&router_,
-                              NULL,
-                              ipc_thread().message_loop_proxy().get(),
-                              shutdown_event(),
-                              channel()));
+        new GpuChannelManager(&router_, NULL, ipc_thread().task_runner().get(),
+                              shutdown_event(), channel()));
   }
 
   void Shutdown() override {
     gpu_channel_manager_.reset();
     IPC::SimpleWorker::Shutdown();
   }
 
   GpuChannelManager* gpu_channel_manager() {
     return gpu_channel_manager_.get();
   }
@@ skipping 88 matching lines @@
   const ValueState* state2 =
       pending_value_buffer_state2->GetState(GL_MOUSE_POSITION_CHROMIUM);
   ASSERT_NE(state1, state2);
 
   ASSERT_EQ(state1->int_value[0], value_state1.int_value[0]);
   ASSERT_EQ(state2->int_value[0], value_state2.int_value[0]);
   ASSERT_NE(state1->int_value[0], state2->int_value[0]);
 }
 
 }  // namespace content