Remove WebMediaPlayer::SurfaceLayerMode.

This CL replaces the dual-valued SurfaceLayerMode enum with
a simple bool instead.

Bug: 901513
Change-Id: I6f27c56256286f846fcccac8becb3792a0e8fcc7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3627590
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Reviewed-by: Philip Jägenstedt <foolip@chromium.org>
Commit-Queue: Markus Handell <handellm@google.com>
Cr-Commit-Position: refs/heads/main@{#1001095}

content/renderer/media/media_factory.cc

@@ -497,8 +497,7 @@ blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
                      parent_frame_sink_id,
                      blink::WebSurfaceLayerBridge::ContainsVideo::kYes),
       RenderThreadImpl::current()->SharedMainThreadContextProvider(),
-      use_surface_layer ? blink::WebMediaPlayer::SurfaceLayerMode::kAlways
-                        : blink::WebMediaPlayer::SurfaceLayerMode::kNever,
+      use_surface_layer,
       render_frame_->GetRenderFrameMediaPlaybackOptions()
           .is_background_suspend_enabled,
       render_frame_->GetRenderFrameMediaPlaybackOptions()
@@ -769,9 +768,7 @@ blink::WebMediaPlayer* MediaFactory::CreateWebMediaPlayerForMediaStream(
       base::BindOnce(&blink::WebSurfaceLayerBridge::Create,
                      parent_frame_sink_id,
                      blink::WebSurfaceLayerBridge::ContainsVideo::kYes),
-      std::move(submitter),
-      use_surface_layer ? blink::WebMediaPlayer::SurfaceLayerMode::kAlways
-                        : blink::WebMediaPlayer::SurfaceLayerMode::kNever);
+      std::move(submitter), use_surface_layer);
 }
 
 media::RendererWebMediaPlayerDelegate*

third_party/blink/public/platform/media/web_media_player_builder.h

@@ -90,7 +90,7 @@ class BLINK_PLATFORM_EXPORT WebMediaPlayerBuilder {
       mojo::PendingRemote<media::mojom::MediaMetricsProvider> metrics_provider,
       CreateSurfaceLayerBridgeCB create_bridge_callback,
       scoped_refptr<viz::RasterContextProvider> raster_context_provider,
-      WebMediaPlayer::SurfaceLayerMode use_surface_layer_for_video,
+      bool use_surface_layer_for_video,
       bool is_background_suspend_enabled,
       bool is_background_video_playback_enabled,
       bool is_background_video_track_optimization_supported,

third_party/blink/public/platform/web_media_player.h

@@ -134,15 +134,6 @@ class WebMediaPlayer {
     base::TimeDelta average_frame_duration;
   };
 
-  // Describes when we use SurfaceLayer for video instead of VideoLayer.
-  enum class SurfaceLayerMode {
-    // Always use VideoLayer
-    kNever,
-
-    // Always use SurfaceLayer for video.
-    kAlways,
-  };
-
   virtual ~WebMediaPlayer() = default;
 
   virtual LoadTiming Load(LoadType,

third_party/blink/public/web/modules/mediastream/webmediaplayer_ms.h

@@ -88,7 +88,7 @@ class BLINK_MODULES_EXPORT WebMediaPlayerMS
       const WebString& sink_id,
       CreateSurfaceLayerBridgeCB create_bridge_callback,
       std::unique_ptr<WebVideoFrameSubmitter> submitter_,
-      WebMediaPlayer::SurfaceLayerMode surface_layer_mode);
+      bool use_surface_layer);
 
   WebMediaPlayerMS(const WebMediaPlayerMS&) = delete;
   WebMediaPlayerMS& operator=(const WebMediaPlayerMS&) = delete;
@@ -338,8 +338,7 @@ class BLINK_MODULES_EXPORT WebMediaPlayerMS
   std::unique_ptr<WebVideoFrameSubmitter> submitter_;
 
   // Whether the use of a surface layer instead of a video layer is enabled.
-  WebMediaPlayer::SurfaceLayerMode surface_layer_mode_ =
-      WebMediaPlayer::SurfaceLayerMode::kNever;
+  bool use_surface_layer_ = false;
 
   // Owns the weblayer and obtains/maintains SurfaceIds for
   // kUseSurfaceLayerForVideo feature.

