Create CanvasCaptureMediaStreamTrack in a regular MediaStream

This CL handles the recent spec change where we decided to
return a specialized CanvasCaptureMediaStreamTrack object
instead of a CanvasCaptureMediaStream from a
canvas::captureStream() call.

BUG=524218
TEST=Ran the demos listed in [0] with MediaCaptureFromElement flag enabled.
[0] https://docs.google.com/document/d/1JmWfOtUP6ZqsYJ--U8y0OtHkBt-VyjX4N-JqIjb1t78/edit#heading=h.gee451fatrq7
TBR=esprehn@chromium.org on third_party/WebKit/public/platform/Platform.h

Review URL: https://codereview.chromium.org/1505013002

Cr-Commit-Position: refs/heads/master@{#364602}

4 files changed, 56 insertions, 11 deletions

diff --git a/content/renderer/media/canvas_capture_handler.cc b/content/renderer/media/canvas_capture_handler.cc
index bb26e24..7e1e8e7 100644
--- a/content/renderer/media/canvas_capture_handler.cc
+++ b/content/renderer/media/canvas_capture_handler.cc
@@ -4,10 +4,17 @@
 
 #include "content/renderer/media/canvas_capture_handler.h"
 
+#include "base/base64.h"
 #include "base/bind_helpers.h"
-#include "content/public/renderer/media_stream_api.h"
+#include "base/rand_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "content/public/renderer/render_thread.h"
+#include "content/renderer/media/media_stream_video_capturer_source.h"
+#include "content/renderer/media/media_stream_video_source.h"
+#include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/render_thread_impl.h"
+#include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
+#include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 namespace content {
@@ -86,7 +93,7 @@ class CanvasCaptureHandler::CanvasCaptureHandlerDelegate {
 
 CanvasCaptureHandler::CanvasCaptureHandler(const blink::WebSize& size,
                                            double frame_rate,
-                                           blink::WebMediaStream* stream)
+                                           blink::WebMediaStreamTrack* track)
     : ask_for_new_frame_(false),
       size_(size),
       io_task_runner_(content::RenderThread::Get()->GetIOMessageLoopProxy()),
@@ -94,7 +101,7 @@ CanvasCaptureHandler::CanvasCaptureHandler(const blink::WebSize& size,
   scoped_ptr<media::VideoCapturerSource> video_source(
       new CanvasCaptureHandler::VideoCapturerSource(
           weak_ptr_factory_.GetWeakPtr(), frame_rate));
-  content::AddVideoTrackToMediaStream(video_source.Pass(), false, true, stream);
+  AddVideoCapturerSourceToVideoTrack(video_source.Pass(), track);
 }
 
 CanvasCaptureHandler::~CanvasCaptureHandler() {
@@ -175,4 +182,26 @@ void CanvasCaptureHandler::CreateNewFrame(const blink::WebSkImage& image) {
                  base::TimeTicks()));
 }
 
+void CanvasCaptureHandler::AddVideoCapturerSourceToVideoTrack(
+    scoped_ptr<media::VideoCapturerSource> source,
+    blink::WebMediaStreamTrack* web_track) {
+  std::string str_track_id;
+  base::Base64Encode(base::RandBytesAsString(64), &str_track_id);
+  const blink::WebString track_id = base::UTF8ToUTF16(str_track_id);
+  blink::WebMediaStreamSource webkit_source;
+  scoped_ptr<MediaStreamVideoSource> media_stream_source(
+      new MediaStreamVideoCapturerSource(
+          MediaStreamSource::SourceStoppedCallback(), source.Pass()));
+  webkit_source.initialize(track_id, blink::WebMediaStreamSource::TypeVideo,
+                           track_id, false, true);
+  webkit_source.setExtraData(media_stream_source.get());
+
+  web_track->initialize(webkit_source);
+  blink::WebMediaConstraints constraints;
+  constraints.initialize();
+  web_track->setExtraData(new MediaStreamVideoTrack(
+      media_stream_source.release(), constraints,
+      MediaStreamVideoSource::ConstraintsCallback(), true));
+}
+
 }  // namespace content
diff --git a/content/renderer/media/canvas_capture_handler.h b/content/renderer/media/canvas_capture_handler.h
index 05e5bdc..b2a5cc2 100644
--- a/content/renderer/media/canvas_capture_handler.h
+++ b/content/renderer/media/canvas_capture_handler.h
@@ -13,19 +13,33 @@
 #include "media/base/video_capturer_source.h"
 #include "media/base/video_frame_pool.h"
 #include "third_party/WebKit/public/platform/WebCanvasCaptureHandler.h"
