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

content/browser/renderer_host/media/video_capture_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/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/browser/renderer_host/media/web_contents_video_capture_device.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/media_stream_request.h"
 #include "media/video/capture/fake_video_capture_device.h"
 #include "media/video/capture/video_capture_device.h"
 
-using content::BrowserThread;
-
-namespace media_stream {
+namespace content {
 
 // Starting id for the first capture session.
 // VideoCaptureManager::kStartOpenSessionId is used as default id without
 // explicitly calling open device.
 enum { kFirstSessionId = VideoCaptureManager::kStartOpenSessionId + 1 };
 
 struct VideoCaptureManager::Controller {
   Controller(
       VideoCaptureController* vc_controller,
       VideoCaptureControllerEventHandler* handler)
@@ skipping 93 matching lines @@
 
   media::VideoCaptureDevice::Names device_names;
   GetAvailableDevices(&device_names);
 
   StreamDeviceInfoArray devices;
   for (media::VideoCaptureDevice::Names::iterator it =
            device_names.begin(); it != device_names.end(); ++it) {
     bool opened = DeviceOpened(*it);
     // NOTE: Only support enumeration of the MEDIA_DEVICE_VIDEO_CAPTURE type.
     devices.push_back(StreamDeviceInfo(
-        content::MEDIA_DEVICE_VIDEO_CAPTURE, it->device_name,
-        it->unique_id, opened));
+        MEDIA_DEVICE_VIDEO_CAPTURE, it->device_name, it->unique_id, opened));
   }
 
   PostOnDevicesEnumerated(devices);
 }
 
 void VideoCaptureManager::OnOpen(int capture_session_id,
                                  const StreamDeviceInfo& device) {
   DCHECK(IsOnDeviceThread());
   DCHECK(devices_.find(capture_session_id) == devices_.end());
   DVLOG(1) << "VideoCaptureManager::OnOpen, id " << capture_session_id;
@@ skipping 12 matching lines @@
   // Open the device.
   media::VideoCaptureDevice::Name vc_device_name;
   vc_device_name.device_name = device.name;
   vc_device_name.unique_id = device.device_id;
 
   if (use_fake_device_) {
     video_capture_device =
         media::FakeVideoCaptureDevice::Create(vc_device_name);
   } else {
     switch (device.stream_type) {
-      case content::MEDIA_DEVICE_VIDEO_CAPTURE:
+      case MEDIA_DEVICE_VIDEO_CAPTURE:
         video_capture_device =
             media::VideoCaptureDevice::Create(vc_device_name);
         break;
-      case content::MEDIA_TAB_VIDEO_CAPTURE:
-        video_capture_device = content::WebContentsVideoCaptureDevice::Create(
+      case MEDIA_TAB_VIDEO_CAPTURE:
+        video_capture_device = WebContentsVideoCaptureDevice::Create(
             vc_device_name.unique_id);
         break;
       default:
         NOTIMPLEMENTED();
         break;
     }
   }
   if (!video_capture_device) {
     PostOnError(capture_session_id, kDeviceNotAvailable);
     return;
@@ skipping 96 matching lines @@
 
   if (!stopped_cb.is_null())
     stopped_cb.Run();
 
   if (capture_session_id == kStartOpenSessionId) {
     // This device was opened from Start(), not Open(). Close it!
     OnClose(capture_session_id);
   }
 }
 
-void VideoCaptureManager::OnOpened(content::MediaStreamDeviceType stream_type,
+void VideoCaptureManager::OnOpened(MediaStreamDeviceType stream_type,
                                    int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
   listener_->Opened(stream_type, capture_session_id);
 }
 
-void VideoCaptureManager::OnClosed(content::MediaStreamDeviceType stream_type,
+void VideoCaptureManager::OnClosed(MediaStreamDeviceType stream_type,
                                    int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
   listener_->Closed(stream_type, capture_session_id);
 }
 
 void VideoCaptureManager::OnDevicesEnumerated(
     const StreamDeviceInfoArray& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
   // NOTE: Only support enumeration of the MEDIA_DEVICE_VIDEO_CAPTURE type.
-  listener_->DevicesEnumerated(content::MEDIA_DEVICE_VIDEO_CAPTURE, devices);
+  listener_->DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, devices);
 }
 
-void VideoCaptureManager::OnError(content::MediaStreamDeviceType stream_type,
+void VideoCaptureManager::OnError(MediaStreamDeviceType stream_type,
                                   int capture_session_id,
                                   MediaStreamProviderError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
   listener_->Error(stream_type, capture_session_id, error);
 }
 
 void VideoCaptureManager::PostOnOpened(
-    content::MediaStreamDeviceType stream_type, int capture_session_id) {
+    MediaStreamDeviceType stream_type, int capture_session_id) {
   DCHECK(IsOnDeviceThread());
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&VideoCaptureManager::OnOpened, this,
                                      stream_type, capture_session_id));
 }
 
 void VideoCaptureManager::PostOnClosed(
-    content::MediaStreamDeviceType stream_type, int capture_session_id) {
+    MediaStreamDeviceType stream_type, int capture_session_id) {
   DCHECK(IsOnDeviceThread());
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&VideoCaptureManager::OnClosed, this,
                                      stream_type, capture_session_id));
 }
 
 void VideoCaptureManager::PostOnDevicesEnumerated(
     const StreamDeviceInfoArray& devices) {
   DCHECK(IsOnDeviceThread());
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&VideoCaptureManager::OnDevicesEnumerated,
                                      this, devices));
 }
 
 void VideoCaptureManager::PostOnError(int capture_session_id,
                                       MediaStreamProviderError error) {
   DCHECK(IsOnDeviceThread());
-  content::MediaStreamDeviceType stream_type =
-      content::MEDIA_DEVICE_VIDEO_CAPTURE;
+  MediaStreamDeviceType stream_type = MEDIA_DEVICE_VIDEO_CAPTURE;
   VideoCaptureDevices::const_iterator it = devices_.find(capture_session_id);
   if (it != devices_.end())
     stream_type = it->second.stream_type;
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&VideoCaptureManager::OnError, this,
                                      stream_type, capture_session_id, error));
 }
 
 bool VideoCaptureManager::IsOnDeviceThread() const {
@@ skipping 133 matching lines @@
   // Solution for not using MediaStreamManager.
   // This session id won't be returned by Open().
   if (capture_session_id == kStartOpenSessionId) {
     media::VideoCaptureDevice::Names device_names;
     GetAvailableDevices(&device_names);
     if (device_names.empty()) {
       // No devices available.
       return NULL;
     }
     // NOTE: Only support enumeration of the MEDIA_DEVICE_VIDEO_CAPTURE type.
-    StreamDeviceInfo device(content::MEDIA_DEVICE_VIDEO_CAPTURE,
+    StreamDeviceInfo device(MEDIA_DEVICE_VIDEO_CAPTURE,
                             device_names.front().device_name,
                             device_names.front().unique_id, false);
 
     // Call OnOpen to open using the first device in the list.
     OnOpen(capture_session_id, device);
 
     VideoCaptureDevices::iterator dit = devices_.find(capture_session_id);
     if (dit != devices_.end()) {
       return dit->second.capture_device;
     }
   }
   return NULL;
 }
 
-}  // namespace media_stream
+}  // namespace content