third_party/blink/renderer/core/exported/web_media_player_impl_unittest.cc

@@ -441,9 +441,9 @@ class WebMediaPlayerImplTest
         base::BindOnce(&WebMediaPlayerImplTest::CreateMockSurfaceLayerBridge,
                        base::Unretained(this)),
         viz::TestContextProvider::Create(),
-        WebMediaPlayer::SurfaceLayerMode::kAlways,
-        is_background_suspend_enabled_, is_background_video_playback_enabled_,
-        true, std::move(demuxer_override), nullptr);
+        /*use_surface_layer=*/true, is_background_suspend_enabled_,
+        is_background_video_playback_enabled_, true,
+        std::move(demuxer_override), nullptr);
   }
 
   std::unique_ptr<WebSurfaceLayerBridge> CreateMockSurfaceLayerBridge(

third_party/blink/renderer/core/exported/web_view_impl.cc

@@ -42,6 +42,7 @@
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "cc/layers/picture_layer.h"
+#include "components/viz/common/features.h"
 #include "media/base/media_switches.h"
 #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
 #include "third_party/blink/public/common/features.h"
@@ -180,10 +181,6 @@
 #include "ui/base/ui_base_features.h"
 #include "ui/gfx/geometry/skia_conversions.h"
 
-#if BUILDFLAG(IS_ANDROID)
-#include "components/viz/common/features.h"
-#endif
-
 #if !BUILDFLAG(IS_MAC)
 #include "skia/ext/legacy_display_globals.h"
 #include "third_party/blink/public/platform/web_font_render_style.h"
@@ -376,14 +373,6 @@ void ApplyCommandLineToSettings(WebSettings* settings) {
   }
 }
 
-WebMediaPlayer::SurfaceLayerMode GetVideoSurfaceLayerMode() {
-#if BUILDFLAG(IS_ANDROID)
-  if (!::features::UseSurfaceLayerForVideo())
-    return blink::WebMediaPlayer::SurfaceLayerMode::kNever;
-#endif
-  return WebMediaPlayer::SurfaceLayerMode::kAlways;
-}
-
 ui::mojom::blink::WindowOpenDisposition NavigationPolicyToDisposition(
     NavigationPolicy policy) {
   switch (policy) {
@@ -1707,10 +1696,8 @@ void WebView::ApplyWebPreferences(const web_pref::WebPreferences& prefs,
       static_cast<blink::WebEffectiveConnectionType>(
           prefs.low_priority_iframes_threshold));
 
-  settings->SetPictureInPictureEnabled(
-      prefs.picture_in_picture_enabled &&
-      GetVideoSurfaceLayerMode() !=
-          blink::WebMediaPlayer::SurfaceLayerMode::kNever);
+  settings->SetPictureInPictureEnabled(prefs.picture_in_picture_enabled &&
+                                       ::features::UseSurfaceLayerForVideo());
 
   settings->SetLazyLoadEnabled(prefs.lazy_load_enabled);
   settings->SetPreferredColorScheme(prefs.preferred_color_scheme);

third_party/blink/renderer/modules/mediastream/webmediaplayer_ms.cc

@@ -352,7 +352,7 @@ WebMediaPlayerMS::WebMediaPlayerMS(
     const WebString& sink_id,
     CreateSurfaceLayerBridgeCB create_bridge_callback,
     std::unique_ptr<WebVideoFrameSubmitter> submitter,
-    WebMediaPlayer::SurfaceLayerMode surface_layer_mode)
+    bool use_surface_layer)
     : internal_frame_(std::make_unique<MediaStreamInternalFrameWrapper>(frame)),
       network_state_(WebMediaPlayer::kNetworkStateEmpty),
       ready_state_(WebMediaPlayer::kReadyStateHaveNothing),
@@ -380,7 +380,7 @@ WebMediaPlayerMS::WebMediaPlayerMS(
               this,
               &WebMediaPlayerMS::StopForceBeginFrames)),
       submitter_(std::move(submitter)),
