Media Related changes for TabCapture API

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/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 "googleurl/src/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #endif
 
 using content::BrowserThread;
+using content::MediaStreamRequest;
 
 namespace media_stream {
 
 // Creates a random label used to identify requests.
 static std::string RandomLabel() {
   // An earlier PeerConnection spec,
   // http://dev.w3.org/2011/webrtc/editor/webrtc.html, specified the
   // MediaStream::label alphabet as containing 36 characters from
   // range: U+0021, U+0023 to U+0027, U+002A to U+002B, U+002D to U+002E,
   // U+0030 to U+0039, U+0041 to U+005A, U+005E to U+007E.
@@ skipping 28 matching lines @@
   com_initializer_.reset(new base::win::ScopedCOMInitializer(
       base::win::ScopedCOMInitializer::kMTA));
 }
 
 void DeviceThread::CleanUp() {
   com_initializer_.reset();
 }
 #endif
 
 // TODO(xians): Merge DeviceRequest with MediaStreamRequest.
-struct MediaStreamManager::DeviceRequest {
-  enum RequestState {
-    STATE_NOT_REQUESTED = 0,
-    STATE_REQUESTED,
-    STATE_PENDING_APPROVAL,
-    STATE_OPENING,
-    STATE_DONE,
-    STATE_ERROR
-  };
-
+class MediaStreamManager::DeviceRequest {

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

Nice, thanks.

+ public:
   enum RequestType {
     GENERATE_STREAM = 0,
     ENUMERATE_DEVICES,
     OPEN_DEVICE
   };
 
   DeviceRequest()
       : requester(NULL),
-        state(content::NUM_MEDIA_TYPES, STATE_NOT_REQUESTED),
         type(GENERATE_STREAM),
         render_process_id(-1),
-        render_view_id(-1) {
+        render_view_id(-1),
+        state_(content::NUM_MEDIA_TYPES,
+               MediaStreamRequest::STATE_NOT_REQUESTED) {
   }
 
   DeviceRequest(MediaStreamRequester* requester,
                 const StreamOptions& request_options,
                 int render_process_id,
                 int render_view_id,
                 const GURL& request_security_origin)
       : requester(requester),
         options(request_options),
-        state(content::NUM_MEDIA_TYPES, STATE_NOT_REQUESTED),
         type(GENERATE_STREAM),
         render_process_id(render_process_id),
         render_view_id(render_view_id),
-        security_origin(request_security_origin) {
+        security_origin(request_security_origin),
+        state_(content::NUM_MEDIA_TYPES,
+               MediaStreamRequest::STATE_NOT_REQUESTED) {
     DCHECK(requester);
   }
 
   ~DeviceRequest() {}
 
   MediaStreamRequester* requester;
   StreamOptions options;
-  std::vector<RequestState> state;
   RequestType type;
   int render_process_id;
   int render_view_id;
   GURL security_origin;
   std::string requested_device_id;
   StreamDeviceInfoArray devices;
+
+  void setState(MediaStreamType stream_type,
+                MediaStreamRequest::RequestState new_state) {
+    state_[stream_type] = new_state;
+  }
+
+  MediaStreamRequest::RequestState getState(MediaStreamType stream_type) const {
+    return state_[stream_type];
+  }
+
+ private:
+  std::vector<MediaStreamRequest::RequestState> state_;
 };
 
+// Helper to update the request state and notify observers.
+static void UpdateRequestState(

[wjia(left Chromium), 2012/10/11 20:21:07]

I guess you need to call this function only when request is related to tab
capture. If you can guarantee the request->requested_device_id will not overlap
between regular device capture and tab capture, you can check the device_id
inside media_observer->OnMediaRequestStateChanged(). Otherwise, you need a way
to distinguish device capture and tab capture requests, such as new types in
RequestType. 

[justinlin, 2012/10/11 21:19:21]

Done. Changed the check to just use options.{video,audio}_type instead as
discussed.

+    MediaStreamManager::DeviceRequest* request,
+    MediaStreamType stream_type,
+    const MediaStreamRequest::RequestState new_state) {
+  request->setState(stream_type, new_state);
+
+  content::MediaObserver* media_observer =
+    content::GetContentClient()->browser()->GetMediaObserver();
+  if (media_observer == NULL)
+    return;
+  media_observer->OnMediaRequestStateChanged(
+    request->render_process_id,
+    request->render_view_id,
+    content::MediaStreamDevice(stream_type,
+                               request->requested_device_id,

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

Do we still notify the observer if requested_device_id is empty?

[justinlin, 2012/10/11 19:41:51]

Done. We could short-circuit it here with that condition if you'd like since we
would be the only ones using this now.

+                               request->requested_device_id),
+    new_state);
+}
+
 MediaStreamManager::EnumerationCache::EnumerationCache()
     : valid(false) {
 }
 
 MediaStreamManager::EnumerationCache::~EnumerationCache() {
 }
 
 bool MediaStreamManager::always_use_fake_devices_ = false;
 
 // static
@@ skipping 62 matching lines @@
     const StreamOptions& options, const std::string& device_id,
     const GURL& security_origin, std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Create a new request based on options.
   AddRequest(DeviceRequest(requester, options,
                            render_process_id, render_view_id,
                            security_origin),
              label);
   DeviceRequest& request = requests_[*label];
+  request.requested_device_id = device_id;
 
   // Get user confirmation to use the capture device.
   device_settings_->RequestCaptureDeviceUsage(*label,
                                               render_process_id,
                                               render_view_id,
                                               options,
                                               security_origin);
   // TODO(miu): We should ask the device manager whether a device with id
   // |device_id| actually exists.  Note that no such MediaStreamProvider API for
   // this currently exists.  Also, we don't have a user-friendly device name for
   // the infobar UI.
+  StreamDeviceInfoArray devices;
   if (content::IsAudioMediaType(options.audio_type)) {
-    request.state[options.audio_type] = DeviceRequest::STATE_PENDING_APPROVAL;
-    device_settings_->AvailableDevices(
-        *label, options.audio_type, StreamDeviceInfoArray(
-            1, StreamDeviceInfo(options.audio_type, device_id, device_id,
-                                false)));
+    // TODO(justinlin): Updating the state to requested and pending are no-ops
+    // in terms of the media manager, but these are the state changes we want to
+    // support in terms of extensions (which is registered as an observer).
+    UpdateRequestState(&request, options.audio_type,

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

Are you sure that you want to update the observer_ consecutively? I simply think
STATE_REQUESTED should not be used here.

[justinlin, 2012/10/11 19:41:51]

We might remove the "requested" state notification if it doesn't make sense to
have it later, but I think the observers should be notified of entering this
"state".

+                       MediaStreamRequest::STATE_REQUESTED);
+    UpdateRequestState(&request, options.audio_type,
+                       MediaStreamRequest::STATE_PENDING_APPROVAL);
+    devices.push_back(
+        StreamDeviceInfo(options.audio_type, device_id, device_id, false));
   }
   if (content::IsVideoMediaType(options.video_type)) {
-    request.state[options.video_type] = DeviceRequest::STATE_PENDING_APPROVAL;
-    device_settings_->AvailableDevices(
-        *label, options.video_type, StreamDeviceInfoArray(
-            1, StreamDeviceInfo(options.video_type, device_id, device_id,
-                                false)));
+    UpdateRequestState(&request, options.video_type,
+                       MediaStreamRequest::STATE_REQUESTED);
+    UpdateRequestState(&request, options.video_type,
+                       MediaStreamRequest::STATE_PENDING_APPROVAL);
+    devices.push_back(
+        StreamDeviceInfo(options.video_type, device_id, device_id, false));
   }
+  DevicesAccepted(*label, devices);

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

?? It is bypassing the infobar, don't you need users' approval on the access of
the devices?

[justinlin, 2012/10/11 19:41:51]

Yes, I think we eventually want to add a notification infobar that will tell the
user a current tab is being captured in the captured tab. We can't reuse the
approval infobar right now because the media request is typically made from the
context of an extension's background page (which has no visible UI). Long story
short, this is needed because if we do it in the context of the current page,
the stream gets lost if the user changes the URL, but we want the capture to
follow URL changes. So, we want to bypass for now. We can discuss this in
meeting if needed.

[wjia(left Chromium), 2012/10/11 20:21:07]

you need post a task, instead of calling DevicesAccepted directly, since the
requester might not have a chance to register the label yet (check
media_stream_dispatcher_host.cc).

[justinlin, 2012/10/11 21:19:21]

Done. Thanks.

 }
 
 void MediaStreamManager::CancelGenerateStream(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
     // The request isn't complete.
     if (!RequestDone(it->second)) {
       DeviceRequest& request = it->second;
       for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES;
            ++i) {
         const MediaStreamType stream_type = static_cast<MediaStreamType>(i);
-        if (request.state[stream_type] != DeviceRequest::STATE_OPENING) {
+        if (request.getState(stream_type) !=
+            MediaStreamRequest::STATE_OPENING) {
           continue;
         }
         for (StreamDeviceInfoArray::const_iterator device_it =
                  request.devices.begin();
              device_it != request.devices.end(); ++device_it) {
           if (device_it->stream_type == stream_type) {
             GetDeviceManager(stream_type)->Close(device_it->session_id);
           }
         }
       }
@@ skipping 14 matching lines @@
       StopEnumerateDevices(label);
       return;
     }
     for (StreamDeviceInfoArray::const_iterator device_it =
              it->second.devices.begin();
          device_it != it->second.devices.end(); ++device_it) {
       GetDeviceManager(device_it->stream_type)->Close(device_it->session_id);
     }
     if (it->second.type == DeviceRequest::GENERATE_STREAM &&
         RequestDone(it->second)) {
+      // Notify observers that this device is being closed.
+      for (MediaStreamType i = content::MEDIA_NO_SERVICE;
+           i != content::NUM_MEDIA_TYPES; ++i) {
+        if (it->second.getState(i) != MediaStreamRequest::STATE_NOT_REQUESTED)
+          UpdateRequestState(&it->second, i, MediaStreamRequest::STATE_CLOSING);

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

I think I have already asked the question before, but I might miss your
feedback, please correct me if you have already answered.
Lots code is shared by GenerateStream and GenerateStreamForDevice or other types
of requests, do you want to update the observer if it is not a TAB request?

[justinlin, 2012/10/11 19:41:51]

Right, for now probably not. Added short-circuit in the UpdateRequestState
function like you suggested in a previous comment so it doesn't notify if
there's no device_id.

+      }
       NotifyObserverDevicesClosed(&(it->second));
     }
     requests_.erase(it);
   }
 }
 
 void MediaStreamManager::EnumerateDevices(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
@@ skipping 19 matching lines @@
   }
 
   DeviceRequest new_request(requester, options,
                             render_process_id,
                             render_view_id,
                             security_origin);
   new_request.type = DeviceRequest::ENUMERATE_DEVICES;
 
   if (cache->valid) {
     // Cached device list of this type exists. Just send it out.
-    new_request.state[type] = DeviceRequest::STATE_REQUESTED;
+    UpdateRequestState(&new_request, type,
+                       MediaStreamRequest::STATE_REQUESTED);
     AddRequest(new_request, label);
     // Need to post a task since the requester won't have label till
     // this function returns.
     BrowserThread::PostTask(BrowserThread::IO,
         FROM_HERE,
         base::Bind(&MediaStreamManager::SendCachedDeviceList,
                    base::Unretained(this), cache, *label));
   } else {
     StartEnumeration(&new_request, label);
     StartMonitoring();
@@ skipping 83 matching lines @@
 
 void MediaStreamManager::StartEnumeration(
     DeviceRequest* new_request,
     std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES;
        ++i) {
     const MediaStreamType stream_type = static_cast<MediaStreamType>(i);
     if (Requested(new_request->options, stream_type)) {
-      new_request->state[stream_type] = DeviceRequest::STATE_REQUESTED;
+      UpdateRequestState(new_request, stream_type,
+                         MediaStreamRequest::STATE_REQUESTED);
       DCHECK_GE(active_enumeration_ref_count_[stream_type], 0);
       if (active_enumeration_ref_count_[stream_type] == 0) {
         ++active_enumeration_ref_count_[stream_type];
         GetDeviceManager(stream_type)->EnumerateDevices();
       }
     }
   }
 
   AddRequest(*new_request, label);
 }
@@ skipping 58 matching lines @@
         request = &(request_it->second);
         break;
       }
     }
   }
   if (request == NULL) {
     // The request doesn't exist.
     return;
   }
 
