Show camera and microphone status indicators.

content/browser/renderer_host/media/media_stream_manager.cc

Index: content/browser/renderer_host/media/media_stream_manager.cc
diff --git a/content/browser/renderer_host/media/media_stream_manager.cc b/content/browser/renderer_host/media/media_stream_manager.cc
index 9771e25ac6c96fee1a4c75c6839c43d7580855dd..f7982b872064e2c779a9ce3049f2cee5a5b45c66 100644
--- a/content/browser/renderer_host/media/media_stream_manager.cc
+++ b/content/browser/renderer_host/media/media_stream_manager.cc
@@ -17,6 +17,8 @@
 #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;
@@ -54,6 +56,7 @@ static bool Requested(const StreamOptions& options,
   return false;
 }
 
+// TODO(xians): Merge DeviceRequest with MediaStreamRequest.
 struct MediaStreamManager::DeviceRequest {
   enum RequestState {
     kNotRequested = 0,
@@ -73,17 +76,25 @@ struct MediaStreamManager::DeviceRequest {
   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);
   }
 
@@ -93,6 +104,9 @@ struct MediaStreamManager::DeviceRequest {
   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;
@@ -154,9 +168,11 @@ void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
   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) {
@@ -209,6 +225,9 @@ void MediaStreamManager::StopGeneratedStream(const std::string& label) {
          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;
   }
@@ -230,11 +249,13 @@ void MediaStreamManager::EnumerateDevices(
   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(
@@ -254,19 +275,18 @@ void MediaStreamManager::OpenDevice(
   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));
 
@@ -303,9 +323,9 @@ void MediaStreamManager::StartEnumeration(
         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;
@@ -370,6 +390,7 @@ void MediaStreamManager::Opened(MediaStreamType stream_type,
     case DeviceRequest::kGenerateStream:
       request->requester->StreamGenerated(label, request->audio_devices,
                                           request->video_devices);
+      NotifyObserverDevicesOpened(request);
       break;
     default:
       NOTREACHED();
@@ -556,6 +577,49 @@ void MediaStreamManager::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.