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.
@@ skipping 85 matching lines @@
     base::Closure stopped_cb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   device_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::OnStop, this, capture_session_id,
                  stopped_cb));
 }
 
 void VideoCaptureManager::Error(
     const media::VideoCaptureSessionId& capture_session_id) {
-  PostOnError(capture_session_id, kDeviceNotAvailable);
+  device_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoCaptureManager::PostOnError, this, capture_session_id,
+                 kDeviceNotAvailable));
 }
 
 void VideoCaptureManager::UseFakeDevice() {
   use_fake_device_ = true;
 }
 
 void VideoCaptureManager::OnEnumerateDevices() {
   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);
+    // NOTE: Only support enumeration of the MEDIA_DEVICE_VIDEO_CAPTURE type.
     devices.push_back(StreamDeviceInfo(
-        content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE, it->device_name,
+        content::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;
 
   // 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);
+    DeviceEntry& new_entry = devices_[capture_session_id];
+    new_entry.stream_type = device.stream_type;
+    new_entry.capture_device = video_capture_device;
+    PostOnOpened(device.stream_type, 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.stream_type) {
+      case content::MEDIA_DEVICE_VIDEO_CAPTURE:
+        video_capture_device =
+            media::VideoCaptureDevice::Create(vc_device_name);
+        break;
+      case content::MEDIA_TAB_VIDEO_CAPTURE:
+        // TODO(miu): Replace this stub with the actual implementation in a
+        // later change.
+        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);
+  DeviceEntry& new_entry = devices_[capture_session_id];
+  new_entry.stream_type = device.stream_type;
+  new_entry.capture_device = video_capture_device;
+  PostOnOpened(device.stream_type, capture_session_id);
 }
 
 void VideoCaptureManager::OnClose(int capture_session_id) {
   DCHECK(IsOnDeviceThread());
   DVLOG(1) << "VideoCaptureManager::OnClose, id " << capture_session_id;
 
-  media::VideoCaptureDevice* video_capture_device = NULL;
   VideoCaptureDevices::iterator device_it = devices_.find(capture_session_id);
-  if (device_it != devices_.end()) {
-    video_capture_device = device_it->second;
-    devices_.erase(device_it);
+  if (device_it == devices_.end()) {
+    return;
+  }
+  const DeviceEntry removed_entry = device_it->second;
+  devices_.erase(device_it);
 
-    Controllers::iterator cit = controllers_.find(video_capture_device);
+  Controllers::iterator cit = controllers_.find(removed_entry.capture_device);
+  if (cit != controllers_.end()) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&VideoCaptureController::StopSession,
+                   cit->second->controller, capture_session_id));
+  }
+
+  if (!DeviceInUse(removed_entry.capture_device)) {
+    // No other users of this device, deallocate (if not done already) and
+    // delete the device. No need to take care of the controller, that is done
+    // by |OnStop|.
+    removed_entry.capture_device->DeAllocate();
+    Controllers::iterator cit = controllers_.find(removed_entry.capture_device);
     if (cit != controllers_.end()) {
-      BrowserThread::PostTask(
-          BrowserThread::IO, FROM_HERE,
-          base::Bind(&VideoCaptureController::StopSession,
-                     cit->second->controller, capture_session_id));
+      delete cit->second;
+      controllers_.erase(cit);
     }
+    delete removed_entry.capture_device;
+  }
 
