Replace MessageLoopProxy with SingleThreadTaskRunner for the rest of media/.

media/audio/audio_manager_base.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 "media/audio/audio_manager_base.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_output_resampler.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "media/base/media_switches.h"
 
 namespace media {
@@ skipping 71 matching lines @@
   audio_thread_.init_com_with_mta(true);
 #elif defined(OS_MACOSX)
   // CoreAudio calls must occur on the main thread of the process, which in our
   // case is sadly the browser UI thread.  Failure to execute calls on the right
   // thread leads to crashes and odd behavior.  See http://crbug.com/158170.
   // TODO(dalecurtis): We should require the message loop to be passed in.
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   if (!cmd_line->HasSwitch(switches::kDisableMainThreadAudio) &&
       base::MessageLoopProxy::current().get() &&
       base::MessageLoop::current()->IsType(base::MessageLoop::TYPE_UI)) {
-    message_loop_ = base::MessageLoopProxy::current();
+    task_runner_ = base::MessageLoopProxy::current();
     return;
   }
 #endif
 
   CHECK(audio_thread_.Start());
-  message_loop_ = audio_thread_.message_loop_proxy();
+  task_runner_ = audio_thread_.message_loop_proxy();
 }
 
 AudioManagerBase::~AudioManagerBase() {
   // The platform specific AudioManager implementation must have already
   // stopped the audio thread. Otherwise, we may destroy audio streams before
   // stopping the thread, resulting an unexpected behavior.
   // This way we make sure activities of the audio streams are all stopped
   // before we destroy them.
   CHECK(!audio_thread_.IsRunning());
   // All the output streams should have been deleted.
   DCHECK_EQ(0, num_output_streams_);
   // All the input streams should have been deleted.
   DCHECK_EQ(0, num_input_streams_);
 }
 
 base::string16 AudioManagerBase::GetAudioInputDeviceModel() {
   return base::string16();
 }
 
-scoped_refptr<base::MessageLoopProxy> AudioManagerBase::GetMessageLoop() {
-  return message_loop_;
+scoped_refptr<base::SingleThreadTaskRunner> AudioManagerBase::GetTaskRunner() {
+  return task_runner_;
 }
 
-scoped_refptr<base::MessageLoopProxy> AudioManagerBase::GetWorkerLoop() {
+scoped_refptr<base::SingleThreadTaskRunner>
+AudioManagerBase::GetWorkerTaskRunner() {
   // Lazily start the worker thread.
   if (!audio_thread_.IsRunning())
     CHECK(audio_thread_.Start());
 
   return audio_thread_.message_loop_proxy();
 }
 
 AudioOutputStream* AudioManagerBase::MakeAudioOutputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const std::string& input_device_id) {
   // TODO(miu): Fix ~50 call points across several unit test modules to call
   // this method on the audio thread, then uncomment the following:
-  // DCHECK(message_loop_->BelongsToCurrentThread());
+  // DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!params.IsValid()) {
     DLOG(ERROR) << "Audio parameters are invalid";
     return NULL;
   }
 
   // Limit the number of audio streams opened. This is to prevent using
   // excessive resources for a large number of audio streams. More
   // importantly it prevents instability on certain systems.
   // See bug: http://crbug.com/30242.
@@ skipping 28 matching lines @@
   }
 
   return stream;
 }
 
 AudioInputStream* AudioManagerBase::MakeAudioInputStream(
     const AudioParameters& params,
     const std::string& device_id) {
   // TODO(miu): Fix ~20 call points across several unit test modules to call
   // this method on the audio thread, then uncomment the following:
-  // DCHECK(message_loop_->BelongsToCurrentThread());
+  // DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!params.IsValid() || (params.channels() > kMaxInputChannels) ||
       device_id.empty()) {
     DLOG(ERROR) << "Audio parameters are invalid for device " << device_id;
     return NULL;
   }
 
   if (num_input_streams_ >= max_num_input_streams_) {
     DLOG(ERROR) << "Number of opened input audio streams "
                 << num_input_streams_
@@ skipping 21 matching lines @@
     ++num_input_streams_;
   }
 
   return stream;
 }
 
 AudioOutputStream* AudioManagerBase::MakeAudioOutputStreamProxy(
     const AudioParameters& params,
     const std::string& device_id,
     const std::string& input_device_id) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
 
   // If the caller supplied an empty device id to select the default device,
   // we fetch the actual device id of the default device so that the lookup
   // will find the correct device regardless of whether it was opened as
   // "default" or via the specific id.
   // NOTE: Implementations that don't yet support opening non-default output
   // devices may return an empty string from GetDefaultOutputDeviceID().
   std::string output_device_id = device_id.empty() ?
       GetDefaultOutputDeviceID() : device_id;
 
