Wip - cl for implemening VideoTrackSource::ApplyConstraints(constraints, VideoTrack) and adopt safe…

content/renderer/media/canvas_capture_handler.cc

 // Copyright 2015 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/canvas_capture_handler.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind_helpers.h"
@@ skipping 103 matching lines @@
   const media::VideoCapturerSource::VideoCaptureDeliverFrameCB
       new_frame_callback_;
   // Bound to IO thread.
   base::ThreadChecker io_thread_checker_;
   base::WeakPtrFactory<CanvasCaptureHandlerDelegate> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CanvasCaptureHandlerDelegate);
 };
 
 CanvasCaptureHandler::CanvasCaptureHandler(
-    const blink::WebSize& size,
-    double frame_rate,
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    blink::WebMediaStreamTrack* track)
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : ask_for_new_frame_(false),
-      size_(size),
       io_task_runner_(io_task_runner),
       weak_ptr_factory_(this) {
-  std::unique_ptr<media::VideoCapturerSource> video_source(
-      new VideoCapturerSource(weak_ptr_factory_.GetWeakPtr(), frame_rate));
-  AddVideoCapturerSourceToVideoTrack(std::move(video_source), track);
 }
 
 CanvasCaptureHandler::~CanvasCaptureHandler() {
   DVLOG(3) << __func__;
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   io_task_runner_->DeleteSoon(FROM_HERE, delegate_.release());
 }
 
 // static
 CanvasCaptureHandler* CanvasCaptureHandler::CreateCanvasCaptureHandler(
-    const blink::WebSize& size,
-    double frame_rate,
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    blink::WebMediaStreamTrack* track) {
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner) {
   // Save histogram data so we can see how much CanvasCapture is used.
   // The histogram counts the number of calls to the JS API.
   UpdateWebRTCMethodCount(WEBKIT_CANVAS_CAPTURE_STREAM);
 
-  return new CanvasCaptureHandler(size, frame_rate, io_task_runner, track);
+  return new CanvasCaptureHandler(io_task_runner);
+}
+
+blink::WebMediaStreamTrack CanvasCaptureHandler::createTrack(
+    const blink::WebSize& size, double frame_rate) {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  size_ = size;
+  std::unique_ptr<media::VideoCapturerSource> video_source(
+        new VideoCapturerSource(weak_ptr_factory_.GetWeakPtr(), frame_rate));
+  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;
+  std::unique_ptr<MediaStreamVideoSource> media_stream_source(
+      new MediaStreamVideoCapturerSource(
+          MediaStreamSource::SourceStoppedCallback(), std::move(video_source)));
+  webkit_source.initialize(track_id, blink::WebMediaStreamSource::TypeVideo,
+                           track_id, false);
+  webkit_source.setExtraData(media_stream_source.get());
+  return MediaStreamVideoTrack::CreateVideoTrack(media_stream_source.release());
 }
 
 void CanvasCaptureHandler::sendNewFrame(const SkImage* image) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   CreateNewFrame(image);
 }
 
 bool CanvasCaptureHandler::needsNewFrame() const {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   return ask_for_new_frame_;
@@ skipping 80 matching lines @@
                              size.width(), size.height());
   }
 
   last_frame_ = video_frame;
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CanvasCaptureHandler::CanvasCaptureHandlerDelegate::
                      SendNewFrameOnIOThread,
                  delegate_->GetWeakPtrForIOThread(), video_frame, timestamp));
 }
-
-void CanvasCaptureHandler::AddVideoCapturerSourceToVideoTrack(
-    std::unique_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;
-  std::unique_ptr<MediaStreamVideoSource> media_stream_source(
-      new MediaStreamVideoCapturerSource(
-          MediaStreamSource::SourceStoppedCallback(), std::move(source)));
-  webkit_source.initialize(track_id, blink::WebMediaStreamSource::TypeVideo,
-                           track_id, false);
-  webkit_source.setExtraData(media_stream_source.get());
-
-  web_track->initialize(webkit_source);
-  blink::WebMediaConstraints constraints;
-  constraints.initialize();
-  web_track->setTrackData(new MediaStreamVideoTrack(
-      media_stream_source.release(), constraints,
-      MediaStreamVideoSource::ConstraintsCallback(), true));
-}
-
 }  // namespace content