[Mojo Video Capture] Add content_browsertest for exercising video capture

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 <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 283 matching lines @@
     : serial_id_(serial_id),
       session_id_(session_id),
       params_(params),
       abort_start_(false) {
 }
 
 VideoCaptureManager::VideoCaptureManager(
     std::unique_ptr<media::VideoCaptureDeviceFactory> factory,
     scoped_refptr<base::SingleThreadTaskRunner> device_task_runner)
     : device_task_runner_(std::move(device_task_runner)),
-      listener_(nullptr),
       new_capture_session_id_(1),
       video_capture_device_factory_(std::move(factory)) {}
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(devices_.empty());
   DCHECK(device_start_queue_.empty());
 }
 
 void VideoCaptureManager::AddVideoCaptureObserver(
     media::VideoCaptureObserver* observer) {
   DCHECK(observer);
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   capture_observers_.AddObserver(observer);
 }
 
 void VideoCaptureManager::RemoveAllVideoCaptureObservers() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   capture_observers_.Clear();
 }
 
 void VideoCaptureManager::RegisterListener(
     MediaStreamProviderListener* listener) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(!listener_);
+  DCHECK(listener);
   DCHECK(device_task_runner_);
-  listener_ = listener;
+  listeners_.AddObserver(listener);
 #if defined(OS_ANDROID)
   application_state_has_running_activities_ = true;
   app_status_listener_.reset(new base::android::ApplicationStatusListener(
       base::Bind(&VideoCaptureManager::OnApplicationStateChange,
                  base::Unretained(this))));
 #endif
 }
 
-void VideoCaptureManager::UnregisterListener() {
+void VideoCaptureManager::UnregisterListener(
+    MediaStreamProviderListener* listener) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(listener_);
-  listener_ = nullptr;
+  listeners_.RemoveObserver(listener);
 }
 
 void VideoCaptureManager::EnumerateDevices(
     const EnumerationCallback& client_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureManager::EnumerateDevices";
 
   // Bind a callback to ConsolidateDevicesInfoOnDeviceThread() with an argument
   // for another callback to OnDevicesInfoEnumerated() to be run in the current
   // loop, i.e. IO loop. Pass a timer for UMA histogram collection.
   base::Callback<void(std::unique_ptr<VideoCaptureDeviceDescriptors>)>
       devices_enumerated_callback = base::Bind(
           &VideoCaptureManager::ConsolidateDevicesInfoOnDeviceThread, this,
           media::BindToCurrentLoop(base::Bind(
               &VideoCaptureManager::OnDevicesInfoEnumerated, this,
               base::Owned(new base::ElapsedTimer()), client_callback)),
           devices_info_cache_);
   // OK to use base::Unretained() since we own the VCDFactory and |this| is
   // bound in |devices_enumerated_callback|.
   device_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&media::VideoCaptureDeviceFactory::EnumerateDeviceDescriptors,
                  base::Unretained(video_capture_device_factory_.get()),
                  devices_enumerated_callback));
 }
 
-int VideoCaptureManager::Open(const StreamDeviceInfo& device_info) {
+int VideoCaptureManager::Open(const MediaStreamDevice& device) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(listener_);
 
   // Generate a new id for the session being opened.
   const media::VideoCaptureSessionId capture_session_id =
       new_capture_session_id_++;
 
   DCHECK(sessions_.find(capture_session_id) == sessions_.end());
   DVLOG(1) << "VideoCaptureManager::Open, id " << capture_session_id;
 
   // We just save the stream info for processing later.
-  sessions_[capture_session_id] = device_info.device;
+  sessions_[capture_session_id] = device;
 
   // Notify our listener asynchronously; this ensures that we return
   // |capture_session_id| to the caller of this function before using that same
   // id in a listener event.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&VideoCaptureManager::OnOpened, this,
-                            device_info.device.type, capture_session_id));
+      FROM_HERE, base::Bind(&VideoCaptureManager::OnOpened, this, device.type,
+                            capture_session_id));
   return capture_session_id;
 }
 
 void VideoCaptureManager::Close(int capture_session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(listener_);
   DVLOG(1) << "VideoCaptureManager::Close, id " << capture_session_id;
 
   SessionMap::iterator session_it = sessions_.find(capture_session_id);
   if (session_it == sessions_.end()) {
     NOTREACHED();
     return;
   }
 
   DeviceEntry* const existing_device =
       GetDeviceEntryByTypeAndId(session_it->second.type, session_it->second.id);
@@ skipping 355 matching lines @@
       LogVideoCaptureEvent(
           VIDEO_CAPTURE_STOP_CAPTURE_OK_NO_FRAMES_PRODUCED_BY_DEVICE);
     } else {
       LogVideoCaptureEvent(
           VIDEO_CAPTURE_STOP_CAPTURE_OK_NO_FRAMES_PRODUCED_BY_DESKTOP_OR_TAB);
     }
   } else {
     LogVideoCaptureEvent(VIDEO_CAPTURE_STOP_CAPTURE_DUE_TO_ERROR);
     for (auto it : sessions_) {
       if (it.second.type == entry->stream_type && it.second.id == entry->id) {
-        listener_->Aborted(it.second.type, it.first);
+        for (auto& listener : listeners_)
+          listener.Aborted(it.second.type, it.first);
         // Aborted() call might synchronously destroy |entry|, recheck.
         entry = GetDeviceEntryByController(controller);
         if (!entry)
           return;
         break;
       }
     }
   }
 
   // Detach client from controller.
@@ skipping 253 matching lines @@
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StopDeviceTime");
   DCHECK(IsOnDeviceThread());
   device->StopAndDeAllocate();
   DVLOG(3) << "DoStopDeviceOnDeviceThread";
 }
 
 void VideoCaptureManager::OnOpened(
     MediaStreamType stream_type,
     media::VideoCaptureSessionId capture_session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!listener_) {
-    // Listener has been removed.
-    return;
-  }
-  listener_->Opened(stream_type, capture_session_id);
+  for (auto& listener : listeners_)
+    listener.Opened(stream_type, capture_session_id);
 }
 
 void VideoCaptureManager::OnClosed(
     MediaStreamType stream_type,
     media::VideoCaptureSessionId capture_session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!listener_) {
-    // Listener has been removed.
-    return;
-  }
-  listener_->Closed(stream_type, capture_session_id);
+  for (auto& listener : listeners_)
+    listener.Closed(stream_type, capture_session_id);
 }
 
 void VideoCaptureManager::OnDevicesInfoEnumerated(
     base::ElapsedTimer* timer,
     const EnumerationCallback& client_callback,
     const VideoCaptureManager::DeviceInfos& new_devices_info_cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   UMA_HISTOGRAM_TIMES(
       "Media.VideoCaptureManager.GetAvailableDevicesInfoOnDeviceThreadTime",
       timer->Elapsed());
@@ skipping 266 matching lines @@
     if (!device_in_queue) {
       // Session ID is only valid for Screen capture. So we can fake it to
       // resume video capture devices here.
       QueueStartDevice(kFakeSessionId, entry.get(), entry->parameters);
     }
   }
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content