Add a feature to disable surface layer for MediaStreams.

This adds a SurfaceLayerForMediaStreams feature that is enabled by
default. The expectation is that the Meet team will use this to
evaluate the CPU usage and other performance characteristics.

To disable surface layer for media streams you should launch Chrome
with --disable-features=SurfaceLayerForMediaStreams

R=liberato

Bug: 1157671
Test: http://apprtc.appspot.com/
Change-Id: I89cca10f8a81939d4a742be4352dcd2075edc6c5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2586513
Commit-Queue: Dale Curtis <dalecurtis@chromium.org>
Commit-Queue: Frank Liberato <liberato@chromium.org>
Reviewed-by: Frank Liberato <liberato@chromium.org>
Auto-Submit: Dale Curtis <dalecurtis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#836309}

content/renderer/media/media_factory.cc

@@ -215,22 +215,83 @@ std::unique_ptr<media::DefaultRendererFactory> CreateDefaultRendererFactory(
   return default_factory;
 }
 
-}  // namespace
-
-namespace content {
+enum class MediaPlayerType {
+  kNormal,       // WebMediaPlayerImpl backed.
+  kMediaStream,  // MediaStream backed.
+};
 
-// static
-blink::WebMediaPlayer::SurfaceLayerMode
-MediaFactory::GetVideoSurfaceLayerMode() {
+// Helper function returning whether SurfaceLayer should be enabled.
+blink::WebMediaPlayer::SurfaceLayerMode GetSurfaceLayerMode(
+    MediaPlayerType type) {
 #if defined(OS_ANDROID)
   if (base::FeatureList::IsEnabled(media::kDisableSurfaceLayerForVideo) &&
-      !features::IsUsingVizForWebView())
+      !features::IsUsingVizForWebView()) {
     return blink::WebMediaPlayer::SurfaceLayerMode::kNever;
+  }
 #endif  // OS_ANDROID
 
-  return blink::WebMediaPlayer::SurfaceLayerMode::kAlways;
+  if (type != MediaPlayerType::kMediaStream)
+    return blink::WebMediaPlayer::SurfaceLayerMode::kAlways;
+
+  return base::FeatureList::IsEnabled(media::kSurfaceLayerForMediaStreams)
+             ? blink::WebMediaPlayer::SurfaceLayerMode::kAlways
+             : blink::WebMediaPlayer::SurfaceLayerMode::kNever;
 }
 
+// Creates the VideoFrameSubmitter and its task_runner based on the current
+// SurfaceLayerMode;
+std::unique_ptr<blink::WebVideoFrameSubmitter> CreateSubmitter(
+    scoped_refptr<base::SingleThreadTaskRunner>*
+        video_frame_compositor_task_runner,
+    const cc::LayerTreeSettings& settings,
+    media::MediaLog* media_log,
+    content::RenderFrame* render_frame,
+    blink::WebMediaPlayer::SurfaceLayerMode surface_layer_mode) {
+  content::RenderThreadImpl* render_thread =
+      content::RenderThreadImpl::current();
+  *video_frame_compositor_task_runner = nullptr;
+
+  if (!render_thread)
+    return nullptr;
+
+  bool use_sync_primitives = false;
+  if (surface_layer_mode == blink::WebMediaPlayer::SurfaceLayerMode::kAlways) {
+    // Run the compositor / frame submitter on its own thread.
+    *video_frame_compositor_task_runner =
+        render_thread->CreateVideoFrameCompositorTaskRunner();
+    // We must use sync primitives on this thread.
+    use_sync_primitives = true;
+  } else {
+    // Run on the cc thread, even if we may switch to SurfaceLayer mode later
+    // if we're in kOnDemand mode.  We do this to avoid switching threads when
+    // switching to SurfaceLayer.
+    *video_frame_compositor_task_runner =
+        render_thread->compositor_task_runner()
+            ? render_thread->compositor_task_runner()
+            : render_frame->GetTaskRunner(
+                  blink::TaskType::kInternalMediaRealTime);
+    render_thread->SetVideoFrameCompositorTaskRunner(
+        *video_frame_compositor_task_runner);
+  }
+
+  if (surface_layer_mode == blink::WebMediaPlayer::SurfaceLayerMode::kNever)
+    return nullptr;
+
+  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());
+  return blink::WebVideoFrameSubmitter::Create(
+      std::move(post_to_context_provider_cb), std::move(log_roughness_cb),
+      settings, use_sync_primitives);
+}
+
+}  // namespace
+
+namespace content {
+
 MediaFactory::MediaFactory(
     RenderFrameImpl* render_frame,
     media::RequestRoutingTokenCallback request_routing_token_cb)
@@ -291,61 +352,6 @@ bool UseMediaPlayerRenderer(const GURL& url) {
 }
 #endif  // defined(OS_ANDROID)
 
-std::unique_ptr<blink::WebVideoFrameSubmitter> MediaFactory::CreateSubmitter(
-    scoped_refptr<base::SingleThreadTaskRunner>*
-        video_frame_compositor_task_runner,
-    const cc::LayerTreeSettings& settings,
-    media::MediaLog* media_log) {
-  blink::WebMediaPlayer::SurfaceLayerMode use_surface_layer_for_video =
-      GetVideoSurfaceLayerMode();
-  content::RenderThreadImpl* render_thread =
-      content::RenderThreadImpl::current();
-  *video_frame_compositor_task_runner = nullptr;
-
-  if (!render_thread)
-    return nullptr;
-
-  bool use_sync_primitives = false;
-  if (use_surface_layer_for_video ==
-      blink::WebMediaPlayer::SurfaceLayerMode::kAlways) {
-    // Run the compositor / frame submitter on its own thread.
-    *video_frame_compositor_task_runner =
-        render_thread->CreateVideoFrameCompositorTaskRunner();
-    // We must use sync primitives on this thread.
-    use_sync_primitives = true;
-  } else {
-    // Run on the cc thread, even if we may switch to SurfaceLayer mode later
-    // if we're in kOnDemand mode.  We do this to avoid switching threads when
-    // switching to SurfaceLayer.
-    *video_frame_compositor_task_runner =
-        render_thread->compositor_task_runner()
-            ? render_thread->compositor_task_runner()
-            : render_frame_->GetTaskRunner(
-                  blink::TaskType::kInternalMediaRealTime);
-
-    // TODO(https://crbug/901513): Remove once kOnDemand is removed.
-    render_thread->SetVideoFrameCompositorTaskRunner(
-        *video_frame_compositor_task_runner);
-  }
-
-  std::unique_ptr<blink::WebVideoFrameSubmitter> submitter;
-
-  if (use_surface_layer_for_video !=
-      blink::WebMediaPlayer::SurfaceLayerMode::kNever) {
-    auto log_roughness_cb =
-        base::BindRepeating(LogRoughness, base::Owned(media_log->Clone()));
-    auto post_to_context_provider_cb = base::BindRepeating(
-        &PostContextProviderToCallback,
-        RenderThreadImpl::current()->GetCompositorMainThreadTaskRunner());
-    submitter = blink::WebVideoFrameSubmitter::Create(
-        std::move(post_to_context_provider_cb), std::move(log_roughness_cb),
-        settings, use_sync_primitives);
-  }
-
-  DCHECK(*video_frame_compositor_task_runner);
-
-  return submitter;
-}
 
 blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
     const blink::WebMediaPlayerSource& source,
@@ -454,8 +460,10 @@ blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
 
   scoped_refptr<base::SingleThreadTaskRunner>
       video_frame_compositor_task_runner;
-  std::unique_ptr<blink::WebVideoFrameSubmitter> submitter = CreateSubmitter(
-      &video_frame_compositor_task_runner, settings, media_log.get());
+  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);
 
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner =
       render_thread->GetMediaThreadTaskRunner();
