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;

[no longer working on chromium, 2012/09/10 09:11:04]

how are we using the new_entry?

[miu, 2012/09/10 21:24:38]

It's a DeviceEntry&, not a DeviceEntry.  So, we are setting the fields on the
object stored in the devices_ map.

This is marginally cheaper than creating a DeviceEntry, setting its fields, and
then inserting it into the devices_ map (which requires an additional copy).

[no longer working on chromium, 2012/09/10 22:12:38]

Good to know, thanks, I missed the declaration of DeviceEntry and Wei's
comments.

+    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];

[no longer working on chromium, 2012/09/10 09:11:04]

same question here.

+  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 entry = device_it->second;

[no longer working on chromium, 2012/09/10 09:11:04]

I am sorry if I misunderstand something here, is this entry a copy of
device_it->second? If so, does the delete entry.capture_device; in line 232
delete the original memory?

[miu, 2012/09/10 21:24:38]

See wjia@'s comments and my response below (line 232).

[no longer working on chromium, 2012/09/10 22:12:38]

Done.

+  devices_.erase(device_it);
 
-    Controllers::iterator cit = controllers_.find(video_capture_device);
+  Controllers::iterator cit = controllers_.find(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(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|.
+    entry.capture_device->DeAllocate();
+    Controllers::iterator cit = controllers_.find(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 entry.capture_device;

[tommi (sloooow) - chröme, 2012/09/10 09:17:25]

set to NULL as well?
It's not clear to me how capture_device ownership is managed actually and at
what time it is safe to delete etc.  There seems to be a good chance of
object/memory leaks here.

[wjia(left Chromium), 2012/09/10 17:40:16]

|entry| is a local variable. No need to set it to NULL. What happens here is
that:
1. VideoCaptureDevices used to use capture_session_id as index to store
VideoCaptureDevice, and it's possible multiple capture_session_id's can be
mapped to same VideoCaptureDevice.
2. miu@ just added a MediaStreamType associated with each VideoCaptureDevice
(i.e., the new class DeviceEntry).
3. When OnClose() is called, the entry in VideoCaptureDevices will be erased
immediately. However, the corresponding VideoCaptureDevice might be still in use
by other session_id's. Therefore, the copy of DeviceEntry on line 211.
4. The VideoCaptureDevice will be deleted only when it's not used by any
session.

Hope this clarifies.

[miu, 2012/09/10 21:24:38]

Yes.  Multiple DeviceEntrys could point to the exact same VideoCaptureDevice
instance.  Normally, we would want to use scoped_refptr<VideoCaptureDevice> in
the entries, but we need to invoke DeAllocate() on the capture device before
destruction.

I've added a comment in the header file to clarify that
DeviceEntry::capture_device might be shared across sessions.

[tommi (sloooow) - chröme, 2012/09/11 10:40:27]

Thanks for the info.

+  }
 
-    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(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()) {

[tommi (sloooow) - chröme, 2012/09/10 09:17:25]

no {}

[miu, 2012/09/10 21:24:38]

Done.

+    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