@@ skipping 77 matching lines @@
 void AudioManagerBase::ReleaseInputStream(AudioInputStream* stream) {
   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioInputStream.
   --num_input_streams_;
   delete stream;
 }
 
 void AudioManagerBase::Shutdown() {
   // Only true when we're sharing the UI message loop with the browser.  The UI
   // loop is no longer running at this time and browser destruction is imminent.
-  if (message_loop_->BelongsToCurrentThread()) {
+  if (task_runner_->BelongsToCurrentThread()) {
     ShutdownOnAudioThread();
   } else {
-    message_loop_->PostTask(FROM_HERE, base::Bind(
+    task_runner_->PostTask(FROM_HERE, base::Bind(
         &AudioManagerBase::ShutdownOnAudioThread, base::Unretained(this)));
   }
 
   // Stop() will wait for any posted messages to be processed first.
   audio_thread_.Stop();
 }
 
 void AudioManagerBase::ShutdownOnAudioThread() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
 
   AudioOutputDispatchers::iterator it = output_dispatchers_.begin();
   for (; it != output_dispatchers_.end(); ++it) {
     scoped_refptr<AudioOutputDispatcher>& dispatcher = (*it)->dispatcher;
     dispatcher->Shutdown();
 
     // All AudioOutputProxies must have been freed before Shutdown is called.
     // If they still exist, things will go bad.  They have direct pointers to
     // both physical audio stream objects that belong to the dispatcher as
     // well as the message loop of the audio thread that will soon go away.
     // So, better crash now than later.
     DCHECK(dispatcher->HasOneRef()) << "AudioOutputProxies are still alive";
     dispatcher = NULL;
   }
 
   output_dispatchers_.clear();
 }
 
 void AudioManagerBase::AddOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   output_listeners_.AddObserver(listener);
 }
 
 void AudioManagerBase::RemoveOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   output_listeners_.RemoveObserver(listener);
 }
 
 void AudioManagerBase::NotifyAllOutputDeviceChangeListeners() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "Firing OnDeviceChange() notifications.";
   FOR_EACH_OBSERVER(AudioDeviceListener, output_listeners_, OnDeviceChange());
 }
 
 AudioParameters AudioManagerBase::GetDefaultOutputStreamParameters() {
   return GetPreferredOutputStreamParameters(GetDefaultOutputDeviceID(),
       AudioParameters());
 }
 
 AudioParameters AudioManagerBase::GetOutputStreamParameters(
@@ skipping 28 matching lines @@
 
   return 0;
 }
 
 scoped_ptr<AudioLog> AudioManagerBase::CreateAudioLog(
     AudioLogFactory::AudioComponent component) {
   return audio_log_factory_->CreateAudioLog(component);
 }
 
 void AudioManagerBase::FixWedgedAudio() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
 #if defined(OS_MACOSX)
   // Through trial and error, we've found that one way to restore audio after a
   // hang is to close all outstanding audio streams.  Once all streams have been
   // closed, new streams appear to work correctly.
   //
   // In Chrome terms, this means we need to ask all AudioOutputDispatchers to
   // close all Open()'d streams.  Once all streams across all dispatchers have
   // been closed, we ask for all previously Start()'d streams to be recreated
   // using the same AudioSourceCallback they had before.
   //
   // Since this operation takes place on the audio thread we can be sure that no
   // other state-changing stream operations will take place while the fix is in
   // progress.
   //
   // See http://crbug.com/160920 for additional details.
   for (AudioOutputDispatchers::iterator it = output_dispatchers_.begin();
        it != output_dispatchers_.end(); ++it) {
     (*it)->dispatcher->CloseStreamsForWedgeFix();
   }
   for (AudioOutputDispatchers::iterator it = output_dispatchers_.begin();
        it != output_dispatchers_.end(); ++it) {
     (*it)->dispatcher->RestartStreamsForWedgeFix();
   }
 #endif
 }
 
 }  // namespace media