Show camera and microphone status indicators.

content/browser/renderer_host/media/media_stream_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/media_stream_manager.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/media_stream_device_settings.h"
 #include "content/browser/renderer_host/media/media_stream_requester.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/media_observer.h"
 #include "media/audio/audio_manager.h"
 
 using content::BrowserThread;
 
 static const char* kMediaStreamManagerKeyName = "content_media_stream_manager";
 
 namespace media_stream {
 
 // Creates a random label used to identify requests.
 static std::string RandomLabel() {
@@ skipping 17 matching lines @@
   if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE &&
       options.video) {
     return true;
   } else if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE &&
              options.audio) {
     return true;
   }
   return false;
 }
 
+// TODO(xians): Merge DeviceRequest with MediaStreamRequest.
 struct MediaStreamManager::DeviceRequest {
   enum RequestState {
     kNotRequested = 0,
     kRequested,
     kPendingApproval,
     kOpening,
     kDone,
     kError
   };
 
   enum RequestType {
     kGenerateStream = 0,
     kEnumerateDevices,
     kOpenDevice
   };
 
   DeviceRequest()
       : requester(NULL),
         state(content::NUM_MEDIA_STREAM_DEVICE_TYPES, kNotRequested),
-        type(kGenerateStream) {
+        type(kGenerateStream),
+        render_process_id(-1),
+        render_view_id(-1) {
     options.audio = false;
     options.video = false;
   }
 
   DeviceRequest(MediaStreamRequester* requester,
-                const StreamOptions& request_options)
+                const StreamOptions& request_options,
+                int render_process_id,
+                int render_view_id,
+                const std::string& request_security_origin)
       : requester(requester),
         options(request_options),
         state(content::NUM_MEDIA_STREAM_DEVICE_TYPES, kNotRequested),
-        type(kGenerateStream) {
+        type(kGenerateStream),
+        render_process_id(render_process_id),
+        render_view_id(render_view_id),
+        security_origin(request_security_origin) {
     DCHECK(requester);
   }
 
   ~DeviceRequest() {}
 
   MediaStreamRequester* requester;
   StreamOptions options;
   std::vector<RequestState> state;
   RequestType type;
+  int render_process_id;
+  int render_view_id;
+  std::string security_origin;
   std::string requested_device_id;
   StreamDeviceInfoArray audio_devices;
   StreamDeviceInfoArray video_devices;
 };
 
 // static
 MediaStreamManager* MediaStreamManager::GetForResourceContext(
     content::ResourceContext* resource_context,
     media::AudioManager* audio_manager) {
   MediaStreamManager* rv = static_cast<MediaStreamManager*>(
@@ skipping 41 matching lines @@
 
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
                                         int render_process_id,
                                         int render_view_id,
                                         const StreamOptions& options,
                                         const std::string& security_origin,
                                         std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Create a new request based on options.
-  DeviceRequest new_request = DeviceRequest(requester, options);
-  StartEnumeration(&new_request, render_process_id, render_view_id,
-                   security_origin, label);
+  DeviceRequest new_request(requester, options,
+                            render_process_id,
+                            render_view_id,
+                            security_origin);
+  StartEnumeration(&new_request, label);
 }
 
 void MediaStreamManager::CancelRequests(MediaStreamRequester* requester) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DeviceRequests::iterator it = requests_.begin();
   while (it != requests_.end()) {
     if (it->second.requester == requester && !RequestDone(it->second)) {
       // The request isn't complete, but there might be some devices already
       // opened -> close them.
       DeviceRequest* request = &(it->second);
@@ skipping 32 matching lines @@
     for (StreamDeviceInfoArray::iterator audio_it =
          it->second.audio_devices.begin();
          audio_it != it->second.audio_devices.end(); ++audio_it) {
       audio_input_device_manager()->Close(audio_it->session_id);
     }
     for (StreamDeviceInfoArray::iterator video_it =
          it->second.video_devices.begin();
          video_it != it->second.video_devices.end(); ++video_it) {
       video_capture_manager()->Close(video_it->session_id);
     }
+    if (it->second.type == DeviceRequest::kGenerateStream) {
+      NotifyObserverDevicesClosed(&(it->second));
+    }
     requests_.erase(it);
     return;
   }
 }
 
 void MediaStreamManager::EnumerateDevices(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
     MediaStreamType type,
     const std::string& security_origin,
     std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Create a new request.
   StreamOptions options;
   if (type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE)
     options.audio = true;
   else
     options.video = true;
 
-  DeviceRequest new_request = DeviceRequest(requester, options);
+  DeviceRequest new_request(requester, options,
+                            render_process_id,
+                            render_view_id,
+                            security_origin);
   new_request.type = DeviceRequest::kEnumerateDevices;
 
-  StartEnumeration(&new_request, render_process_id, render_view_id,
-                   security_origin, label);
+  StartEnumeration(&new_request, label);
 }
 
 void MediaStreamManager::OpenDevice(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
     const std::string& device_id,
     MediaStreamType type,
     const std::string& security_origin,
     std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Create a new request.
   StreamOptions options;
   if (type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE)
     options.audio = true;
   else
     options.video = true;
 
-  DeviceRequest new_request = DeviceRequest(requester, options);
+  DeviceRequest new_request(requester, options,
+                            render_process_id,
+                            render_view_id,
+                            security_origin);
   new_request.type = DeviceRequest::kOpenDevice;
   new_request.requested_device_id = device_id;
 
-  StartEnumeration(&new_request, render_process_id, render_view_id,
-                   security_origin, label);
+  StartEnumeration(&new_request, label);
 }
 
 void MediaStreamManager::StartEnumeration(
     DeviceRequest* new_request,
-    int render_process_id,
-    int render_view_id,
-    const std::string& security_origin,
     std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   MediaStreamType stream_type = content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE;
   if (Requested(new_request->options, stream_type)) {
     new_request->state[stream_type] = DeviceRequest::kRequested;
     if (!enumeration_in_progress_[stream_type]) {
       enumeration_in_progress_[stream_type] = true;
       GetDeviceManager(stream_type)->EnumerateDevices();
     }
@@ skipping 16 matching lines @@
   requests_.insert(std::make_pair(request_label, *new_request));
 
   // Get user confirmation to use capture devices.
   // Need to make an asynchronous call to make sure the |requester| gets the
   // |label| before it would receive any event.
   if (new_request->type == DeviceRequest::kGenerateStream) {
     BrowserThread::PostTask(BrowserThread::IO,
         FROM_HERE,
         base::Bind(&MediaStreamDeviceSettings::RequestCaptureDeviceUsage,
                    base::Unretained(device_settings_.get()),
-                   request_label, render_process_id,
-                   render_view_id, new_request->options,
-                   security_origin));
+                   request_label, new_request->render_process_id,
+                   new_request->render_view_id, new_request->options,
+                   new_request->security_origin));
   }
 
   (*label) = request_label;
 }
 
 void MediaStreamManager::Opened(MediaStreamType stream_type,
                                 int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Find the request containing this device and mark it as used.
@@ skipping 44 matching lines @@
     return;
   }
 
   switch (request->type) {
     case DeviceRequest::kOpenDevice:
       request->requester->DeviceOpened(label, (*devices)[0]);
       break;
     case DeviceRequest::kGenerateStream:
       request->requester->StreamGenerated(label, request->audio_devices,
                                           request->video_devices);
+      NotifyObserverDevicesOpened(request);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void MediaStreamManager::Closed(MediaStreamType stream_type,
                                 int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
@@ skipping 166 matching lines @@
     return;
   }
 }
 
 void MediaStreamManager::UseFakeDevice() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   video_capture_manager()->UseFakeDevice();
   device_settings_->UseFakeUI();
 }
 