@@ -488,7 +496,7 @@ blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
                          parent_frame_sink_id,
                          blink::WebSurfaceLayerBridge::ContainsVideo::kYes),
           RenderThreadImpl::current()->SharedMainThreadContextProvider(),
-          GetVideoSurfaceLayerMode(),
+          surface_layer_mode,
           render_frame_->GetRenderFrameMediaPlaybackOptions()
               .is_background_suspend_enabled,
           render_frame_->GetRenderFrameMediaPlaybackOptions()
@@ -702,8 +710,11 @@ blink::WebMediaPlayer* MediaFactory::CreateWebMediaPlayerForMediaStream(
       render_frame_->GetTaskRunner(blink::TaskType::kInternalMedia),
       std::move(handlers));
 
-  std::unique_ptr<blink::WebVideoFrameSubmitter> submitter = CreateSubmitter(
-      &video_frame_compositor_task_runner, settings, media_log.get());
+  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);
 
   return new blink::WebMediaPlayerMS(
       frame, client, GetWebMediaPlayerDelegate(), std::move(media_log),
@@ -715,7 +726,7 @@ blink::WebMediaPlayer* MediaFactory::CreateWebMediaPlayerForMediaStream(
       base::BindOnce(&blink::WebSurfaceLayerBridge::Create,
                      parent_frame_sink_id,
                      blink::WebSurfaceLayerBridge::ContainsVideo::kYes),
-      std::move(submitter), GetVideoSurfaceLayerMode());
+      std::move(submitter), surface_layer_mode);
 }
 
 media::RendererWebMediaPlayerDelegate*

