Move content\browser\renderer_host\media to content namespace.

content/browser/renderer_host/media/audio_input_device_manager.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_device_manager.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager_event_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/media_stream_request.h"
 #include "media/audio/audio_device_name.h"
 #include "media/audio/audio_input_ipc.h"
 #include "media/audio/audio_manager_base.h"
 
-using content::BrowserThread;
-
-namespace media_stream {
+namespace content {
 
 const int AudioInputDeviceManager::kFakeOpenSessionId = 1;
 
 namespace {
 // Starting id for the first capture session.
 const int kFirstSessionId = AudioInputDeviceManager::kFakeOpenSessionId + 1;
 }
 
 AudioInputDeviceManager::AudioInputDeviceManager(
     media::AudioManager* audio_manager)
@@ skipping 100 matching lines @@
   // BrowserMainloop.
   media::AudioDeviceNames device_names;
   audio_manager_->GetAudioInputDeviceNames(&device_names);
 
   StreamDeviceInfoArray* devices = new StreamDeviceInfoArray;
   for (media::AudioDeviceNames::iterator it = device_names.begin();
        it != device_names.end();
        ++it) {
     // NOTE: Only support enumeration of the MEDIA_DEVICE_AUDIO_CAPTURE type.
     devices->push_back(StreamDeviceInfo(
-        content::MEDIA_DEVICE_AUDIO_CAPTURE, it->device_name,
+        MEDIA_DEVICE_AUDIO_CAPTURE, it->device_name,
         it->unique_id, false));
   }
 
   // Return the device list through the listener by posting a task on
   // IO thread since MediaStreamManager handles the callback asynchronously.
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&AudioInputDeviceManager::DevicesEnumeratedOnIOThread,
                  this,
@@ skipping 18 matching lines @@
                                      this,
                                      device.stream_type, session_id));
 }
 
 void AudioInputDeviceManager::CloseOnDeviceThread(int session_id) {
   DCHECK(IsOnDeviceThread());
 
   StreamDeviceMap::iterator it = devices_.find(session_id);
   if (it == devices_.end())
     return;
-  const content::MediaStreamDeviceType stream_type = it->second.stream_type;
+  const MediaStreamDeviceType stream_type = it->second.stream_type;
   devices_.erase(it);
 
   // Post a callback through the listener on IO thread since
   // MediaStreamManager handles the callback asynchronously.
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&AudioInputDeviceManager::ClosedOnIOThread,
                                      this,
                                      stream_type, session_id));
 }
 
 void AudioInputDeviceManager::DevicesEnumeratedOnIOThread(
     StreamDeviceInfoArray* devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Ensure that |devices| gets deleted on exit.
   scoped_ptr<StreamDeviceInfoArray> devices_array(devices);
   if (listener_) {
     // NOTE: Only support enumeration of the MEDIA_DEVICE_AUDIO_CAPTURE type.
-    listener_->DevicesEnumerated(content::MEDIA_DEVICE_AUDIO_CAPTURE,
-                                 *devices_array);
+    listener_->DevicesEnumerated(MEDIA_DEVICE_AUDIO_CAPTURE, *devices_array);
   }
 }
 
 void AudioInputDeviceManager::OpenedOnIOThread(
-    content::MediaStreamDeviceType stream_type, int session_id) {
+    MediaStreamDeviceType stream_type, int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (listener_)
     listener_->Opened(stream_type, session_id);
 }
 
 void AudioInputDeviceManager::ClosedOnIOThread(
-    content::MediaStreamDeviceType stream_type, int session_id) {
+    MediaStreamDeviceType stream_type, int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (listener_)
     listener_->Closed(stream_type, session_id);
 }
 
 bool AudioInputDeviceManager::IsOnDeviceThread() const {
   return device_loop_->BelongsToCurrentThread();
 }
 
-}  // namespace media_stream
+}  // namespace content