Renamed AudioController to AudioOutputController.

This is in preparation to add an AudioInputController for audio recording in subsequent changes.
BUG=none
TEST=no functional change

Review URL: http://codereview.chromium.org/2964005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@52015 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 57 insertions, 52 deletions

diff --git a/chrome/browser/renderer_host/audio_renderer_host.cc b/chrome/browser/renderer_host/audio_renderer_host.cc
index b714723..80be2a9 100644
--- a/chrome/browser/renderer_host/audio_renderer_host.cc
+++ b/chrome/browser/renderer_host/audio_renderer_host.cc
@@ -118,29 +118,29 @@ void AudioRendererHost::IPCChannelClosing() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// media::AudioController::EventHandler implementations.
-void AudioRendererHost::OnCreated(media::AudioController* controller) {
+// media::AudioOutputController::EventHandler implementations.
+void AudioRendererHost::OnCreated(media::AudioOutputController* controller) {
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(this, &AudioRendererHost::DoCompleteCreation,
                         controller));
 }
 
-void AudioRendererHost::OnPlaying(media::AudioController* controller) {
+void AudioRendererHost::OnPlaying(media::AudioOutputController* controller) {
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(this, &AudioRendererHost::DoSendPlayingMessage,
                         controller));
 }
 
-void AudioRendererHost::OnPaused(media::AudioController* controller) {
+void AudioRendererHost::OnPaused(media::AudioOutputController* controller) {
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(this, &AudioRendererHost::DoSendPausedMessage,
                         controller));
 }
 
-void AudioRendererHost::OnError(media::AudioController* controller,
+void AudioRendererHost::OnError(media::AudioOutputController* controller,
                                 int error_code) {
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
@@ -148,7 +148,7 @@ void AudioRendererHost::OnError(media::AudioController* controller,
                         controller, error_code));
 }
 
-void AudioRendererHost::OnMoreData(media::AudioController* controller,
+void AudioRendererHost::OnMoreData(media::AudioOutputController* controller,
                                    base::Time timestamp,
                                    uint32 pending_bytes) {
   ChromeThread::PostTask(
@@ -157,7 +157,8 @@ void AudioRendererHost::OnMoreData(media::AudioController* controller,
                         controller, timestamp, pending_bytes));
 }
 
-void AudioRendererHost::DoCompleteCreation(media::AudioController* controller) {
+void AudioRendererHost::DoCompleteCreation(
+    media::AudioOutputController* controller) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   AudioEntry* entry = LookupByController(controller);
@@ -213,7 +214,7 @@ void AudioRendererHost::DoCompleteCreation(media::AudioController* controller) {
 }
 
 void AudioRendererHost::DoSendPlayingMessage(
-    media::AudioController* controller) {
+    media::AudioOutputController* controller) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   AudioEntry* entry = LookupByController(controller);
@@ -227,7 +228,7 @@ void AudioRendererHost::DoSendPlayingMessage(
 }
 
 void AudioRendererHost::DoSendPausedMessage(
-    media::AudioController* controller) {
+    media::AudioOutputController* controller) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   AudioEntry* entry = LookupByController(controller);
@@ -240,9 +241,10 @@ void AudioRendererHost::DoSendPausedMessage(
       entry->render_view_id, entry->stream_id, params));
 }
 
-void AudioRendererHost::DoRequestMoreData(media::AudioController* controller,
-                                          base::Time timestamp,
-                                          uint32 pending_bytes) {
+void AudioRendererHost::DoRequestMoreData(
+    media::AudioOutputController* controller,
+    base::Time timestamp,
+    uint32 pending_bytes) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   // If we already have a pending request then return.
@@ -260,7 +262,7 @@ void AudioRendererHost::DoRequestMoreData(media::AudioController* controller,
           timestamp.ToInternalValue()));
 }
 