+void MediaStreamManager::NotifyObserverDevicesOpened(DeviceRequest* request) {
+  content::MediaObserver* media_observer =
+      content::GetContentClient()->browser()->GetMediaObserver();
+  content::MediaStreamDevices opened_devices;
+  DevicesFromRequest(request, &opened_devices);
+  DCHECK(!opened_devices.empty());
+  media_observer->OnCaptureDevicesOpened(request->render_process_id,
+                                         request->render_view_id,
+                                         opened_devices);
+}
+
+void MediaStreamManager::NotifyObserverDevicesClosed(DeviceRequest* request) {
+  content::MediaObserver* media_observer =
+      content::GetContentClient()->browser()->GetMediaObserver();
+  content::MediaStreamDevices closed_devices;
+  DevicesFromRequest(request, &closed_devices);
+  if (closed_devices.empty())
+    return;
+  media_observer->OnCaptureDevicesClosed(request->render_process_id,
+                                         request->render_view_id,
+                                         closed_devices);
+}
+
+void MediaStreamManager::DevicesFromRequest(
+    DeviceRequest* request, content::MediaStreamDevices* devices) {
+  StreamDeviceInfoArray::const_iterator it = request->audio_devices.begin();
+  for (; it != request->audio_devices.end(); ++it) {
+    devices->push_back(
+        content::MediaStreamDevice(
+            content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE,
+            it->device_id,
+            it->name));
+  }
+  for (it = request->video_devices.begin(); it != request->video_devices.end();
+       ++it) {
+    devices->push_back(
+        content::MediaStreamDevice(
+            content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
+            it->device_id,
+            it->name));
+  }
+}
+
 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Check if all devices are opened.
   if (Requested(request.options,
                 content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE)) {
     for (StreamDeviceInfoArray::const_iterator it =
          request.audio_devices.begin(); it != request.audio_devices.end();
          ++it) {
       if (it->in_use == false) {
         return false;
@@ skipping 19 matching lines @@
   if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE) {
     return video_capture_manager();
   } else if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE) {
     return audio_input_device_manager();
   }
   NOTREACHED();
   return NULL;
 }
 
 }  // namespace media_stream