Replaces VideoLayer with a SurfaceLayer in WebMediaPlayerImpl

media/blink/webmediaplayer_impl.cc

 // Copyright 2013 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 "media/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 43 matching lines @@
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerEncryptedMediaClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerSource.h"
 #include "third_party/WebKit/public/platform/WebMediaSource.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
+#include "third_party/WebKit/public/platform/WebVideoSurfaceLayerBridge.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 #if defined(OS_ANDROID)
 #include "media/base/android/media_codec_util.h"
 #endif
 
@@ skipping 186 matching lines @@
       embedded_media_experience_enabled_(
           params->embedded_media_experience_enabled()),
       request_routing_token_cb_(params->request_routing_token_cb()),
       overlay_routing_token_(OverlayInfo::RoutingToken()) {
   DVLOG(1) << __func__;
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_selector_);
   DCHECK(client_);
   DCHECK(delegate_);
 
+  if (base::FeatureList::IsEnabled(media::kUseSurfaceLayerForVideo))
+    bridge_ = base::WrapUnique(blink::WebVideoSurfaceLayerBridge::Create());
+
   force_video_overlays_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kForceVideoOverlays);
 
   if (base::FeatureList::IsEnabled(media::kOverlayFullscreenVideo)) {
     bool use_android_overlay =
         base::FeatureList::IsEnabled(media::kUseAndroidOverlay);
     overlay_mode_ = use_android_overlay ? OverlayMode::kUseAndroidOverlay
                                         : OverlayMode::kUseContentVideoView;
   } else {
     overlay_mode_ = OverlayMode::kNoOverlays;
@@ skipping 36 matching lines @@
   watch_time_reporter_.reset();
 
   // The underlying Pipeline must be stopped before it is destroyed.
   pipeline_controller_.Stop();
 
   if (last_reported_memory_usage_)
     adjust_allocated_memory_cb_.Run(-last_reported_memory_usage_);
 
   // Destruct compositor resources in the proper order.
   client_->SetWebLayer(nullptr);
-  if (video_weblayer_)
+  if (!base::FeatureList::IsEnabled(media::kUseSurfaceLayerForVideo) &&
+      video_weblayer_) {
     static_cast<cc::VideoLayer*>(video_weblayer_->layer())->StopUsingProvider();
+  } else {
+    if (bridge_->GetWebLayer())
+      static_cast<cc::VideoLayer*>(bridge_->GetCCLayer())->StopUsingProvider();
+  }
   compositor_task_runner_->DeleteSoon(FROM_HERE, compositor_);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 }
 
 void WebMediaPlayerImpl::Load(LoadType load_type,
                               const blink::WebMediaPlayerSource& source,
                               CORSMode cors_mode) {
   DVLOG(1) << __func__;
@@ skipping 1004 matching lines @@
     if (overlay_enabled_) {
       // SurfaceView doesn't support rotated video, so transition back if
       // the video is now rotated.  If |force_video_overlays_|, we keep the
       // overlay anyway so that the state machine keeps working.
       if (!force_video_overlays_ && !DoesOverlaySupportMetadata())
         DisableOverlay();
       else if (surface_manager_)
         surface_manager_->NaturalSizeChanged(pipeline_metadata_.natural_size);
     }
 
-    DCHECK(!video_weblayer_);
-    video_weblayer_.reset(new cc_blink::WebLayerImpl(cc::VideoLayer::Create(
-        compositor_, pipeline_metadata_.video_rotation)));
-    video_weblayer_->layer()->SetContentsOpaque(opaque_);
-    video_weblayer_->SetContentsOpaqueIsFixed(true);
-    client_->SetWebLayer(video_weblayer_.get());
+    if (!base::FeatureList::IsEnabled(media::kUseSurfaceLayerForVideo)) {
+      DCHECK(!video_weblayer_);
+      video_weblayer_.reset(new cc_blink::WebLayerImpl(cc::VideoLayer::Create(
+          compositor_, pipeline_metadata_.video_rotation)));
+      video_weblayer_->layer()->SetContentsOpaque(opaque_);
+      video_weblayer_->SetContentsOpaqueIsFixed(true);
+      client_->SetWebLayer(video_weblayer_.get());
+    } else {
+      if (bridge_->GetWebLayer()) {
+        bridge_->GetCCLayer()->SetContentsOpaque(opaque_);

[enne (OOO), 2017/07/06 01:23:31]

To be honest, I'm not sure that this is necessary? I think this plumbing
ultimately just sets this bit on the video draw quad:
https://cs.chromium.org/chromium/src/cc/layers/video_layer_impl.cc?rcl=8a4399...

I'm mostly sure that setting the opaque rect correctly on the video quads that
are generated will do the same thing here.

+        // TODO(lethalantidote): Figure out how to persist opaque setting
+        // without calling WebLayerImpl's SetContentsOpaueIsFixed;
+        client_->SetWebLayer(bridge_->GetWebLayer());
+      }
+    }
   }
 
   if (observer_)
     observer_->OnMetadataChanged(pipeline_metadata_);
 
   CreateWatchTimeReporter();
   UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnProgress() {
@@ skipping 173 matching lines @@
   delegate_->DidPlayerSizeChange(delegate_id_, NaturalSize());
 }
 
 void WebMediaPlayerImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::kReadyStateHaveNothing);
 
   opaque_ = opaque;
   // Modify content opaqueness of cc::Layer directly so that
   // SetContentsOpaqueIsFixed is ignored.
