Move media/audio files into media namespace (relanding)

content/browser/renderer_host/media/audio_input_renderer_host.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/browser/renderer_host/media/audio_input_renderer_host.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/process.h"
 #include "base/shared_memory.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/audio_input_sync_writer.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/common/media/audio_messages.h"
 
 using content::BrowserMessageFilter;
 using content::BrowserThread;
 
 AudioInputRendererHost::AudioEntry::AudioEntry()
     : stream_id(0),
       pending_close(false) {
 }
 
 AudioInputRendererHost::AudioEntry::~AudioEntry() {}
 
 AudioInputRendererHost::AudioInputRendererHost(
     content::ResourceContext* resource_context,
-    AudioManager* audio_manager)
+    media::AudioManager* audio_manager)
     : resource_context_(resource_context),
       audio_manager_(audio_manager) {
 }
 
 AudioInputRendererHost::~AudioInputRendererHost() {
   DCHECK(audio_entries_.empty());
 }
 
 void AudioInputRendererHost::OnChannelClosing() {
   BrowserMessageFilter::OnChannelClosing();
@@ skipping 68 matching lines @@
   // mapping shared memory and sharing with the renderer process.
   base::SharedMemoryHandle foreign_memory_handle;
   if (!entry->shared_memory.ShareToProcess(peer_handle(),
                                            &foreign_memory_handle)) {
     // If we failed to map and share the shared memory then close the audio
     // stream and send an error message.
     DeleteEntryOnError(entry);
     return;
   }
 
-  AudioInputSyncWriter* writer =
-      static_cast<AudioInputSyncWriter*>(entry->writer.get());
+  media::AudioInputSyncWriter* writer =
+      static_cast<media::AudioInputSyncWriter*>(entry->writer.get());
 
 #if defined(OS_WIN)
   base::SyncSocket::Handle foreign_socket_handle;
 #else
   base::FileDescriptor foreign_socket_handle;
 #endif
 
   // If we failed to prepare the sync socket for the renderer then we fail
   // the construction of audio input stream.
   if (!writer->PrepareForeignSocketHandle(peer_handle(),
@@ skipping 61 matching lines @@
           resource_context_, audio_manager_)->audio_input_device_manager();
 
   // Add the session entry to the map.
   session_entries_[session_id] = stream_id;
 
   // Start the device with the session_id. If the device is started
   // successfully, OnDeviceStarted() callback will be triggered.
   audio_input_man->Start(session_id, this);
 }
 
-void AudioInputRendererHost::OnCreateStream(int stream_id,
-                                            const AudioParameters& params,
-                                            const std::string& device_id,
-                                            bool automatic_gain_control) {
+void AudioInputRendererHost::OnCreateStream(
+    int stream_id, const media::AudioParameters& params,
+    const std::string& device_id, bool automatic_gain_control) {
   VLOG(1) << "AudioInputRendererHost::OnCreateStream(stream_id="
           << stream_id << ")";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(LookupById(stream_id) == NULL);
 
-  AudioParameters audio_params(params);
+  media::AudioParameters audio_params(params);
 
   DCHECK_GT(audio_params.frames_per_buffer(), 0);
   uint32 buffer_size = audio_params.GetBytesPerBuffer();
 
   // Create a new AudioEntry structure.
   scoped_ptr<AudioEntry> entry(new AudioEntry());
 
-  uint32 mem_size = sizeof(AudioInputBufferParameters) + buffer_size;
+  uint32 mem_size = sizeof(media::AudioInputBufferParameters) + buffer_size;
 
   // Create the shared memory and share it with the renderer process
   // using a new SyncWriter object.
   if (!entry->shared_memory.CreateAndMapAnonymous(mem_size)) {
     // If creation of shared memory failed then send an error message.
     SendErrorMessage(stream_id);
     return;
   }
 
-  scoped_ptr<AudioInputSyncWriter> writer(
-      new AudioInputSyncWriter(&entry->shared_memory));
+  scoped_ptr<media::AudioInputSyncWriter> writer(
+      new media::AudioInputSyncWriter(&entry->shared_memory));
 
   if (!writer->Init()) {
     SendErrorMessage(stream_id);
     return;
   }
 
   // If we have successfully created the SyncWriter then assign it to the
   // entry and construct an AudioInputController.
   // TODO(henrika): replace CreateLowLatency() with Create() as soon
   // as satish has ensured that Speech Input also uses the default low-
@@ skipping 179 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (SessionEntryMap::iterator it = session_entries_.begin();
        it != session_entries_.end(); ++it) {
     if (stream_id == it->second) {
       return it->first;
     }
   }
   return 0;
 }