create a separate WebMediaPlayer for URL derived from media stream

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/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "content/common/child_thread.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_dependency_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/peer_connection_handler_jsep.h"
+#include "content/renderer/media/rtc_video_renderer.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/ipc_socket_factory.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "media/base/message_loop_factory.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"
@@ skipping 159 matching lines @@
     media_stream_dispatcher_->CancelGenerateStream(it->first);
     user_media_requests_.erase(it);
   }
 }
 
 WebKit::WebMediaStreamDescriptor MediaStreamImpl::GetMediaStream(
     const GURL& url) {
   return WebKit::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url);
 }
 
+bool MediaStreamImpl::IsMediaStream(const GURL& url) {
+  DCHECK(CalledOnValidThread());
+  WebKit::WebMediaStreamDescriptor descriptor(GetMediaStream(url));
+
+  if (descriptor.isNull() || !descriptor.extraData())
+    return false;  // This is not a valid stream.
+
+  MediaStreamExtraData* extra_data =
+      static_cast<MediaStreamExtraData*>(descriptor.extraData());
+  webrtc::MediaStreamInterface* stream = extra_data->local_stream();
+  if (stream && stream->video_tracks() && stream->video_tracks()->count() > 0)
+    return true;
+  stream = extra_data->remote_stream();
+  if (stream && stream->video_tracks() && stream->video_tracks()->count() > 0)
+    return true;
+  return false;
+}
+
+scoped_refptr<webkit_media::VideoFrameProvider>
+MediaStreamImpl::GetVideoFrameProvider(
+    const GURL& url,
+    const base::Closure& error_cb,
+    const webkit_media::VideoFrameProvider::RepaintCB& repaint_cb) {
+  DCHECK(CalledOnValidThread());
+  WebKit::WebMediaStreamDescriptor descriptor(GetMediaStream(url));
+
+  if (descriptor.isNull() || !descriptor.extraData())
+    return NULL;  // This is not a valid stream.
+
+  DVLOG(1) << "MediaStreamImpl::GetVideoFrameProvider stream:"
+           << UTF16ToUTF8(descriptor.label());
+
+  MediaStreamExtraData* extra_data =
+      static_cast<MediaStreamExtraData*>(descriptor.extraData());
+  if (extra_data->local_stream())
+    return CreateLocalVideoFrameProvider(extra_data->local_stream(),
+                                         error_cb, repaint_cb);
+  if (extra_data->remote_stream())
+    return CreateRemoteVideoFrameProvider(extra_data->remote_stream(),
+                                          error_cb, repaint_cb);
+  NOTREACHED();
+  return NULL;
+}
+
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::GetVideoDecoder(
     const GURL& url,
     media::MessageLoopFactory* message_loop_factory) {
   DCHECK(CalledOnValidThread());
   WebKit::WebMediaStreamDescriptor descriptor(GetMediaStream(url));
 
   if (descriptor.isNull() || !descriptor.extraData())
     return NULL;  // This is not a valid stream.
 
   DVLOG(1) << "MediaStreamImpl::GetVideoDecoder stream:"
@@ skipping 247 matching lines @@
       // processed before returning. We wait for the above task to finish before
       // letting the the function continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
     p2p_socket_dispatcher_->RemoveDestructionObserver(this);
   }
 }
 
+scoped_refptr<webkit_media::VideoFrameProvider>
+MediaStreamImpl::CreateLocalVideoFrameProvider(
+    webrtc::MediaStreamInterface* stream,
+    const base::Closure& error_cb,
+    const webkit_media::VideoFrameProvider::RepaintCB& repaint_cb) {
+  if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
+    return NULL;
+
+  int video_session_id =
+      media_stream_dispatcher_->video_session_id(stream->label(), 0);
+  media::VideoCaptureCapability capability;
+  capability.width = kVideoCaptureWidth;
+  capability.height = kVideoCaptureHeight;
+  capability.frame_rate = kVideoCaptureFramePerSecond;
+  capability.color = media::VideoCaptureCapability::kI420;
+  capability.expected_capture_delay = 0;
+  capability.interlaced = false;
+
+  DVLOG(1) << "MediaStreamImpl::CreateLocalVideoFrameProvider video_session_id:"
+           << video_session_id;
+
+  return new content::LocalVideoCapture(
+      video_session_id,
+      vc_manager_.get(),
+      capability,
+      error_cb,
+      repaint_cb);
+}
+
+scoped_refptr<webkit_media::VideoFrameProvider>
+MediaStreamImpl::CreateRemoteVideoFrameProvider(
+    webrtc::MediaStreamInterface* stream,
+    const base::Closure& error_cb,
+    const webkit_media::VideoFrameProvider::RepaintCB& repaint_cb) {
+  if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
+    return NULL;
+
+  DVLOG(1) << "MediaStreamImpl::CreateRemoteVideoFrameProvider label:"
+           << stream->label();
+
+  return new content::RTCVideoRenderer(
+      stream->video_tracks()->at(0),
+      error_cb,
+      repaint_cb);
+}
+
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::CreateLocalVideoDecoder(
     webrtc::MediaStreamInterface* stream,
     media::MessageLoopFactory* message_loop_factory) {
   if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
     return NULL;
 
   int video_session_id =
       media_stream_dispatcher_->video_session_id(stream->label(), 0);
   media::VideoCaptureCapability capability;
   capability.width = kVideoCaptureWidth;
@@ skipping 79 matching lines @@
 MediaStreamExtraData::MediaStreamExtraData(
     webrtc::MediaStreamInterface* remote_stream)
     : remote_stream_(remote_stream) {
 }
 MediaStreamExtraData::MediaStreamExtraData(
     webrtc::LocalMediaStreamInterface* local_stream)
     : local_stream_(local_stream) {
 }
 MediaStreamExtraData::~MediaStreamExtraData() {
 }