-    if (!DeviceInUse(video_capture_device)) {
-      // No other users of this device, deallocate (if not done already) and
-      // delete the device. No need to take care of the controller, that is done
-      // by |OnStop|.
-      video_capture_device->DeAllocate();
-      Controllers::iterator cit = controllers_.find(video_capture_device);
-      if (cit != controllers_.end()) {
-        delete cit->second;
-        controllers_.erase(cit);
-      }
-      delete video_capture_device;
-    }
-  }
-  PostOnClosed(capture_session_id);
+  PostOnClosed(removed_entry.stream_type, capture_session_id);
 }
 
 void VideoCaptureManager::OnStart(
     const media::VideoCaptureParams capture_params,
     media::VideoCaptureDevice::EventHandler* video_capture_receiver) {
   DCHECK(IsOnDeviceThread());
   DCHECK(video_capture_receiver != NULL);
   DVLOG(1) << "VideoCaptureManager::OnStart, (" << capture_params.width
            << ", " << capture_params.height
            << ", " << capture_params.frame_per_second
@@ skipping 21 matching lines @@
 }
 
 void VideoCaptureManager::OnStop(
     const media::VideoCaptureSessionId capture_session_id,
     base::Closure stopped_cb) {
   DCHECK(IsOnDeviceThread());
   DVLOG(1) << "VideoCaptureManager::OnStop, id " << capture_session_id;
 
   VideoCaptureDevices::iterator it = devices_.find(capture_session_id);
   if (it != devices_.end()) {
-    media::VideoCaptureDevice* video_capture_device = it->second;
+    media::VideoCaptureDevice* video_capture_device = it->second.capture_device;
     // Possible errors are signaled to video_capture_receiver by
     // video_capture_device. video_capture_receiver to perform actions.
     video_capture_device->Stop();
     video_capture_device->DeAllocate();
     Controllers::iterator cit = controllers_.find(video_capture_device);
     if (cit != controllers_.end()) {
       cit->second->ready_to_delete = true;
       if (cit->second->handlers.empty()) {
         delete cit->second;
         controllers_.erase(cit);
       }
     }
   }
 
   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(int capture_session_id) {
+void VideoCaptureManager::OnOpened(content::MediaStreamDeviceType stream_type,
+                                   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(stream_type, capture_session_id);
 }
 
-void VideoCaptureManager::OnClosed(int capture_session_id) {
+void VideoCaptureManager::OnClosed(content::MediaStreamDeviceType stream_type,
+                                   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(stream_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);
+  // NOTE: Only support enumeration of the MEDIA_DEVICE_VIDEO_CAPTURE type.
+  listener_->DevicesEnumerated(content::MEDIA_DEVICE_VIDEO_CAPTURE, devices);
 }
 
-void VideoCaptureManager::OnError(int capture_session_id,
+void VideoCaptureManager::OnError(content::MediaStreamDeviceType stream_type,
+                                  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(stream_type, capture_session_id, error);
 }
 
-void VideoCaptureManager::PostOnOpened(int capture_session_id) {
+void VideoCaptureManager::PostOnOpened(
+    content::MediaStreamDeviceType stream_type, int capture_session_id) {
   DCHECK(IsOnDeviceThread());
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&VideoCaptureManager::OnOpened, this,
-                                     capture_session_id));
+                                     stream_type, capture_session_id));
 }
 
-void VideoCaptureManager::PostOnClosed(int capture_session_id) {
+void VideoCaptureManager::PostOnClosed(
+    content::MediaStreamDeviceType stream_type, int capture_session_id) {
   DCHECK(IsOnDeviceThread());
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&VideoCaptureManager::OnClosed, this,
-                                     capture_session_id));
+                                     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) {
-  // Don't check thread here, can be called from both IO thread and device
-  // thread.
+  DCHECK(IsOnDeviceThread());
+  content::MediaStreamDeviceType stream_type =
+      content::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,
-                                     capture_session_id, error));
+                                     stream_type, capture_session_id, error));
 }
 
 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);
   } else {
     media::FakeVideoCaptureDevice::GetDeviceNames(device_names);
   }
 }
 
 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) {
+    if (device_name.unique_id ==
+            it->second.capture_device->device_name().unique_id) {
       // We've found the device!
       return true;
     }
   }
   return false;
 }
 
 media::VideoCaptureDevice* VideoCaptureManager::GetOpenedDevice(
     const StreamDeviceInfo& device_info) {
   DCHECK(IsOnDeviceThread());
 
   for (VideoCaptureDevices::iterator it = devices_.begin();
        it != devices_.end(); it++) {
-    if (device_info.device_id == it->second->device_name().unique_id) {
-      return it->second;
+    if (device_info.device_id ==
+            it->second.capture_device->device_name().unique_id) {
+      return it->second.capture_device;
     }
   }
   return NULL;
 }
 
 bool VideoCaptureManager::DeviceInUse(
     const media::VideoCaptureDevice* video_capture_device) {
   DCHECK(IsOnDeviceThread());
 
   for (VideoCaptureDevices::iterator it = devices_.begin();
        it != devices_.end(); ++it) {
-    if (video_capture_device == it->second) {
+    if (video_capture_device == it->second.capture_device) {
       // We've found the device!
       return true;
     }
   }
   return false;
 }
 
 void VideoCaptureManager::AddController(
     const media::VideoCaptureParams& capture_params,
     VideoCaptureControllerEventHandler* handler,
@@ skipping 60 matching lines @@
       return;
     }
   }
 }
 
 media::VideoCaptureDevice* VideoCaptureManager::GetDeviceInternal(
     int capture_session_id) {
   DCHECK(IsOnDeviceThread());
   VideoCaptureDevices::iterator dit = devices_.find(capture_session_id);
   if (dit != devices_.end()) {
-    return dit->second;
+    return dit->second.capture_device;
   }
 
   // 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,
+    // NOTE: Only support enumeration of the MEDIA_DEVICE_VIDEO_CAPTURE type.
+    StreamDeviceInfo device(content::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;
+      return dit->second.capture_device;
     }
   }
   return NULL;
 }
 
 }  // namespace media_stream