cc: Video layers without a frame should not occlude

Added VisibleContentOpaqueRegion() to the VideoLayerImpl, if
a frame hasn't been set yet, then we don't have an opaque region.

+ test

BUG=460612

Review URL: https://codereview.chromium.org/1134663005

Cr-Commit-Position: refs/heads/master@{#330449}

cc/layers/video_frame_provider.h

@@ -67,6 +67,10 @@ class CC_EXPORT VideoFrameProvider {
   virtual bool UpdateCurrentFrame(base::TimeTicks deadline_min,
                                   base::TimeTicks deadline_max) = 0;
 
+  // Returns true if GetCurrentFrame() will return a non-null frame and false
+  // otherwise. Aside from thread locks, the state won't change.
+  virtual bool HasCurrentFrame() = 0;
+
   // Returns the current frame, which may have been updated by a recent call to
   // UpdateCurrentFrame(). A call to this method does not ensure that the frame
   // will be rendered. A subsequent call to PutCurrentFrame() must be made if

cc/layers/video_frame_provider_client_impl.cc

@@ -98,6 +98,11 @@ void VideoFrameProviderClientImpl::ReleaseLock() {
   provider_lock_.Release();
 }
 
+bool VideoFrameProviderClientImpl::HasCurrentFrame() {
+  base::AutoLock locker(provider_lock_);
+  return provider_ && provider_->HasCurrentFrame();
+}
+
 const gfx::Transform& VideoFrameProviderClientImpl::StreamTextureMatrix()
     const {
   DCHECK(thread_checker_.CalledOnValidThread());

cc/layers/video_frame_provider_client_impl.h

@@ -42,6 +42,7 @@ class CC_EXPORT VideoFrameProviderClientImpl
   scoped_refptr<media::VideoFrame> AcquireLockAndCurrentFrame();
   void PutCurrentFrame();
   void ReleaseLock();
+  bool HasCurrentFrame();
 
   const gfx::Transform& StreamTextureMatrix() const;
 

cc/layers/video_layer_impl.cc

@@ -388,6 +388,13 @@ void VideoLayerImpl::DidDraw(ResourceProvider* resource_provider) {
   provider_client_impl_->ReleaseLock();
 }
 
+SimpleEnclosedRegion VideoLayerImpl::VisibleContentOpaqueRegion() const {
+  // If we don't have a frame yet, then we don't have an opaque region.
+  if (!provider_client_impl_->HasCurrentFrame())
+    return SimpleEnclosedRegion();
+  return LayerImpl::VisibleContentOpaqueRegion();
+}
+
 void VideoLayerImpl::ReleaseResources() {
   updater_ = nullptr;
 }

cc/layers/video_layer_impl.h

@@ -38,6 +38,7 @@ class CC_EXPORT VideoLayerImpl : public LayerImpl {
   void AppendQuads(RenderPass* render_pass,
                    AppendQuadsData* append_quads_data) override;
   void DidDraw(ResourceProvider* resource_provider) override;
+  SimpleEnclosedRegion VisibleContentOpaqueRegion() const override;
   void DidBecomeActive() override;
   void ReleaseResources() override;
 

cc/layers/video_layer_impl_unittest.cc

@@ -85,6 +85,50 @@ TEST(VideoLayerImplTest, Occlusion) {
   }
 }
 
+TEST(VideoLayerImplTest, OccludesOtherLayers) {
+  gfx::Size layer_size(1000, 1000);
+  gfx::Rect visible(layer_size);
+
+  LayerTestCommon::LayerImplTest impl;
+  impl.host_impl()->SetViewportSize(layer_size);
+  DebugSetImplThreadAndMainThreadBlocked(impl.proxy());
+  auto active_tree = impl.host_impl()->active_tree();
+
+  // Create a video layer with no frame on top of another layer.
+  scoped_ptr<LayerImpl> layer_impl = LayerImpl::Create(active_tree, 3);
+  layer_impl->SetHasRenderSurface(true);
+  layer_impl->SetBounds(layer_size);
+  layer_impl->SetContentBounds(layer_size);
+  layer_impl->SetDrawsContent(true);
+  const auto& draw_properties = layer_impl->draw_properties();
+
+  FakeVideoFrameProvider provider;
+  scoped_ptr<VideoLayerImpl> video_layer_impl = VideoLayerImpl::Create(
+      active_tree, 4, &provider, media::VIDEO_ROTATION_0);
+  video_layer_impl->SetBounds(layer_size);
+  video_layer_impl->SetContentBounds(layer_size);
+  video_layer_impl->SetDrawsContent(true);
+  video_layer_impl->SetContentsOpaque(true);
+
+  layer_impl->AddChild(video_layer_impl.Pass());
+  active_tree->SetRootLayer(layer_impl.Pass());
+
+  active_tree->UpdateDrawProperties(false);
+
+  // We don't have a frame yet, so the video doesn't occlude the layer below it.
+  EXPECT_FALSE(draw_properties.occlusion_in_content_space.IsOccluded(visible));
+
+  scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame(
+      media::VideoFrame::YV12, gfx::Size(10, 10), gfx::Rect(10, 10),
+      gfx::Size(10, 10), base::TimeDelta());
+  provider.set_frame(video_frame);
+  active_tree->set_needs_update_draw_properties();
+  active_tree->UpdateDrawProperties(false);
+
+  // We have a frame now, so the video occludes the layer below it.
+  EXPECT_TRUE(draw_properties.occlusion_in_content_space.IsOccluded(visible));
+}
+
 TEST(VideoLayerImplTest, DidBecomeActiveShouldSetActiveVideoLayer) {
   LayerTestCommon::LayerImplTest impl;
   DebugSetImplThreadAndMainThreadBlocked(impl.proxy());

cc/test/fake_video_frame_provider.cc

@@ -23,6 +23,10 @@ void FakeVideoFrameProvider::SetVideoFrameProviderClient(Client* client) {
   client_ = client;
 }
 
+bool FakeVideoFrameProvider::HasCurrentFrame() {
+  return frame_;
+}
+
 scoped_refptr<media::VideoFrame> FakeVideoFrameProvider::GetCurrentFrame() {
   return frame_;
 }

cc/test/fake_video_frame_provider.h

@@ -19,6 +19,7 @@ class FakeVideoFrameProvider : public VideoFrameProvider {
   void SetVideoFrameProviderClient(Client* client) override;
   bool UpdateCurrentFrame(base::TimeTicks deadline_min,
                           base::TimeTicks deadline_max) override;
+  bool HasCurrentFrame() override;
   scoped_refptr<media::VideoFrame> GetCurrentFrame() override;
   void PutCurrentFrame() override {}
 

content/renderer/media/android/webmediaplayer_android.cc

@@ -1280,6 +1280,11 @@ bool WebMediaPlayerAndroid::UpdateCurrentFrame(base::TimeTicks deadline_min,
   return false;
 }
 
+bool WebMediaPlayerAndroid::HasCurrentFrame() {
+  base::AutoLock auto_lock(current_frame_lock_);
+  return current_frame_;
+}
+
 scoped_refptr<media::VideoFrame> WebMediaPlayerAndroid::GetCurrentFrame() {
   scoped_refptr<VideoFrame> video_frame;
   {

content/renderer/media/android/webmediaplayer_android.h

@@ -187,6 +187,7 @@ class WebMediaPlayerAndroid : public blink::WebMediaPlayer,
       cc::VideoFrameProvider::Client* client) override;
   bool UpdateCurrentFrame(base::TimeTicks deadline_min,
                           base::TimeTicks deadline_max) override;
+  bool HasCurrentFrame() override;
   scoped_refptr<media::VideoFrame> GetCurrentFrame() override;
   void PutCurrentFrame() override;
 

content/renderer/media/webmediaplayer_ms.cc

@@ -464,6 +464,11 @@ bool WebMediaPlayerMS::UpdateCurrentFrame(base::TimeTicks deadline_min,
   return false;
 }
 
+bool WebMediaPlayerMS::HasCurrentFrame() {
+  base::AutoLock auto_lock(current_frame_lock_);
+  return current_frame_;
+}
+
 scoped_refptr<media::VideoFrame> WebMediaPlayerMS::GetCurrentFrame() {
   DVLOG(3) << "WebMediaPlayerMS::GetCurrentFrame";
   base::AutoLock auto_lock(current_frame_lock_);

content/renderer/media/webmediaplayer_ms.h

@@ -136,6 +136,7 @@ class WebMediaPlayerMS
       cc::VideoFrameProvider::Client* client) override;
   bool UpdateCurrentFrame(base::TimeTicks deadline_min,
                           base::TimeTicks deadline_max) override;
+  bool HasCurrentFrame() override;
   scoped_refptr<media::VideoFrame> GetCurrentFrame() override;
   void PutCurrentFrame() override;
 

media/blink/video_frame_compositor.cc

@@ -124,6 +124,11 @@ bool VideoFrameCompositor::UpdateCurrentFrame(base::TimeTicks deadline_min,
   return CallRender(deadline_min, deadline_max, false);
 }
 
+bool VideoFrameCompositor::HasCurrentFrame() {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  return current_frame_;
+}
+
 void VideoFrameCompositor::Start(RenderCallback* callback) {
   TRACE_EVENT0("media", "VideoFrameCompositor::Start");
 

media/blink/video_frame_compositor.h

@@ -78,6 +78,7 @@ class MEDIA_EXPORT VideoFrameCompositor
       cc::VideoFrameProvider::Client* client) override;
   bool UpdateCurrentFrame(base::TimeTicks deadline_min,
                           base::TimeTicks deadline_max) override;
+  bool HasCurrentFrame() override;
   scoped_refptr<VideoFrame> GetCurrentFrame() override;
   void PutCurrentFrame() override;