-  DCHECK_NE(request->state[stream_type], DeviceRequest::STATE_REQUESTED);
+  DCHECK_NE(request->getState(stream_type),
+            MediaStreamRequest::STATE_REQUESTED);
 
   // Check if all devices for this stream type are opened. Update the state if
   // they are.
   for (StreamDeviceInfoArray::iterator device_it = devices->begin();
        device_it != devices->end(); ++device_it) {
     if (device_it->stream_type != stream_type) {
       continue;
     }
     if (device_it->in_use == false) {
       // Wait for more devices to be opened before we're done.
       return;
     }
   }
-  request->state[stream_type] = DeviceRequest::STATE_DONE;
+
+  UpdateRequestState(request, stream_type, MediaStreamRequest::STATE_DONE);
 
   if (!RequestDone(*request)) {
     // This stream_type is done, but not the other type.
     return;
   }
 
   switch (request->type) {
     case DeviceRequest::OPEN_DEVICE:
       request->requester->DeviceOpened(label, devices->front());
       break;
@@ skipping 46 matching lines @@
     need_update_clients = true;
   }
 
   // Publish the result for all requests waiting for device list(s).
   // Find the requests waiting for this device list, store their labels and
   // release the iterator before calling device settings. We might get a call
   // back from device_settings that will need to iterate through devices.
   std::list<std::string> label_list;
   for (DeviceRequests::iterator it = requests_.begin(); it != requests_.end();
        ++it) {
-    if (it->second.state[stream_type] == DeviceRequest::STATE_REQUESTED &&
+    if (it->second.getState(stream_type) ==
+        MediaStreamRequest::STATE_REQUESTED &&
         Requested(it->second.options, stream_type)) {
       if (it->second.type != DeviceRequest::ENUMERATE_DEVICES)
-        it->second.state[stream_type] = DeviceRequest::STATE_PENDING_APPROVAL;
+        UpdateRequestState(&it->second, stream_type,
+                           MediaStreamRequest::STATE_PENDING_APPROVAL);
       label_list.push_back(it->first);
     }
   }
   for (std::list<std::string>::iterator it = label_list.begin();
        it != label_list.end(); ++it) {
     DeviceRequest& request = requests_[*it];
     switch (request.type) {
       case DeviceRequest::ENUMERATE_DEVICES:
         if (need_update_clients)
           request.requester->DevicesEnumerated(*it, devices);
         break;
       case DeviceRequest::OPEN_DEVICE:
         DCHECK(!request.requested_device_id.empty());
         for (StreamDeviceInfoArray::const_iterator device_it = devices.begin();
              device_it != devices.end(); ++device_it) {
           if (request.requested_device_id == device_it->device_id) {
             StreamDeviceInfo device = *device_it;
             device.in_use = false;
             device.session_id =
                 GetDeviceManager(device_it->stream_type)->Open(device);
-            request.state[device_it->stream_type] =
-                DeviceRequest::STATE_OPENING;
+            UpdateRequestState(&request, device_it->stream_type,
+                               MediaStreamRequest::STATE_OPENING);
             request.devices.push_back(device);
             break;
           }
         }
         break;
       default:
         device_settings_->AvailableDevices(*it, stream_type, devices);
         break;
     }
   }
@@ skipping 27 matching lines @@
         NOTREACHED();
         continue;
       }
       if (device_it->stream_type != stream_type ||
           device_it->session_id != capture_session_id) {
         continue;
       }
       // We've found the failing device. Find the error case:
       // An error should only be reported to the MediaStreamManager if
       // the request has not been fulfilled yet.
