Move media/audio files into media namespace

content/renderer/media/audio_device.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/media/audio_device.h"
 
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "content/common/child_process.h"
 #include "content/common/media/audio_messages.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_output_controller.h"
 #include "media/audio/audio_util.h"
 
 using media::AudioRendererSink;
 
 // Takes care of invoking the render callback on the audio thread.
 // An instance of this class is created for each capture stream in
 // OnStreamCreated().
 class AudioDevice::AudioThreadCallback
     : public AudioDeviceThread::Callback {
  public:
-  AudioThreadCallback(const AudioParameters& audio_parameters,
+  AudioThreadCallback(const media::AudioParameters& audio_parameters,
                       base::SharedMemoryHandle memory,
                       int memory_length,
                       AudioRendererSink::RenderCallback* render_callback);
   virtual ~AudioThreadCallback();
 
   virtual void MapSharedMemory() OVERRIDE;
 
   // Called whenever we receive notifications about pending data.
   virtual void Process(int pending_data) OVERRIDE;
 
  private:
   AudioRendererSink::RenderCallback* render_callback_;
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
 AudioDevice::AudioDevice()
     : ScopedLoopObserver(ChildProcess::current()->io_message_loop()),
       callback_(NULL),
       volume_(1.0),
       stream_id_(0),
       play_on_start_(true),
       is_started_(false) {
   filter_ = RenderThreadImpl::current()->audio_message_filter();
 }
 
-AudioDevice::AudioDevice(const AudioParameters& params,
+AudioDevice::AudioDevice(const media::AudioParameters& params,
                          RenderCallback* callback)
     : ScopedLoopObserver(ChildProcess::current()->io_message_loop()),
       audio_parameters_(params),
       callback_(callback),
       volume_(1.0),
       stream_id_(0),
       play_on_start_(true),
       is_started_(false) {
   filter_ = RenderThreadImpl::current()->audio_message_filter();
 }
 
-void AudioDevice::Initialize(const AudioParameters& params,
+void AudioDevice::Initialize(const media::AudioParameters& params,
                              RenderCallback* callback) {
   CHECK_EQ(0, stream_id_) <<
       "AudioDevice::Initialize() must be called before Start()";
 
   CHECK(!callback_);  // Calling Initialize() twice?
 
   audio_parameters_ = params;
   callback_ = callback;
 }
 
@@ skipping 41 matching lines @@
   volume_ = volume;
 
   return true;
 }
 
 void AudioDevice::GetVolume(double* volume) {
   // Return a locally cached version of the current scaling factor.
   *volume = volume_;
 }
 
-void AudioDevice::InitializeOnIOThread(const AudioParameters& params) {
+void AudioDevice::InitializeOnIOThread(const media::AudioParameters& params) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   // Make sure we don't create the stream more than once.
   DCHECK_EQ(0, stream_id_);
   if (stream_id_)
     return;
 
   stream_id_ = filter_->AddDelegate(this);
   Send(new AudioHostMsg_CreateStream(stream_id_, params));
 }
 
@@ skipping 111 matching lines @@
 }
 
 void AudioDevice::WillDestroyCurrentMessageLoop() {
   LOG(ERROR) << "IO loop going away before the audio device has been stopped";
   ShutDownOnIOThread();
 }
 
 // AudioDevice::AudioThreadCallback
 
 AudioDevice::AudioThreadCallback::AudioThreadCallback(
-    const AudioParameters& audio_parameters,
+    const media::AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
     media::AudioRendererSink::RenderCallback* render_callback)
     : AudioDeviceThread::Callback(audio_parameters, memory, memory_length),
       render_callback_(render_callback) {
 }
 
 AudioDevice::AudioThreadCallback::~AudioThreadCallback() {
 }
 
@@ skipping 24 matching lines @@
   // to the browser process as float, so we don't lose precision for
   // audio hardware which has better than 16bit precision.
   int16* data = reinterpret_cast<int16*>(shared_memory_.memory());
   media::InterleaveFloatToInt16(audio_data_, data,
       audio_parameters_.frames_per_buffer());
 
   // Let the host know we are done.
   media::SetActualDataSizeInBytes(&shared_memory_, memory_length_,
       num_frames * audio_parameters_.channels() * sizeof(data[0]));
 }