-  if (video_weblayer_)
-    video_weblayer_->layer()->SetContentsOpaque(opaque_);
+  if (!base::FeatureList::IsEnabled(media::kUseSurfaceLayerForVideo)) {
+    if (video_weblayer_)
+      video_weblayer_->layer()->SetContentsOpaque(opaque_);
+  } else {
+    if (bridge_->GetWebLayer()) {
+      bridge_->GetCCLayer()->SetContentsOpaque(opaque_);
+    }
+  }
 }
 
 void WebMediaPlayerImpl::OnVideoAverageKeyframeDistanceUpdate() {
   UpdateBackgroundVideoOptimizationState();
 }
 
 void WebMediaPlayerImpl::OnFrameHidden() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // Backgrounding a video requires a user gesture to resume playback.
@@ skipping 153 matching lines @@
       !IsNewRemotePlaybackPipelineEnabled()) {
     scoped_refptr<VideoFrame> frame = cast_impl_.GetCastingBanner();
     if (frame)
       compositor_->PaintSingleFrame(frame);
   }
 
   UpdatePlayState();
 }
 
 gfx::Size WebMediaPlayerImpl::GetCanvasSize() const {
-  if (!video_weblayer_)
-    return pipeline_metadata_.natural_size;
+  if (!base::FeatureList::IsEnabled(media::kUseSurfaceLayerForVideo) {
+    if (!video_weblayer_)
+      return pipeline_metadata_.natural_size;
 
-  return video_weblayer_->Bounds();
+    return video_weblayer_->Bounds();
+  } else {
+    if (!bridge_->GetWebLayer())
+      return pipeline_metadate_.natural_size;
+
+    return bridge_->GetWebLayer()->Bounds();
+  }
 }
 
 void WebMediaPlayerImpl::SetDeviceScaleFactor(float scale_factor) {
   cast_impl_.SetDeviceScaleFactor(scale_factor);
 }
 
 void WebMediaPlayerImpl::SetPoster(const blink::WebURL& poster) {
   cast_impl_.setPoster(poster);
 }
 #endif  // defined(OS_ANDROID)  // WMPI_CAST
@@ skipping 862 matching lines @@
 }
 
 #undef UMA_HISTOGRAM_VIDEO_HEIGHT
 
 void WebMediaPlayerImpl::SetTickClockForTest(base::TickClock* tick_clock) {
   tick_clock_.reset(tick_clock);
   buffered_data_source_host_.SetTickClockForTest(tick_clock);
 }
 
 }  // namespace media