Media Related changes for TabCapture API

content/renderer/media/media_stream_impl.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/renderer/media/media_stream_impl.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "content/renderer/media/capture_video_decoder.h"
 #include "content/renderer/media/local_video_capture.h"
 #include "content/renderer/media/media_stream_extra_data.h"
 #include "content/renderer/media/media_stream_source_extra_data.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/rtc_video_decoder.h"
 #include "content/renderer/media/rtc_video_renderer.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "media/base/message_loop_factory.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebMediaConstraints.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaStreamRegistry.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamComponent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamDescriptor.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 
 namespace {
+
 const int kVideoCaptureWidth = 640;
 const int kVideoCaptureHeight = 480;
 const int kVideoCaptureFramePerSecond = 30;
+
+const char kExtensionScheme[] = "chrome-extension";
+
+std::string GetMandatoryStreamConstraint(
+    const WebKit::WebMediaConstraints& constraints, const std::string& key) {
+  if (constraints.isNull())
+    return std::string();
+
+  WebKit::WebString value;
+  constraints.getMandatoryConstraintValue(UTF8ToUTF16(key), value);
+  return UTF16ToUTF8(value);
+}
+
+void UpdateOptionsIfTabMediaRequest(
+    const WebKit::WebUserMediaRequest& user_media_request,
+    media_stream::StreamOptions* options) {
+  if (options->audio_type != content::MEDIA_NO_SERVICE &&
+      GetMandatoryStreamConstraint(user_media_request.audioConstraints(),
+                                   media_stream::kMediaStreamSource) ==
+                                   media_stream::kMediaStreamSourceTab) {

[miu, 2012/10/12 01:10:50]

nit: Indentation.  Consider putting this 4 chars to the right of
GetMandatoryStreamConstraint's indentation.

[justinlin, 2012/10/12 03:02:31]

Done.

+    options->audio_type = content::MEDIA_TAB_AUDIO_CAPTURE;
+    options->audio_device_id = GetMandatoryStreamConstraint(
+        user_media_request.audioConstraints(),
+        media_stream::kMediaStreamSourceId);
+  }
+
+  if (options->video_type != content::MEDIA_NO_SERVICE &&
+      GetMandatoryStreamConstraint(user_media_request.videoConstraints(),
+                                   media_stream::kMediaStreamSource) ==
+                                   media_stream::kMediaStreamSourceTab) {

[miu, 2012/10/12 01:10:50]

nit: ditto on indentation.

[justinlin, 2012/10/12 03:02:31]

Done.

+    options->video_type = content::MEDIA_TAB_VIDEO_CAPTURE;
+    options->video_device_id = GetMandatoryStreamConstraint(
+        user_media_request.videoConstraints(),
+        media_stream::kMediaStreamSourceId);
+  }
+}
+
 }  // namespace
 
 static int g_next_request_id  = 0;
 
 // Creates a WebKit representation of a stream sources based on
 // |devices| from the MediaStreamDispatcher.
 static void CreateWebKitSourceVector(
     const std::string& label,
     const media_stream::StreamDeviceInfoArray& devices,
     WebKit::WebMediaStreamSource::Type type,
@@ skipping 35 matching lines @@
 void MediaStreamImpl::requestUserMedia(
     const WebKit::WebUserMediaRequest& user_media_request,
     const WebKit::WebVector<WebKit::WebMediaStreamSource>& audio_sources,
     const WebKit::WebVector<WebKit::WebMediaStreamSource>& video_sources) {
   // Save histogram data so we can see how much GetUserMedia is used.
   // The histogram counts the number of calls to the JS API
   // webGetUserMedia.
   UpdateWebRTCMethodCount(WEBKIT_GET_USER_MEDIA);
   DCHECK(CalledOnValidThread());
   int request_id = g_next_request_id++;
-  bool audio = false;
-  bool video = false;
+  media_stream::StreamOptions options(content::MEDIA_NO_SERVICE,
+                                      content::MEDIA_NO_SERVICE);
   WebKit::WebFrame* frame = NULL;
   GURL security_origin;
 
   // |user_media_request| can't be mocked. So in order to test at all we check
   // if it isNull.
   if (user_media_request.isNull()) {
     // We are in a test.
-    audio = audio_sources.size() > 0;
-    video = video_sources.size() > 0;
+    if (audio_sources.size() > 0)
+      options.audio_type = content::MEDIA_DEVICE_AUDIO_CAPTURE;
+    if (video_sources.size() > 0)
+      options.video_type = content::MEDIA_DEVICE_VIDEO_CAPTURE;
   } else {
-    audio = user_media_request.audio();
-    video = user_media_request.video();
+    if (user_media_request.audio())
+      options.audio_type = content::MEDIA_DEVICE_AUDIO_CAPTURE;
+    if (user_media_request.video())
+      options.video_type = content::MEDIA_DEVICE_VIDEO_CAPTURE;
+
     security_origin = GURL(user_media_request.securityOrigin().toString());
     // Get the WebFrame that requested a MediaStream.
     // The frame is needed to tell the MediaStreamDispatcher when a stream goes
     // out of scope.
     frame = user_media_request.ownerDocument().frame();
     DCHECK(frame);
   }
 
+  UpdateOptionsIfTabMediaRequest(user_media_request, &options);

[wjia(left Chromium), 2012/10/11 22:13:27]

Do we need any check after this function returns? E.g., DEVICE_*_CAPTURE will
not pair with TAB_*_CAPTURE?

[justinlin, 2012/10/12 00:50:22]

Good observation! Right now, this can't really happen because the tab capture
stuff can only be used from an extension API, which will force audio/video
streams to tab type or none. Conversely, you can't use the tab stuff from a
non-extension. Maybe, in the future we would want video and tab streams to be
compatible (i.e. use tab video with mic audio?), but that would take some
refactoring since we branch in the browser process depending on what was
requested. Added a check in GenerateStreamForDevice just to future-proof this a
bit.

+
   DVLOG(1) << "MediaStreamImpl::generateStream(" << request_id << ", [ "
-           << (audio ? "audio" : "")
-           << (user_media_request.video() ? " video" : "") << "], "
+           << (options.audio_type ? "audio" : "")

[miu, 2012/10/12 01:10:50]

nit: Consider replacing these with the following so the logging is more useful:

  << "audio=" << options.audio_type
  << ", video=" << options.video_type
  << "], "

[justinlin, 2012/10/12 03:02:31]

Done. Thanks.

+           << (options.video_type ? " video" : "") << "], "
            << security_origin.spec() << ")";
 
   user_media_requests_[request_id] =
       UserMediaRequestInfo(frame, user_media_request);
 
   media_stream_dispatcher_->GenerateStream(
       request_id,
       AsWeakPtr(),
-      media_stream::StreamOptions(audio, video),
+      options,
       security_origin);
 }
 
 void MediaStreamImpl::cancelUserMediaRequest(
     const WebKit::WebUserMediaRequest& user_media_request) {
   DCHECK(CalledOnValidThread());
   MediaRequestMap::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if (it->second.request_ == user_media_request)
       break;
@@ skipping 325 matching lines @@
 
 void MediaStreamExtraData::SetLocalStreamStopCallback(
     const StreamStopCallback& stop_callback) {
   stream_stop_callback_ = stop_callback;
 }
 
 void MediaStreamExtraData::OnLocalStreamStop() {
   if (!stream_stop_callback_.is_null())
     stream_stop_callback_.Run(local_stream_->label());
 }