content/renderer/media/media_factory.h

@@ -64,9 +64,6 @@ struct RenderFrameMediaPlaybackOptions;
 // Assist to RenderFrameImpl in creating various media clients.
 class MediaFactory {
  public:
-  // Helper function returning whether VideoSurfaceLayer should be enabled.
-  static blink::WebMediaPlayer::SurfaceLayerMode GetVideoSurfaceLayerMode();
-
   // Helper function returning whether VideoSurfaceLayer should be enabled for
   // MediaStreams.
   static bool VideoSurfaceLayerEnabledForMS();
@@ -83,14 +80,6 @@ class MediaFactory {
   // interface provider is bound.
   void SetupMojo();
 
-  // Creates the VideoFrameSubmitter and its task_runner based on the current
-  // SurfaceLayerMode;
-  std::unique_ptr<blink::WebVideoFrameSubmitter> CreateSubmitter(
-      scoped_refptr<base::SingleThreadTaskRunner>*
-          video_frame_compositor_task_runner,
-      const cc::LayerTreeSettings& settings,
-      media::MediaLog* media_log);
-
   // Creates a new WebMediaPlayer for the given |source| (either a stream or
   // URL). All pointers other than |initial_cdm| are required to be non-null.
   // The created player serves and is directed by the |client| (e.g.

media/base/media_switches.cc

@@ -423,6 +423,10 @@ const base::Feature kGlobalMediaControlsModernUI{
 const base::Feature kSpecCompliantCanPlayThrough{
     "SpecCompliantCanPlayThrough", base::FEATURE_ENABLED_BY_DEFAULT};
 
+// Controls usage of SurfaceLayer for MediaStreams.
+const base::Feature kSurfaceLayerForMediaStreams{
+    "SurfaceLayerForMediaStreams", base::FEATURE_ENABLED_BY_DEFAULT};
+
 // Disables the real audio output stream after silent audio has been delivered
 // for too long. Should save quite a bit of power in the muted video case.
 const base::Feature kSuspendMutedAudio{"SuspendMutedAudio",

media/base/media_switches.h

@@ -165,6 +165,7 @@ MEDIA_EXPORT extern const base::Feature kRecordMediaEngagementScores;
 MEDIA_EXPORT extern const base::Feature kRecordWebAudioEngagement;
 MEDIA_EXPORT extern const base::Feature kResumeBackgroundVideo;
 MEDIA_EXPORT extern const base::Feature kRevokeMediaSourceObjectURLOnAttach;
+MEDIA_EXPORT extern const base::Feature kSurfaceLayerForMediaStreams;
 MEDIA_EXPORT extern const base::Feature kSuspendMutedAudio;
 MEDIA_EXPORT extern const base::Feature kSpecCompliantCanPlayThrough;
 MEDIA_EXPORT extern const base::Feature kUnifiedAutoplay;