HTMLMediaElementCapture: use Blink-provided foreground task runner

This is part of efforts to replace base::ThreadTaskRunnerHandle::Get()
with other appropriate task runners in the renderer.

Bug: 786332
Change-Id: I431671dc03fa7157c25433575c3cdd5cf75d098a
Reviewed-on: https://chromium-review.googlesource.com/808447Reviewed-by: Miguel Casas <mcasas@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Mounir Lamouri <mlamouri@chromium.org>
Commit-Queue: Hajime Hoshi <hajimehoshi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#523734}

content/renderer/media_capture_from_element/html_video_element_capturer_source.cc

@@ -31,21 +31,24 @@ namespace content {
 std::unique_ptr<HtmlVideoElementCapturerSource>
 HtmlVideoElementCapturerSource::CreateFromWebMediaPlayerImpl(
     blink::WebMediaPlayer* player,
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner) {
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   // Save histogram data so we can see how much HTML Video capture is used.
   // The histogram counts the number of calls to the JS API.
   UpdateWebRTCMethodCount(WEBKIT_VIDEO_CAPTURE_STREAM);
 
   return base::WrapUnique(new HtmlVideoElementCapturerSource(
       static_cast<media::WebMediaPlayerImpl*>(player)->AsWeakPtr(),
-      io_task_runner));
+      io_task_runner, task_runner));
 }
 
 HtmlVideoElementCapturerSource::HtmlVideoElementCapturerSource(
     const base::WeakPtr<blink::WebMediaPlayer>& player,
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : web_media_player_(player),
       io_task_runner_(io_task_runner),
+      task_runner_(task_runner),
       capture_frame_rate_(0.0),
       weak_factory_(this) {
   DCHECK(web_media_player_);
@@ -181,7 +184,7 @@ void HtmlVideoElementCapturerSource::sendNewFrame() {
       next_capture_time_ = current_time;
   }
   // Schedule next capture.
-  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+  task_runner_->PostDelayedTask(
       FROM_HERE,
       base::BindOnce(&HtmlVideoElementCapturerSource::sendNewFrame,
                      weak_factory_.GetWeakPtr()),

content/renderer/media_capture_from_element/html_video_element_capturer_source.h

@@ -40,11 +40,13 @@ class CONTENT_EXPORT HtmlVideoElementCapturerSource final
   static std::unique_ptr<HtmlVideoElementCapturerSource>
   CreateFromWebMediaPlayerImpl(
       blink::WebMediaPlayer* player,
-      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
+      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   HtmlVideoElementCapturerSource(
       const base::WeakPtr<blink::WebMediaPlayer>& player,
-      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
+      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~HtmlVideoElementCapturerSource() override;
 
   // media::VideoCapturerSource Implementation.
@@ -65,6 +67,7 @@ class CONTENT_EXPORT HtmlVideoElementCapturerSource final
 
   const base::WeakPtr<blink::WebMediaPlayer> web_media_player_;
   const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // These three configuration items are passed on StartCapture();
   RunningCallback running_callback_;

content/renderer/media_capture_from_element/html_video_element_capturer_source_unittest.cc

@@ -91,6 +91,7 @@ class HTMLVideoElementCapturerSourceTest : public testing::Test {
         web_media_player_(new MockWebMediaPlayer()),
         html_video_capturer_(new HtmlVideoElementCapturerSource(
             web_media_player_->AsWeakPtr(),
+            base::ThreadTaskRunnerHandle::Get(),
             base::ThreadTaskRunnerHandle::Get())) {}
 
   // Necessary callbacks and MOCK_METHODS for them.

content/renderer/renderer_blink_platform_impl.cc

@@ -980,13 +980,15 @@ RendererBlinkPlatformImpl::CreateCanvasCaptureHandler(
 
 void RendererBlinkPlatformImpl::CreateHTMLVideoElementCapturer(
     WebMediaStream* web_media_stream,
-    WebMediaPlayer* web_media_player) {
+    WebMediaPlayer* web_media_player,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
 #if BUILDFLAG(ENABLE_WEBRTC)
   DCHECK(web_media_stream);
   DCHECK(web_media_player);
   AddVideoTrackToMediaStream(
       HtmlVideoElementCapturerSource::CreateFromWebMediaPlayerImpl(
-          web_media_player, content::RenderThread::Get()->GetIOTaskRunner()),
+          web_media_player, content::RenderThread::Get()->GetIOTaskRunner(),
+          task_runner),
       false,  // is_remote
       web_media_stream);
 #endif

content/renderer/renderer_blink_platform_impl.h

@@ -180,7 +180,8 @@ class CONTENT_EXPORT RendererBlinkPlatformImpl : public BlinkPlatformImpl {
       blink::WebMediaStreamTrack* track) override;
   void CreateHTMLVideoElementCapturer(
       blink::WebMediaStream* web_media_stream,
-      blink::WebMediaPlayer* web_media_player) override;
+      blink::WebMediaPlayer* web_media_player,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
   void CreateHTMLAudioElementCapturer(
       blink::WebMediaStream* web_media_stream,
       blink::WebMediaPlayer* web_media_player) override;

third_party/WebKit/Source/modules/mediacapturefromelement/HTMLMediaElementCapture.cpp

@@ -15,6 +15,7 @@
 #include "modules/mediastream/MediaStreamRegistry.h"
 #include "platform/mediastream/MediaStreamCenter.h"
 #include "public/platform/Platform.h"
+#include "public/platform/TaskType.h"
 #include "public/platform/WebMediaStream.h"
 #include "public/platform/WebMediaStreamTrack.h"
 
@@ -98,7 +99,9 @@ void MediaElementEventListener::handleEvent(ExecutionContext* context,
 
   if (media_element_->HasVideo()) {
     Platform::Current()->CreateHTMLVideoElementCapturer(
-        &web_stream, media_element_->GetWebMediaPlayer());
+        &web_stream, media_element_->GetWebMediaPlayer(),
+        media_element_->GetExecutionContext()->GetTaskRunner(
+            TaskType::kUnthrottled));
   }
   if (media_element_->HasAudio()) {
     Platform::Current()->CreateHTMLAudioElementCapturer(
@@ -189,7 +192,8 @@ MediaStream* HTMLMediaElementCapture::captureStream(
 
   if (element.HasVideo()) {
     Platform::Current()->CreateHTMLVideoElementCapturer(
-        &web_stream, element.GetWebMediaPlayer());
+        &web_stream, element.GetWebMediaPlayer(),
+        element.GetExecutionContext()->GetTaskRunner(TaskType::kUnthrottled));
   }
   if (element.HasAudio()) {
     Platform::Current()->CreateHTMLAudioElementCapturer(

third_party/WebKit/public/platform/Platform.h

@@ -599,8 +599,10 @@ class BLINK_PLATFORM_EXPORT Platform {
 
   // Fills in the WebMediaStream to capture from the WebMediaPlayer identified
   // by the second parameter.
-  virtual void CreateHTMLVideoElementCapturer(WebMediaStream*,
-                                              WebMediaPlayer*) {}
+  virtual void CreateHTMLVideoElementCapturer(
+      WebMediaStream*,
+      WebMediaPlayer*,
+      scoped_refptr<base::SingleThreadTaskRunner>) {}
   virtual void CreateHTMLAudioElementCapturer(WebMediaStream*,
                                               WebMediaPlayer*) {}