-void AudioRendererHost::DoHandleError(media::AudioController* controller,
+void AudioRendererHost::DoHandleError(media::AudioOutputController* controller,
                                       int error_code) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
@@ -335,7 +337,7 @@ void AudioRendererHost::OnCreateStream(
   }
 
   scoped_ptr<AudioEntry> entry(new AudioEntry());
-  scoped_refptr<media::AudioController> controller = NULL;
+  scoped_refptr<media::AudioOutputController> controller = NULL;
   if (low_latency) {
     // If this is the low latency mode, we need to construct a SyncReader first.
     scoped_ptr<AudioSyncReader> reader(
@@ -348,10 +350,10 @@ void AudioRendererHost::OnCreateStream(
     }
 
     // If we have successfully created the SyncReader then assign it to the
-    // entry and construct an AudioController.
+    // entry and construct an AudioOutputController.
     entry->reader.reset(reader.release());
     controller =
-        media::AudioController::CreateLowLatency(
+        media::AudioOutputController::CreateLowLatency(
             this, params.format, params.channels,
             params.sample_rate,
             params.bits_per_sample,
@@ -360,11 +362,12 @@ void AudioRendererHost::OnCreateStream(
   } else {
     // The choice of buffer capacity is based on experiment.
     controller =
-        media::AudioController::Create(this, params.format, params.channels,
-                                       params.sample_rate,
-                                       params.bits_per_sample,
-                                       hardware_packet_size,
-                                       3 * hardware_packet_size);
+        media::AudioOutputController::Create(this, params.format,
+                                             params.channels,
+                                             params.sample_rate,
+                                             params.bits_per_sample,
+                                             hardware_packet_size,
+                                             3 * hardware_packet_size);
   }
 
   if (!controller) {
@@ -485,7 +488,7 @@ void AudioRendererHost::OnNotifyPacketReady(
   if (!packet_size)
     return;
 
-  // Enqueue the data to media::AudioController.
+  // Enqueue the data to media::AudioOutputController.
   entry->controller->EnqueueData(
       reinterpret_cast<uint8*>(entry->shared_memory.memory()),
       packet_size);
@@ -564,7 +567,7 @@ AudioRendererHost::AudioEntry* AudioRendererHost::LookupById(
 }
 
 AudioRendererHost::AudioEntry* AudioRendererHost::LookupByController(
-    media::AudioController* controller) {
+    media::AudioOutputController* controller) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   // Iterate the map of entries.
diff --git a/chrome/browser/renderer_host/audio_renderer_host.h b/chrome/browser/renderer_host/audio_renderer_host.h
index 32da12b..b9ee30f 100644
--- a/chrome/browser/renderer_host/audio_renderer_host.h
+++ b/chrome/browser/renderer_host/audio_renderer_host.h
@@ -68,8 +68,8 @@
 #include "base/waitable_event.h"
 #include "chrome/browser/chrome_thread.h"
 #include "ipc/ipc_message.h"
-#include "media/audio/audio_controller.h"
 #include "media/audio/audio_output.h"
+#include "media/audio/audio_output_controller.h"
 #include "media/audio/simple_sources.h"
 
 class AudioManager;
@@ -78,7 +78,7 @@ struct ViewHostMsg_Audio_CreateStream_Params;
 class AudioRendererHost : public base::RefCountedThreadSafe<
                               AudioRendererHost,
                               ChromeThread::DeleteOnIOThread>,
-                          public media::AudioController::EventHandler {
+                          public media::AudioOutputController::EventHandler {
  public:
   typedef std::pair<int32, int> AudioEntryId;
 
@@ -89,8 +89,8 @@ class AudioRendererHost : public base::RefCountedThreadSafe<
           pending_buffer_request(false) {
     }
 
-    // The AudioController that manages the audio stream.
-    scoped_refptr<media::AudioController> controller;
+    // The AudioOutputController that manages the audio stream.
+    scoped_refptr<media::AudioOutputController> controller;
 
     // Render view ID that requested the audio stream.
     int32 render_view_id;
@@ -103,7 +103,7 @@ class AudioRendererHost : public base::RefCountedThreadSafe<
 
     // The synchronous reader to be used by the controller. We have the
     // ownership of the reader.
-    scoped_ptr<media::AudioController::SyncReader> reader;
+    scoped_ptr<media::AudioOutputController::SyncReader> reader;
 
     bool pending_buffer_request;
   };
@@ -133,12 +133,13 @@ class AudioRendererHost : public base::RefCountedThreadSafe<
   bool OnMessageReceived(const IPC::Message& message, bool* message_was_ok);
 
   /////////////////////////////////////////////////////////////////////////////
-  // AudioController::EventHandler implementations.
-  virtual void OnCreated(media::AudioController* controller);
-  virtual void OnPlaying(media::AudioController* controller);
-  virtual void OnPaused(media::AudioController* controller);
-  virtual void OnError(media::AudioController* controller, int error_code);
-  virtual void OnMoreData(media::AudioController* controller,
+  // AudioOutputController::EventHandler implementations.
+  virtual void OnCreated(media::AudioOutputController* controller);
+  virtual void OnPlaying(media::AudioOutputController* controller);
+  virtual void OnPaused(media::AudioOutputController* controller);
+  virtual void OnError(media::AudioOutputController* controller,
+                       int error_code);
+  virtual void OnMoreData(media::AudioOutputController* controller,
                           base::Time timestamp,
                           uint32 pending_bytes);
 
@@ -193,20 +194,20 @@ class AudioRendererHost : public base::RefCountedThreadSafe<
 
   // Complete the process of creating an audio stream. This will set up the
   // shared memory or shared socket in low latency mode.
-  void DoCompleteCreation(media::AudioController* controller);
+  void DoCompleteCreation(media::AudioOutputController* controller);
 
   // Send a state change message to the renderer.
-  void DoSendPlayingMessage(media::AudioController* controller);
-  void DoSendPausedMessage(media::AudioController* controller);
+  void DoSendPlayingMessage(media::AudioOutputController* controller);
+  void DoSendPausedMessage(media::AudioOutputController* controller);
 
   // Request more data from the renderer. This method is used only in normal
   // latency mode.
-  void DoRequestMoreData(media::AudioController* controller,
+  void DoRequestMoreData(media::AudioOutputController* controller,
                          base::Time timestamp,
                          uint32 pending_bytes);
 
   // Handle error coming from audio stream.
-  void DoHandleError(media::AudioController* controller, int error_code);
+  void DoHandleError(media::AudioOutputController* controller, int error_code);
 
   // A helper method to send an IPC message to renderer process on IO thread.
   // This method is virtual for testing purpose.
@@ -232,7 +233,7 @@ class AudioRendererHost : public base::RefCountedThreadSafe<
   // Search for a AudioEntry having the reference to |controller|.
   // This method is used to look up an AudioEntry after a controller
   // event is received.
-  AudioEntry* LookupByController(media::AudioController* controller);
+  AudioEntry* LookupByController(media::AudioOutputController* controller);
 
   int process_id_;
   base::ProcessHandle process_handle_;
diff --git a/chrome/browser/renderer_host/audio_renderer_host_unittest.cc b/chrome/browser/renderer_host/audio_renderer_host_unittest.cc
index 6d8f96a..0af6cd2 100644
--- a/chrome/browser/renderer_host/audio_renderer_host_unittest.cc
+++ b/chrome/browser/renderer_host/audio_renderer_host_unittest.cc
@@ -301,12 +301,12 @@ class AudioRendererHostTest : public testing::Test {
   }
 
   void SimulateError() {
-    // Find the first AudioController in the AudioRendererHost.
+    // Find the first AudioOutputController in the AudioRendererHost.
     CHECK(host_->audio_entries_.size())
         << "Calls Create() before calling this method";
-    media::AudioController* controller =
+    media::AudioOutputController* controller =
         host_->audio_entries_.begin()->second->controller;
-    CHECK(controller) << "AudioController not found";
+    CHECK(controller) << "AudioOutputController not found";
 
     // Expect an error signal sent through IPC.
     EXPECT_CALL(*host_, OnStreamError(kRouteId, kStreamId))
@@ -422,8 +422,8 @@ TEST_F(AudioRendererHostTest, DataConversationRealStream) {
   Play();
 
   // If this is a real audio device, the data conversation is not limited
-  // to the buffer capacity of AudioController. So we do 5 exchanges before
-  // we close the device.
+  // to the buffer capacity of AudioOutputController. So we do 5 exchanges
+  // before we close the device.
   for (int i = 0; i < 5; ++i) {
     NotifyPacketReady();
   }
diff --git a/chrome/browser/renderer_host/audio_sync_reader.cc b/chrome/browser/renderer_host/audio_sync_reader.cc
index 48787e7..f664d19 100644
--- a/chrome/browser/renderer_host/audio_sync_reader.cc
+++ b/chrome/browser/renderer_host/audio_sync_reader.cc
@@ -14,7 +14,7 @@ AudioSyncReader::AudioSyncReader(base::SharedMemory* shared_memory)
 AudioSyncReader::~AudioSyncReader() {
 }
 
-// media::AudioController::SyncReader implementations.
+// media::AudioOutputController::SyncReader implementations.
 void AudioSyncReader::UpdatePendingBytes(uint32 bytes) {
   socket_->Send(&bytes, sizeof(bytes));
 }
diff --git a/chrome/browser/renderer_host/audio_sync_reader.h b/chrome/browser/renderer_host/audio_sync_reader.h
index 87783cd..490115c 100644
--- a/chrome/browser/renderer_host/audio_sync_reader.h
+++ b/chrome/browser/renderer_host/audio_sync_reader.h
@@ -8,7 +8,7 @@
 #include "base/file_descriptor_posix.h"
 #include "base/process.h"
 #include "base/sync_socket.h"
-#include "media/audio/audio_controller.h"
+#include "media/audio/audio_output_controller.h"
 
 namespace base {
 
@@ -16,16 +16,17 @@ class SharedMemory;
 
 }
 
-// A AudioController::SyncReader implementation using SyncSocket. This is used
-// by AudioController to provide a low latency data source for transmitting
-// audio packets between the browser process and the renderer process.
-class AudioSyncReader : public media::AudioController::SyncReader {
+// A AudioOutputController::SyncReader implementation using SyncSocket. This
+// is used by AudioOutputController to provide a low latency data source for
+// transmitting audio packets between the browser process and the renderer
+// process.
+class AudioSyncReader : public media::AudioOutputController::SyncReader {
  public:
   explicit AudioSyncReader(base::SharedMemory* shared_memory);
 
   virtual ~AudioSyncReader();
 
-  // media::AudioController::SyncReader implementations.
+  // media::AudioOutputController::SyncReader implementations.
   virtual void UpdatePendingBytes(uint32 bytes);
   virtual uint32 Read(void* data, uint32 size);
   virtual void Close();