-      DCHECK(it->second.state[stream_type] != DeviceRequest::STATE_DONE);
-      if (it->second.state[stream_type] != DeviceRequest::STATE_DONE) {
+      DCHECK(it->second.getState(stream_type)
+             != MediaStreamRequest::STATE_DONE);
+      if (it->second.getState(stream_type) != MediaStreamRequest::STATE_DONE) {
         // Request is not done, devices are not opened in this case.
         if (devices.size() <= 1) {
           // 1. Device not opened and no other devices for this request ->
           //    signal stream error and remove the request.
           it->second.requester->StreamGenerationFailed(it->first);
           requests_.erase(it);
         } else {
           // 2. Not opened but other devices exists for this request -> remove
           //    device from list, but don't signal an error.
           devices.erase(device_it);  // NOTE: This invalidates device_it!
@@ skipping 23 matching lines @@
 
   // Process all newly-accepted devices for this request.
   bool found_audio = false, found_video = false;
   for (StreamDeviceInfoArray::const_iterator device_it = devices.begin();
        device_it != devices.end(); ++device_it) {
     StreamDeviceInfo device_info = *device_it;  // Make a copy.
 
     // Set in_use to false to be able to track if this device has been
     // opened. in_use might be true if the device type can be used in more
     // than one session.
-    DCHECK_EQ(request.state[device_it->stream_type],
-              DeviceRequest::STATE_PENDING_APPROVAL);
+    DCHECK_EQ(request.getState(device_it->stream_type),
+              MediaStreamRequest::STATE_PENDING_APPROVAL);
     device_info.in_use = false;
+
     device_info.session_id =
         GetDeviceManager(device_info.stream_type)->Open(device_info);
-    request.state[device_it->stream_type] = DeviceRequest::STATE_OPENING;
+    UpdateRequestState(&request, device_it->stream_type,
+                       MediaStreamRequest::STATE_OPENING);
     request.devices.push_back(device_info);
 
     if (device_info.stream_type == request.options.audio_type) {
       found_audio = true;
     } else if (device_info.stream_type == request.options.video_type) {
       found_video = true;
     }
   }
 
   // Check whether we've received all stream types requested.
   if (!found_audio && content::IsAudioMediaType(request.options.audio_type)) {
-    request.state[request.options.audio_type] = DeviceRequest::STATE_ERROR;
+    UpdateRequestState(&request, request.options.audio_type,
+                       MediaStreamRequest::STATE_ERROR);
   }
   if (!found_video && content::IsVideoMediaType(request.options.video_type)) {
-    request.state[request.options.video_type] = DeviceRequest::STATE_ERROR;
+    UpdateRequestState(&request, request.options.video_type,
+                       MediaStreamRequest::STATE_ERROR);
   }
 }
 
 void MediaStreamManager::SettingsError(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Erase this request and report an error.
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
     DCHECK_EQ(it->second.type, DeviceRequest::GENERATE_STREAM);
     it->second.requester->StreamGenerationFailed(label);
@@ skipping 63 matching lines @@
 
 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   const bool requested_audio =
       content::IsAudioMediaType(request.options.audio_type);
   const bool requested_video =
       content::IsVideoMediaType(request.options.video_type);
 
   const bool audio_done =
-      !requested_audio ||
-      request.state[request.options.audio_type] == DeviceRequest::STATE_DONE ||
-      request.state[request.options.audio_type] == DeviceRequest::STATE_ERROR;
+      !requested_audio || request.getState(request.options.audio_type) ==
+      MediaStreamRequest::STATE_DONE ||
+      request.getState(request.options.audio_type) ==
+      MediaStreamRequest::STATE_ERROR;
   if (!audio_done) {
     return false;
   }
 
   const bool video_done =
-      !requested_video ||
-      request.state[request.options.video_type] == DeviceRequest::STATE_DONE ||
-      request.state[request.options.video_type] == DeviceRequest::STATE_ERROR;
+      !requested_video || request.getState(request.options.video_type) ==
+      MediaStreamRequest::STATE_DONE ||
+      request.getState(request.options.video_type) ==
+      MediaStreamRequest::STATE_ERROR;
   if (!video_done) {
     return false;
   }
 
   for (StreamDeviceInfoArray::const_iterator it = request.devices.begin();
        it != request.devices.end(); ++it) {
     if (it->in_use == false) {
       return false;
     }
   }
@@ skipping 63 matching lines @@
        it != requests_.end(); ++it) {
     if (it->second.type == DeviceRequest::ENUMERATE_DEVICES &&
         Requested(it->second.options, stream_type)) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace media_stream