-      surface_layer_mode_(surface_layer_mode) {
+      use_surface_layer_(use_surface_layer) {
   DCHECK(client);
   DCHECK(delegate_);
   weak_this_ = weak_factory_.GetWeakPtr();
@@ -406,7 +406,7 @@ WebMediaPlayerMS::~WebMediaPlayerMS() {
   // Destruct compositor resources in the proper order.
   get_client()->SetCcLayer(nullptr);
   if (video_layer_) {
-    DCHECK(surface_layer_mode_ != WebMediaPlayer::SurfaceLayerMode::kAlways);
+    DCHECK(!use_surface_layer_);
     video_layer_->StopUsingProvider();
   }
 
@@ -463,7 +463,7 @@ WebMediaPlayer::LoadTiming WebMediaPlayerMS::Load(
 
   compositor_ = base::MakeRefCounted<WebMediaPlayerMSCompositor>(
       compositor_task_runner_, io_task_runner_, web_stream_,
-      std::move(submitter_), surface_layer_mode_, weak_this_);
+      std::move(submitter_), use_surface_layer_, weak_this_);
 
   // We can receive a call to RequestVideoFrameCallback() before |compositor_|
   // is created. In that case, we suspend the request, and wait until now to
@@ -1205,7 +1205,7 @@ void WebMediaPlayerMS::OnFirstFrameReceived(
   OnTransformChanged(video_transform);
   OnOpacityChanged(is_opaque);
 
-  if (surface_layer_mode_ == WebMediaPlayer::SurfaceLayerMode::kAlways)
+  if (use_surface_layer_)
     ActivateSurfaceLayerForVideo(video_transform);
 
   SetReadyState(WebMediaPlayer::kReadyStateHaveMetadata);

third_party/blink/renderer/modules/mediastream/webmediaplayer_ms_compositor.cc

@@ -182,7 +182,7 @@ WebMediaPlayerMSCompositor::WebMediaPlayerMSCompositor(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     MediaStreamDescriptor* media_stream_descriptor,
     std::unique_ptr<WebVideoFrameSubmitter> submitter,
-    WebMediaPlayer::SurfaceLayerMode surface_layer_mode,
+    bool use_surface_layer,
     const base::WeakPtr<WebMediaPlayerMS>& player)
     : video_frame_compositor_task_runner_(video_frame_compositor_task_runner),
       io_task_runner_(io_task_runner),
@@ -195,7 +195,7 @@ WebMediaPlayerMSCompositor::WebMediaPlayerMSCompositor(
       dropped_frame_count_(0),
       stopped_(true),
       render_started_(!stopped_) {
-  if (surface_layer_mode != WebMediaPlayer::SurfaceLayerMode::kNever) {
+  if (use_surface_layer) {
     submitter_ = std::move(submitter);
 
     PostCrossThreadTask(

third_party/blink/renderer/modules/mediastream/webmediaplayer_ms_compositor.h

@@ -74,7 +74,7 @@ class MODULES_EXPORT WebMediaPlayerMSCompositor
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       MediaStreamDescriptor* media_stream_descriptor,
       std::unique_ptr<WebVideoFrameSubmitter> submitter,
-      WebMediaPlayer::SurfaceLayerMode surface_layer_mode,
+      bool use_surface_layer,
       const base::WeakPtr<WebMediaPlayerMS>& player);
 
   WebMediaPlayerMSCompositor(const WebMediaPlayerMSCompositor&) = delete;

third_party/blink/renderer/modules/mediastream/webmediaplayer_ms_test.cc

@@ -663,10 +663,6 @@ class WebMediaPlayerMSTest
 
 void WebMediaPlayerMSTest::InitializeWebMediaPlayerMS() {
   enable_surface_layer_for_video_ = testing::get<0>(GetParam());
-  WebMediaPlayer::SurfaceLayerMode surface_layer_mode =
-      enable_surface_layer_for_video_
-          ? WebMediaPlayer::SurfaceLayerMode::kAlways
-          : WebMediaPlayer::SurfaceLayerMode::kNever;
   player_ = std::make_unique<WebMediaPlayerMS>(
       nullptr, this, &delegate_, std::make_unique<media::NullMediaLog>(),
       scheduler::GetSingleThreadTaskRunnerForTesting(),
@@ -677,7 +673,7 @@ void WebMediaPlayerMSTest::InitializeWebMediaPlayerMS() {
       WebString(),
       WTF::Bind(&WebMediaPlayerMSTest::CreateMockSurfaceLayerBridge,
                 WTF::Unretained(this)),
-      std::move(submitter_), surface_layer_mode);
+      std::move(submitter_), enable_surface_layer_for_video_);
   player_->SetMediaStreamRendererFactoryForTesting(
       std::unique_ptr<MediaStreamRendererFactory>(render_factory_));
 }

third_party/blink/renderer/platform/media/web_media_player_builder.cc

@@ -54,7 +54,7 @@ WebMediaPlayer* WebMediaPlayerBuilder::Build(
     mojo::PendingRemote<media::mojom::MediaMetricsProvider> metrics_provider,
     CreateSurfaceLayerBridgeCB create_bridge_callback,
     scoped_refptr<viz::RasterContextProvider> raster_context_provider,
-    WebMediaPlayer::SurfaceLayerMode surface_layer_mode,
+    bool use_surface_layer,
     bool is_background_suspend_enabled,
     bool is_background_video_playback_enabled,
     bool is_background_video_track_optimization_supported,
@@ -71,7 +71,7 @@ WebMediaPlayer* WebMediaPlayerBuilder::Build(
       std::move(request_routing_token_cb), std::move(media_observer),
       enable_instant_source_buffer_gc, embedded_media_experience_enabled,
       std::move(metrics_provider), std::move(create_bridge_callback),
-      std::move(raster_context_provider), surface_layer_mode,
+      std::move(raster_context_provider), use_surface_layer,
       is_background_suspend_enabled, is_background_video_playback_enabled,
       is_background_video_track_optimization_supported,
       std::move(demuxer_override), std::move(remote_interfaces));

third_party/blink/renderer/platform/media/web_media_player_impl.cc

@@ -421,7 +421,7 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
     mojo::PendingRemote<media::mojom::MediaMetricsProvider> metrics_provider,
     CreateSurfaceLayerBridgeCB create_bridge_callback,
     scoped_refptr<viz::RasterContextProvider> raster_context_provider,
-    WebMediaPlayer::SurfaceLayerMode surface_layer_mode,
+    bool use_surface_layer,
     bool is_background_suspend_enabled,
     bool is_background_video_playback_enabled,
     bool is_background_video_track_optimization_supported,
@@ -447,7 +447,7 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
       observer_(std::move(media_observer)),
       enable_instant_source_buffer_gc_(enable_instant_source_buffer_gc),
       embedded_media_experience_enabled_(embedded_media_experience_enabled),
-      surface_layer_mode_(surface_layer_mode),
+      use_surface_layer_(use_surface_layer),
       create_bridge_callback_(std::move(create_bridge_callback)),
       request_routing_token_cb_(std::move(request_routing_token_cb)),
       media_metrics_provider_(std::move(metrics_provider)),
@@ -2035,7 +2035,7 @@ void WebMediaPlayerImpl::OnMetadata(const media::PipelineMetadata& metadata) {
         DisableOverlay();
     }
 
-    if (surface_layer_mode_ == WebMediaPlayer::SurfaceLayerMode::kAlways) {
+    if (use_surface_layer_) {
       ActivateSurfaceLayerForVideo();
     } else {
       DCHECK(!video_layer_);

third_party/blink/renderer/platform/media/web_media_player_impl.h

@@ -138,7 +138,7 @@ class PLATFORM_EXPORT WebMediaPlayerImpl
       mojo::PendingRemote<media::mojom::MediaMetricsProvider> metrics_provider,
       CreateSurfaceLayerBridgeCB create_bridge_callback,
       scoped_refptr<viz::RasterContextProvider> raster_context_provider,
-      WebMediaPlayer::SurfaceLayerMode surface_layer_mode,
+      bool use_surface_layer,
       bool is_background_suspend_enabled,
       bool is_background_video_play_enabled,
       bool is_background_video_track_optimization_supported,
@@ -976,8 +976,7 @@ class PLATFORM_EXPORT WebMediaPlayerImpl
   bool embedded_media_experience_enabled_ = false;
 
   // When should we use SurfaceLayer for video?
-  WebMediaPlayer::SurfaceLayerMode surface_layer_mode_ =
-      WebMediaPlayer::SurfaceLayerMode::kNever;
+  bool use_surface_layer_ = false;
 
   // Whether surface layer is currently in use to display frames.
   bool surface_layer_for_video_enabled_ = false;