[MBI] Migrate CompositorTaskRunner from MainThreadSchedulerImpl to AgentGroupScheduler

Before this CL, there was only a per-thread CompositorTaskRunner. So any compositor task was running on per-thread compositor task runner even when the task belongs to ASG.

This CL introduces per-ASG CompositorTaskRunner to run ASG’s compositor tasks, and migrate MediaFactory to use per-ASG CompositorTaskRunner. The remaining callsites will be migrated on following CL.

Bug: 1105403
Change-Id: I548e4aaeefee8c229d2f31c26a5a30b3d6386ed2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2601019
Commit-Queue: Minoru Chikamune <chikamune@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Reviewed-by: Kouhei Ueno <kouhei@chromium.org>
Cr-Commit-Position: refs/heads/master@{#843579}

content/renderer/media/media_factory.cc

@@ -246,6 +246,8 @@ blink::WebMediaPlayer::SurfaceLayerMode GetSurfaceLayerMode(
 // Creates the VideoFrameSubmitter and its task_runner based on the current
 // SurfaceLayerMode;
 std::unique_ptr<blink::WebVideoFrameSubmitter> CreateSubmitter(
+    scoped_refptr<base::SingleThreadTaskRunner>
+        main_thread_compositor_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner>*
         video_frame_compositor_task_runner,
     const cc::LayerTreeSettings& settings,
@@ -284,10 +286,8 @@ std::unique_ptr<blink::WebVideoFrameSubmitter> CreateSubmitter(
 
   auto log_roughness_cb =
       base::BindRepeating(LogRoughness, base::Owned(media_log->Clone()));
-  auto post_to_context_provider_cb =
-      base::BindRepeating(&PostContextProviderToCallback,
-                          content::RenderThreadImpl::current()
-                              ->GetCompositorMainThreadTaskRunner());
+  auto post_to_context_provider_cb = base::BindRepeating(
+      &PostContextProviderToCallback, main_thread_compositor_task_runner);
   return blink::WebVideoFrameSubmitter::Create(
       std::move(post_to_context_provider_cb), std::move(log_roughness_cb),
       settings, use_sync_primitives);
@@ -357,7 +357,6 @@ bool UseMediaPlayerRenderer(const GURL& url) {
 }
 #endif  // defined(OS_ANDROID)
 
-
 blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
     const blink::WebMediaPlayerSource& source,
     blink::WebMediaPlayerClient* client,
@@ -366,12 +365,14 @@ blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
     blink::WebContentDecryptionModule* initial_cdm,
     const blink::WebString& sink_id,
     viz::FrameSinkId parent_frame_sink_id,
-    const cc::LayerTreeSettings& settings) {
+    const cc::LayerTreeSettings& settings,
+    scoped_refptr<base::SingleThreadTaskRunner>
+        main_thread_compositor_task_runner) {
   blink::WebLocalFrame* web_frame = render_frame_->GetWebFrame();
   if (source.IsMediaStream()) {
-    return CreateWebMediaPlayerForMediaStream(client, inspector_context,
-                                              sink_id, web_frame,
-                                              parent_frame_sink_id, settings);
+    return CreateWebMediaPlayerForMediaStream(
+        client, inspector_context, sink_id, web_frame, parent_frame_sink_id,
+        settings, main_thread_compositor_task_runner);
   }
 
   // If |source| was not a MediaStream, it must be a URL.
@@ -466,9 +467,9 @@ blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
   scoped_refptr<base::SingleThreadTaskRunner>
       video_frame_compositor_task_runner;
   const auto surface_layer_mode = GetSurfaceLayerMode(MediaPlayerType::kNormal);
-  std::unique_ptr<blink::WebVideoFrameSubmitter> submitter =
-      CreateSubmitter(&video_frame_compositor_task_runner, settings,
-                      media_log.get(), render_frame_, surface_layer_mode);
+  std::unique_ptr<blink::WebVideoFrameSubmitter> submitter = CreateSubmitter(
+      main_thread_compositor_task_runner, &video_frame_compositor_task_runner,
+      settings, media_log.get(), render_frame_, surface_layer_mode);
 
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner =
       render_thread->GetMediaThreadTaskRunner();
@@ -697,7 +698,9 @@ blink::WebMediaPlayer* MediaFactory::CreateWebMediaPlayerForMediaStream(
     const blink::WebString& sink_id,
     blink::WebLocalFrame* frame,
     viz::FrameSinkId parent_frame_sink_id,
-    const cc::LayerTreeSettings& settings) {
+    const cc::LayerTreeSettings& settings,
+    scoped_refptr<base::SingleThreadTaskRunner>
+        main_thread_compositor_task_runner) {
   RenderThreadImpl* const render_thread = RenderThreadImpl::current();
 
   scoped_refptr<base::SingleThreadTaskRunner>
@@ -717,9 +720,9 @@ blink::WebMediaPlayer* MediaFactory::CreateWebMediaPlayerForMediaStream(
 
   const auto surface_layer_mode =
       GetSurfaceLayerMode(MediaPlayerType::kMediaStream);
-  std::unique_ptr<blink::WebVideoFrameSubmitter> submitter =
-      CreateSubmitter(&video_frame_compositor_task_runner, settings,
-                      media_log.get(), render_frame_, surface_layer_mode);
+  std::unique_ptr<blink::WebVideoFrameSubmitter> submitter = CreateSubmitter(
+      main_thread_compositor_task_runner, &video_frame_compositor_task_runner,
+      settings, media_log.get(), render_frame_, surface_layer_mode);
 
   return new blink::WebMediaPlayerMS(
       frame, client, GetWebMediaPlayerDelegate(), std::move(media_log),

content/renderer/media/media_factory.h

@@ -97,7 +97,9 @@ class MediaFactory {
       blink::WebContentDecryptionModule* initial_cdm,
       const blink::WebString& sink_id,
       viz::FrameSinkId parent_frame_sink_id,
-      const cc::LayerTreeSettings& settings);
+      const cc::LayerTreeSettings& settings,
+      scoped_refptr<base::SingleThreadTaskRunner>
+          main_thread_compositor_task_runner);
 
   // Provides an EncryptedMediaClient to connect blink's EME layer to media's
   // implementation of requestMediaKeySystemAccess. Will always return the same
@@ -132,7 +134,9 @@ class MediaFactory {
       const blink::WebString& sink_id,
       blink::WebLocalFrame* frame,
       viz::FrameSinkId parent_frame_sink_id,
-      const cc::LayerTreeSettings& settings);
+      const cc::LayerTreeSettings& settings,
+      scoped_refptr<base::SingleThreadTaskRunner>
+          main_thread_compositor_task_runner);
 
   // Returns the media delegate for WebMediaPlayer usage.  If
   // |media_player_delegate_| is NULL, one is created.

content/renderer/render_frame_impl.cc

@@ -3658,7 +3658,8 @@ blink::WebMediaPlayer* RenderFrameImpl::CreateMediaPlayer(
     const cc::LayerTreeSettings& settings) {
   return media_factory_.CreateMediaPlayer(
       source, client, inspector_context, encrypted_client, initial_cdm, sink_id,
-      GetLocalRootWebFrameWidget()->GetFrameSinkId(), settings);
+      GetLocalRootWebFrameWidget()->GetFrameSinkId(), settings,
+      agent_scheduling_group_.agent_group_scheduler().CompositorTaskRunner());
 }
 
 std::unique_ptr<blink::WebContentSettingsClient>

content/renderer/render_thread_impl.cc

@@ -955,9 +955,6 @@ void RenderThreadImpl::InitializeWebKit(mojo::BinderMap* binders) {
   isolate->SetAddHistogramSampleFunction(AddHistogramSample);
   isolate->SetAddCrashKeyCallback(AddCrashKey);
 
-  main_thread_compositor_task_runner_ =
-      main_thread_scheduler_->CompositorTaskRunner();
-
   if (!command_line.HasSwitch(switches::kDisableThreadedCompositing))
     InitializeCompositorThread();
 
@@ -1301,11 +1298,6 @@ bool RenderThreadImpl::IsUseZoomForDSFEnabled() {
   return is_zoom_for_dsf_enabled_;
 }
 
-scoped_refptr<base::SingleThreadTaskRunner>
-RenderThreadImpl::GetCompositorMainThreadTaskRunner() {
-  return main_thread_compositor_task_runner_;
-}
-
 gpu::GpuMemoryBufferManager* RenderThreadImpl::GetGpuMemoryBufferManager() {
   return gpu_->gpu_memory_buffer_manager();
 }

content/renderer/render_thread_impl.h

@@ -212,8 +212,6 @@ class CONTENT_EXPORT RenderThreadImpl
                                 base::PassKey<AgentSchedulingGroup>);
 
   bool IsThreadedAnimationEnabled();
-  scoped_refptr<base::SingleThreadTaskRunner>
-  GetCompositorMainThreadTaskRunner();
 
   // viz::mojom::CompositingModeWatcher implementation.
   void CompositingModeFallbackToSoftware() override;
@@ -543,9 +541,6 @@ class CONTENT_EXPORT RenderThreadImpl
 
   std::unique_ptr<VariationsRenderThreadObserver> variations_observer_;
 
-  scoped_refptr<base::SingleThreadTaskRunner>
-      main_thread_compositor_task_runner_;
-
   // Compositor settings.
   int gpu_rasterization_msaa_sample_count_;
   bool is_lcd_text_enabled_;

third_party/blink/public/platform/scheduler/web_agent_group_scheduler.h

@@ -31,6 +31,12 @@ class BLINK_PLATFORM_EXPORT WebAgentGroupScheduler {
   // Default task runners for different AgentSchedulingGroup would be
   // independent and won't have any ordering guarantees between them.
   virtual scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() = 0;
+
+  // Compositor task runner for an AgentSchedulingGroup.
+  // Compositor task runners for different AgentSchedulingGroup would be
+  // independent and won't have any ordering guarantees between them.
+  virtual scoped_refptr<base::SingleThreadTaskRunner>
+  CompositorTaskRunner() = 0;
 };
 
 }  // namespace scheduler

third_party/blink/renderer/platform/scheduler/common/dummy_schedulers.cc

@@ -114,6 +114,9 @@ class DummyAgentGroupScheduler : public AgentGroupScheduler {
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override {
     return base::ThreadTaskRunnerHandle::Get();
   }
+  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override {
+    return base::ThreadTaskRunnerHandle::Get();
+  }
 };
 
 class DummyPageScheduler : public PageScheduler {

third_party/blink/renderer/platform/scheduler/main_thread/agent_group_scheduler_impl.cc

@@ -48,6 +48,18 @@ std::unique_ptr<PageScheduler> AgentGroupSchedulerImpl::CreatePageScheduler(
   return page_scheduler;
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+AgentGroupSchedulerImpl::DefaultTaskRunner() {
+  return default_task_runner_;
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+AgentGroupSchedulerImpl::CompositorTaskRunner() {
+  // We temporarily redirect the per-AGS compositor task runner to the main
+  // thread's compositor task runner.
+  return main_thread_scheduler_.CompositorTaskRunner();
+}
+
 AgentGroupScheduler& AgentGroupSchedulerImpl::AsAgentGroupScheduler() {
   return *this;
 }

third_party/blink/renderer/platform/scheduler/main_thread/agent_group_scheduler_impl.h

@@ -6,6 +6,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_MAIN_THREAD_AGENT_GROUP_SCHEDULER_IMPL_H_
 
 #include "base/memory/scoped_refptr.h"
+#include "base/task/sequence_manager/task_queue.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
 #include "third_party/blink/renderer/platform/scheduler/public/agent_group_scheduler.h"
 
@@ -30,9 +31,8 @@ class PLATFORM_EXPORT AgentGroupSchedulerImpl : public AgentGroupScheduler {
 
   std::unique_ptr<PageScheduler> CreatePageScheduler(
       PageScheduler::Delegate*) override;
-  scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override {
-    return default_task_runner_;
-  }
+  scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;
+  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
   MainThreadSchedulerImpl& GetMainThreadScheduler() {
     return main_thread_scheduler_;
   }