-#include "third_party/WebKit/public/platform/WebMediaStream.h"
+#include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebSkImage.h"
 #include "third_party/skia/include/core/SkImage.h"
 
 namespace content {
 
+// CanvasCaptureHandler acts as the link between blink side HTMLCanvasElement
+// and Chrome side VideoCapturerSource. It is responsible for handling
+// WebSkImage instances sent from the blink side, convert them to
+// media::VideoFrame and plug them to the MediaStreamTrack.
+// CanvasCaptureHandler instance is owned by a blink::CanvasDrawListener which
+// is owned by a CanvasCaptureMediaStreamTrack.
+// All methods are called on the same thread as construction and destruction,
+// i.e. the Main Render thread. Note that a CanvasCaptureHandlerDelegate is
+// used to send back frames on the IO thread.
 class CONTENT_EXPORT CanvasCaptureHandler final
     : public NON_EXPORTED_BASE(blink::WebCanvasCaptureHandler) {
  public:
+  // A VideoCapturerSource instance is created, which is responsible for handing
+  // stop&start callbacks back to CanvasCaptureHandler. That VideoCapturerSource
+  // is then plugged into a MediaStreamTrack passed as |track|, and it is owned
+  // by the blink side MediaStreamSource.
   CanvasCaptureHandler(const blink::WebSize& size,
                        double frame_rate,
-                       blink::WebMediaStream* stream);
+                       blink::WebMediaStreamTrack* track);
+  ~CanvasCaptureHandler() override;
 
   // blink::WebCanvasCaptureHandler Implementation.
   void sendNewFrame(const blink::WebSkImage& image) override;
@@ -41,13 +55,15 @@ class CONTENT_EXPORT CanvasCaptureHandler final
   blink::WebSize GetSourceSize() const { return size_; }
 
  private:
-  ~CanvasCaptureHandler() override;
-
   void CreateNewFrame(const blink::WebSkImage& image);
+  void AddVideoCapturerSourceToVideoTrack(
+      scoped_ptr<media::VideoCapturerSource> source,
+      blink::WebMediaStreamTrack* web_track);
 
   // Implementation VideoCapturerSource that is owned by blink and delegates
   // the Start/Stop calls to CanvasCaptureHandler.
   class VideoCapturerSource;
+
   // Object that does all the work of running |new_frame_callback_|.
   // Destroyed on |io_task_runner_| after the class is destroyed.
   class CanvasCaptureHandlerDelegate;
diff --git a/content/renderer/renderer_blink_platform_impl.cc b/content/renderer/renderer_blink_platform_impl.cc
index 1c1102b..a47eec7 100644
--- a/content/renderer/renderer_blink_platform_impl.cc
+++ b/content/renderer/renderer_blink_platform_impl.cc
@@ -148,9 +148,9 @@ using blink::WebGamepads;
 using blink::WebIDBFactory;
 using blink::WebMIDIAccessor;
 using blink::WebMediaRecorderHandler;
-using blink::WebMediaStream;
 using blink::WebMediaStreamCenter;
 using blink::WebMediaStreamCenterClient;
+using blink::WebMediaStreamTrack;
 using blink::WebMimeRegistry;
 using blink::WebRTCPeerConnectionHandler;
 using blink::WebRTCPeerConnectionHandlerClient;
@@ -944,9 +944,9 @@ bool RendererBlinkPlatformImpl::SetSandboxEnabledForTesting(bool enable) {
 WebCanvasCaptureHandler* RendererBlinkPlatformImpl::createCanvasCaptureHandler(
     const WebSize& size,
     double frame_rate,
-    WebMediaStream* stream) {
+    WebMediaStreamTrack* track) {
 #if defined(ENABLE_WEBRTC)
-  return new CanvasCaptureHandler(size, frame_rate, stream);
+  return new CanvasCaptureHandler(size, frame_rate, track);
 #else
   return nullptr;
 #endif  // defined(ENABLE_WEBRTC)
diff --git a/content/renderer/renderer_blink_platform_impl.h b/content/renderer/renderer_blink_platform_impl.h
index 61496fd..226137a 100644
--- a/content/renderer/renderer_blink_platform_impl.h
+++ b/content/renderer/renderer_blink_platform_impl.h
@@ -146,7 +146,7 @@ class CONTENT_EXPORT RendererBlinkPlatformImpl : public BlinkPlatformImpl {
   blink::WebCanvasCaptureHandler* createCanvasCaptureHandler(
       const blink::WebSize& size,
       double frame_rate,
-      blink::WebMediaStream* stream) override;
+      blink::WebMediaStreamTrack* track) override;
   blink::WebGraphicsContext3D* createOffscreenGraphicsContext3D(
       const blink::WebGraphicsContext3D::Attributes& attributes) override;
   blink::WebGraphicsContext3D* createOffscreenGraphicsContext3D(