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

content/renderer/pepper/pepper_platform_audio_input.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.
 
 #include "content/renderer/pepper/pepper_platform_audio_input.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "build/build_config.h"
@@ skipping 30 matching lines @@
     // PepperPlatformAudioInput::ShutDownOnIOThread().
     audio_input->AddRef();
     return audio_input.get();
   }
   return NULL;
 }
 
 void PepperPlatformAudioInput::StartCapture() {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PepperPlatformAudioInput::StartCaptureOnIOThread, this));
 }
 
 void PepperPlatformAudioInput::StopCapture() {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PepperPlatformAudioInput::StopCaptureOnIOThread, this));
 }
 
 void PepperPlatformAudioInput::ShutDown() {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
   // Make sure we don't call shutdown more than once.
   if (!client_)
     return;
 
   // Called on the main thread to stop all audio callbacks. We must only change
   // the client on the main thread, and the delegates from the I/O thread.
   client_ = NULL;
-  io_message_loop_proxy_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PepperPlatformAudioInput::ShutDownOnIOThread, this));
 }
 
 void PepperPlatformAudioInput::OnStreamCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
     int length,
     int total_segments) {
 #if defined(OS_WIN)
@@ skipping 47 matching lines @@
   // here.
   DCHECK(!ipc_);
   DCHECK(!client_);
   DCHECK(label_.empty());
   DCHECK(!pending_open_device_);
 }
 
 PepperPlatformAudioInput::PepperPlatformAudioInput()
     : client_(NULL),
       main_message_loop_proxy_(base::MessageLoopProxy::current()),
-      io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()),
+      io_task_runner_(ChildProcess::current()->io_task_runner()),
       render_frame_id_(MSG_ROUTING_NONE),
       create_stream_sent_(false),
       pending_open_device_(false),
-      pending_open_device_id_(-1) {}
+      pending_open_device_id_(-1) {
+}
 
 bool PepperPlatformAudioInput::Initialize(
     int render_frame_id,
     const std::string& device_id,
     const GURL& document_url,
     int sample_rate,
     int frames_per_buffer,
     PepperAudioInputHost* client) {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
@@ skipping 25 matching lines @@
       PP_DEVICETYPE_DEV_AUDIOCAPTURE,
       device_id.empty() ? media::AudioManagerBase::kDefaultDeviceId : device_id,
       document_url,
       base::Bind(&PepperPlatformAudioInput::OnDeviceOpened, this));
   pending_open_device_ = true;
 
   return true;
 }
 
 void PepperPlatformAudioInput::InitializeOnIOThread(int session_id) {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (!ipc_)
     return;
 
   // We will be notified by OnStreamCreated().
   create_stream_sent_ = true;
   ipc_->CreateStream(this, session_id, params_, false, 1);
 }
 
 void PepperPlatformAudioInput::StartCaptureOnIOThread() {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (ipc_)
     ipc_->RecordStream();
 }
 
 void PepperPlatformAudioInput::StopCaptureOnIOThread() {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // TODO(yzshen): We cannot re-start capturing if the stream is closed.
   if (ipc_ && create_stream_sent_) {
     ipc_->CloseStream();
   }
   ipc_.reset();
 }
 
 void PepperPlatformAudioInput::ShutDownOnIOThread() {
-  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   StopCaptureOnIOThread();
 
   main_message_loop_proxy_->PostTask(
       FROM_HERE, base::Bind(&PepperPlatformAudioInput::CloseDevice, this));
 
   Release();  // Release for the delegate, balances out the reference taken in
               // PepperPlatformAudioInput::Create.
 }
 
 void PepperPlatformAudioInput::OnDeviceOpened(int request_id,
                                               bool succeeded,
                                               const std::string& label) {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
   pending_open_device_ = false;
   pending_open_device_id_ = -1;
 
   PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
   if (succeeded && device_manager) {
     DCHECK(!label.empty());
     label_ = label;
 
     if (client_) {
       int session_id = device_manager->GetSessionID(
           PP_DEVICETYPE_DEV_AUDIOCAPTURE, label);
-      io_message_loop_proxy_->PostTask(
-          FROM_HERE,
-          base::Bind(&PepperPlatformAudioInput::InitializeOnIOThread,
-                     this,
-                     session_id));
+      io_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&PepperPlatformAudioInput::InitializeOnIOThread,
+                                this, session_id));
     } else {
       // Shutdown has occurred.
       CloseDevice();
     }
   } else {
     NotifyStreamCreationFailed();
   }
 }
 
 void PepperPlatformAudioInput::CloseDevice() {
@@ skipping 24 matching lines @@
 PepperMediaDeviceManager* PepperPlatformAudioInput::GetMediaDeviceManager() {
   DCHECK(main_message_loop_proxy_->BelongsToCurrentThread());
 
   RenderFrameImpl* const render_frame =
       RenderFrameImpl::FromRoutingID(render_frame_id_);
   return render_frame ?
       PepperMediaDeviceManager::GetForRenderFrame(render_frame).get() : NULL;
 }
 
 }  // namespace content