Begin adding support for tab mirroring via the MediaStream audio/video capturing

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/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 {
 
 // 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)
       : controller(vc_controller),
         ready_to_delete(false) {
     handlers.push_front(handler);
   }
   ~Controller() {}
 
   scoped_refptr<VideoCaptureController> controller;
   bool ready_to_delete;
   Handlers handlers;
 };
 
-VideoCaptureManager::VideoCaptureManager()
-    : listener_(NULL),
+VideoCaptureManager::VideoCaptureManager(
+    media_stream::MediaStreamType device_type)
+    : device_type_(device_type),
+      listener_(NULL),
       new_capture_session_id_(kFirstSessionId),
       use_fake_device_(false) {
+  DCHECK(content::IsVideoMediaStreamDeviceType(device_type_));
 }
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(devices_.empty());
   DCHECK(controllers_.empty());
 }
 
 void VideoCaptureManager::Register(MediaStreamProviderListener* listener,
                                    base::MessageLoopProxy* device_thread_loop) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 72 matching lines @@
   DCHECK(IsOnDeviceThread());
 
   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);
     devices.push_back(StreamDeviceInfo(
-        content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE, it->device_name,
-        it->unique_id, opened));
+        device_type_, 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;
 
   // Check if another session has already opened this device. If so, just
   // use that opened device.
   media::VideoCaptureDevice* video_capture_device = GetOpenedDevice(device);
   if (video_capture_device) {
     devices_[capture_session_id] = video_capture_device;
     PostOnOpened(capture_session_id);
     return;
   }
 
   // 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::VideoCaptureDevice::Create(vc_device_name);
-  } else {
+  if (use_fake_device_) {
     video_capture_device =
         media::FakeVideoCaptureDevice::Create(vc_device_name);
+  } else {
+    switch (device_type_) {
+      case content::MEDIA_STREAM_DEVICE_TYPE_USER_VIDEO_CAPTURE:
+        video_capture_device =
+            media::VideoCaptureDevice::Create(vc_device_name);
+        break;
+      case content::MEDIA_STREAM_DEVICE_TYPE_TAB_VIDEO_CAPTURE:
+        // TODO(miu): Replace this stub with the actual implementation.
+        video_capture_device =
+            media::FakeVideoCaptureDevice::Create(vc_device_name);
+        break;
+      default:
+        NOTIMPLEMENTED();
+        break;
+    }
   }
   if (!video_capture_device) {
     PostOnError(capture_session_id, kDeviceNotAvailable);
     return;
   }
 
   devices_[capture_session_id] = video_capture_device;
   PostOnOpened(capture_session_id);
 }
 
@@ skipping 93 matching lines @@
     OnClose(capture_session_id);
   }
 }
 
 void VideoCaptureManager::OnOpened(int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
-  listener_->Opened(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
-                    capture_session_id);
+  listener_->Opened(device_type_, capture_session_id);
 }
 
 void VideoCaptureManager::OnClosed(int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
-  listener_->Closed(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
-                    capture_session_id);
+  listener_->Closed(device_type_, capture_session_id);
 }
 
 void VideoCaptureManager::OnDevicesEnumerated(
     const StreamDeviceInfoArray& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
-  listener_->DevicesEnumerated(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
-                               devices);
+  listener_->DevicesEnumerated(device_type_, devices);
 }
 
 void VideoCaptureManager::OnError(int capture_session_id,
                                   MediaStreamProviderError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
-  listener_->Error(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
-                   capture_session_id, error);
+  listener_->Error(device_type_, capture_session_id, error);
 }
 
 void VideoCaptureManager::PostOnOpened(int capture_session_id) {
   DCHECK(IsOnDeviceThread());
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&VideoCaptureManager::OnOpened, this,
                                      capture_session_id));
 }
 
@@ skipping 25 matching lines @@
 }
 
 bool VideoCaptureManager::IsOnDeviceThread() const {
   return device_loop_->BelongsToCurrentThread();
 }
 
 void VideoCaptureManager::GetAvailableDevices(
     media::VideoCaptureDevice::Names* device_names) {
   DCHECK(IsOnDeviceThread());
 
-  if (!use_fake_device_) {
-    media::VideoCaptureDevice::GetDeviceNames(device_names);
+  if (use_fake_device_) {
+    media::FakeVideoCaptureDevice::GetDeviceNames(device_names);
   } else {
-    media::FakeVideoCaptureDevice::GetDeviceNames(device_names);
+    switch (device_type_) {
+      case content::MEDIA_STREAM_DEVICE_TYPE_USER_VIDEO_CAPTURE:
+        media::VideoCaptureDevice::GetDeviceNames(device_names);
+        break;
+      case content::MEDIA_STREAM_DEVICE_TYPE_TAB_VIDEO_CAPTURE: {
+        // TODO(miu): Replace this stub with the actual implementation.
+        media::VideoCaptureDevice::Name name;
+        name.unique_id = "/dev/video0";
+        name.device_name = "Stub Tab Video Capture";
+        device_names->push_back(name);
+        break;
+      }
+      default:
+        NOTIMPLEMENTED();
+        break;
+    }
   }
 }
 
 bool VideoCaptureManager::DeviceOpened(
     const media::VideoCaptureDevice::Name& device_name) {
   DCHECK(IsOnDeviceThread());
 
   for (VideoCaptureDevices::iterator it = devices_.begin();
        it != devices_.end(); ++it) {
     if (device_name.unique_id == it->second->device_name().unique_id) {
@@ skipping 109 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;
     }
-    StreamDeviceInfo device(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
-                            device_names.front().device_name,
-                            device_names.front().unique_id, false);
+    StreamDeviceInfo device(
+        device_type_, 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;
     }
   }
   return NULL;
 }
 
 }  // namespace media_stream