Obtains ExternalResources for VideoFrameSubmitter.

The result of this CL should be that the frames submitted by the
VideoFrameSubmitter now have complete information and thus should show
up on the screen.

This CL accomplishes this mainly through a refactor of VideoLayerImpl
shared functions into VideoResourceUpdater, making them accessible to
VideoFrameSubmitter.

Bug: 746182
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
Change-Id: I6cfe9d181e3cde4c13299c42df40ab73480a0587
Reviewed-on: https://chromium-review.googlesource.com/701917Reviewed-by: enne <enne@chromium.org>
Reviewed-by: Frank Liberato <liberato@chromium.org>
Reviewed-by: Philip Rogers <pdr@chromium.org>
Commit-Queue: CJ DiMeglio <lethalantidote@chromium.org>
Cr-Commit-Position: refs/heads/master@{#519952}

cc/layers/video_layer_impl.cc

@@ -106,37 +106,7 @@ bool VideoLayerImpl::WillDraw(DrawMode draw_mode,
         layer_tree_impl()->resource_provider(),
         layer_tree_impl()->settings().use_stream_video_draw_quad));
   }
-
-  VideoFrameExternalResources external_resources =
-      updater_->CreateExternalResourcesFromVideoFrame(frame_);
-  frame_resource_type_ = external_resources.type;
-
-  if (external_resources.type ==
-      VideoFrameExternalResources::SOFTWARE_RESOURCE) {
-    DCHECK_GT(external_resources.software_resource, viz::kInvalidResourceId);
-    software_resource_ = external_resources.software_resource;
-    software_release_callback_ =
-        std::move(external_resources.software_release_callback);
-    return true;
-  }
-  frame_resource_offset_ = external_resources.offset;
-  frame_resource_multiplier_ = external_resources.multiplier;
-  frame_bits_per_channel_ = external_resources.bits_per_channel;
-
-  DCHECK_EQ(external_resources.resources.size(),
-            external_resources.release_callbacks.size());
-  ResourceProvider::ResourceIdArray resource_ids;
-  resource_ids.reserve(external_resources.resources.size());
-  for (size_t i = 0; i < external_resources.resources.size(); ++i) {
-    unsigned resource_id = resource_provider->ImportResource(
-        external_resources.resources[i],
-        viz::SingleReleaseCallback::Create(
-            std::move(external_resources.release_callbacks[i])));
-    frame_resources_.push_back(
-        FrameResource(resource_id, external_resources.resources[i].size));
-    resource_ids.push_back(resource_id);
-  }
-
+  updater_->ObtainFrameResources(frame_);
   return true;
 }
 
@@ -165,153 +135,20 @@ void VideoLayerImpl::AppendQuads(viz::RenderPass* render_pass,
       break;
   }
 
-  viz::SharedQuadState* shared_quad_state =
-      render_pass->CreateAndAppendSharedQuadState();
-  gfx::Rect rotated_size_rect(rotated_size);
-  shared_quad_state->SetAll(transform, rotated_size_rect, visible_layer_rect(),
-                            clip_rect(), is_clipped(), contents_opaque(),
-                            draw_opacity(), SkBlendMode::kSrcOver,
-                            GetSortingContextId());
-
-  AppendDebugBorderQuad(render_pass, rotated_size_rect, shared_quad_state,
-                        append_quads_data);
-
-  gfx::Rect quad_rect(rotated_size);
-  gfx::Rect visible_rect = frame_->visible_rect();
-  bool needs_blending = !contents_opaque();
-  gfx::Size coded_size = frame_->coded_size();
-
   Occlusion occlusion_in_video_space =
       draw_properties()
           .occlusion_in_content_space.GetOcclusionWithGivenDrawTransform(
               transform);
   gfx::Rect visible_quad_rect =
-      occlusion_in_video_space.GetUnoccludedContentRect(quad_rect);
+      occlusion_in_video_space.GetUnoccludedContentRect(
+          gfx::Rect(rotated_size));
   if (visible_quad_rect.IsEmpty())
     return;
 
-  const float tex_width_scale =
-      static_cast<float>(visible_rect.width()) / coded_size.width();
-  const float tex_height_scale =
-      static_cast<float>(visible_rect.height()) / coded_size.height();
-
-  switch (frame_resource_type_) {
-    // TODO(danakj): Remove this, hide it in the hardware path.
-    case VideoFrameExternalResources::SOFTWARE_RESOURCE: {
-      DCHECK_EQ(frame_resources_.size(), 0u);
-      DCHECK_GT(software_resource_, viz::kInvalidResourceId);
-      bool premultiplied_alpha = true;
-      gfx::PointF uv_top_left(0.f, 0.f);
-      gfx::PointF uv_bottom_right(tex_width_scale, tex_height_scale);
-      float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
-      bool flipped = false;
-      bool nearest_neighbor = false;
-      auto* texture_quad =
-          render_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
-      texture_quad->SetNew(
-          shared_quad_state, quad_rect, visible_quad_rect, needs_blending,
-          software_resource_, premultiplied_alpha, uv_top_left, uv_bottom_right,
-          SK_ColorTRANSPARENT, opacity, flipped, nearest_neighbor, false);
-      ValidateQuadResources(texture_quad);
-      break;
-    }
-    case VideoFrameExternalResources::YUV_RESOURCE: {
-      const gfx::Size ya_tex_size = coded_size;
-
-      int u_width = media::VideoFrame::Columns(
-          media::VideoFrame::kUPlane, frame_->format(), coded_size.width());
-      int u_height = media::VideoFrame::Rows(
-          media::VideoFrame::kUPlane, frame_->format(), coded_size.height());
-      gfx::Size uv_tex_size(u_width, u_height);
-
-      if (frame_->HasTextures()) {
-        if (frame_->format() == media::PIXEL_FORMAT_NV12) {
-          DCHECK_EQ(2u, frame_resources_.size());
-        } else {
-          DCHECK_EQ(media::PIXEL_FORMAT_I420, frame_->format());
-          DCHECK_EQ(3u,
-                    frame_resources_.size());  // Alpha is not supported yet.
-        }
-      } else {
-        DCHECK_GE(frame_resources_.size(), 3u);
-        DCHECK(frame_resources_.size() <= 3 ||
-               ya_tex_size == media::VideoFrame::PlaneSize(
-                                  frame_->format(), media::VideoFrame::kAPlane,
-                                  coded_size));
-      }
-
-      // Compute the UV sub-sampling factor based on the ratio between
-      // |ya_tex_size| and |uv_tex_size|.
-      float uv_subsampling_factor_x =
-          static_cast<float>(ya_tex_size.width()) / uv_tex_size.width();
-      float uv_subsampling_factor_y =
-          static_cast<float>(ya_tex_size.height()) / uv_tex_size.height();
-      gfx::RectF ya_tex_coord_rect(visible_rect);
-      gfx::RectF uv_tex_coord_rect(
-          visible_rect.x() / uv_subsampling_factor_x,
-          visible_rect.y() / uv_subsampling_factor_y,
-          visible_rect.width() / uv_subsampling_factor_x,
-          visible_rect.height() / uv_subsampling_factor_y);
-
-      auto* yuv_video_quad =
-          render_pass->CreateAndAppendDrawQuad<viz::YUVVideoDrawQuad>();
-      yuv_video_quad->SetNew(
-          shared_quad_state, quad_rect, visible_quad_rect, needs_blending,
-          ya_tex_coord_rect, uv_tex_coord_rect, ya_tex_size, uv_tex_size,
-          frame_resources_[0].id, frame_resources_[1].id,
-          frame_resources_.size() > 2 ? frame_resources_[2].id
-                                      : frame_resources_[1].id,
-          frame_resources_.size() > 3 ? frame_resources_[3].id : 0,
-          frame_->ColorSpace(), frame_resource_offset_,
-          frame_resource_multiplier_, frame_bits_per_channel_);
-      yuv_video_quad->require_overlay = frame_->metadata()->IsTrue(
-          media::VideoFrameMetadata::REQUIRE_OVERLAY);
-      ValidateQuadResources(yuv_video_quad);
-      break;
-    }
-    case VideoFrameExternalResources::RGBA_RESOURCE:
-    case VideoFrameExternalResources::RGBA_PREMULTIPLIED_RESOURCE:
-    case VideoFrameExternalResources::RGB_RESOURCE: {
-      DCHECK_EQ(frame_resources_.size(), 1u);
-      if (frame_resources_.size() < 1u)
-        break;
-      bool premultiplied_alpha =
-          frame_resource_type_ ==
-          VideoFrameExternalResources::RGBA_PREMULTIPLIED_RESOURCE;
-      gfx::PointF uv_top_left(0.f, 0.f);
-      gfx::PointF uv_bottom_right(tex_width_scale, tex_height_scale);
-      float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
-      bool flipped = false;
-      bool nearest_neighbor = false;
-      auto* texture_quad =
-          render_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
-      texture_quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect,
-                           needs_blending, frame_resources_[0].id,
-                           premultiplied_alpha, uv_top_left, uv_bottom_right,
-                           SK_ColorTRANSPARENT, opacity, flipped,
-                           nearest_neighbor, false);
-      texture_quad->set_resource_size_in_pixels(coded_size);
-      ValidateQuadResources(texture_quad);
-      break;
-    }
-    case VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE: {
-      DCHECK_EQ(frame_resources_.size(), 1u);
-      if (frame_resources_.size() < 1u)
-        break;
-      gfx::Transform scale;
-      scale.Scale(tex_width_scale, tex_height_scale);
-      auto* stream_video_quad =
-          render_pass->CreateAndAppendDrawQuad<viz::StreamVideoDrawQuad>();
-      stream_video_quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect,
-                                needs_blending, frame_resources_[0].id,
-                                frame_resources_[0].size_in_pixels, scale);
-      ValidateQuadResources(stream_video_quad);
-      break;
-    }
-    case VideoFrameExternalResources::NONE:
-      NOTIMPLEMENTED();
-      break;
-  }
+  updater_->AppendQuads(render_pass, frame_, transform, rotated_size,
+                        visible_layer_rect(), clip_rect(), is_clipped(),
+                        contents_opaque(), draw_opacity(),
+                        GetSortingContextId(), visible_quad_rect);
 }
 
 void VideoLayerImpl::DidDraw(LayerTreeResourceProvider* resource_provider) {
@@ -319,17 +156,7 @@ void VideoLayerImpl::DidDraw(LayerTreeResourceProvider* resource_provider) {
 
   DCHECK(frame_.get());
 
-  if (frame_resource_type_ ==
-      VideoFrameExternalResources::SOFTWARE_RESOURCE) {
-    DCHECK_GT(software_resource_, viz::kInvalidResourceId);
-    std::move(software_release_callback_).Run(gpu::SyncToken(), false);
-    software_resource_ = viz::kInvalidResourceId;
-  } else {
-    for (const FrameResource& resource : frame_resources_)
-      resource_provider->RemoveImportedResource(resource.id);
-    frame_resources_.clear();
-  }
-
+  updater_->ReleaseFrameResources();
   provider_client_impl_->PutCurrentFrame();
   frame_ = nullptr;
 

cc/layers/video_layer_impl.h

@@ -63,23 +63,6 @@ class CC_EXPORT VideoLayerImpl : public LayerImpl {
   media::VideoRotation video_rotation_;
 
   std::unique_ptr<VideoResourceUpdater> updater_;
-  VideoFrameExternalResources::ResourceType frame_resource_type_;
-  float frame_resource_offset_;
-  float frame_resource_multiplier_;
-  uint32_t frame_bits_per_channel_;
-
-  struct FrameResource {
-    FrameResource(viz::ResourceId id, gfx::Size size_in_pixels)
-        : id(id), size_in_pixels(size_in_pixels) {}
-    viz::ResourceId id;
-    gfx::Size size_in_pixels;
-  };
-  std::vector<FrameResource> frame_resources_;
-
-  // TODO(danakj): Remove these, use TransferableResource for software path too.
-  unsigned software_resource_ = viz::kInvalidResourceId;
-  // Called once for software_resource_.
-  viz::ReleaseCallback software_release_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoLayerImpl);
 };

cc/resources/video_resource_updater.h

@@ -29,12 +29,18 @@ class PaintCanvasVideoRenderer;
 class VideoFrame;
 }
 
+namespace gfx {
+class Rect;
+class Transform;
+}  // namespace gfx
+
 namespace viz {
 class ContextProvider;
+class RenderPass;
 }
 
 namespace cc {
-class ResourceProvider;
+class LayerTreeResourceProvider;
 
 class CC_EXPORT VideoFrameExternalResources {
  public:
@@ -50,7 +56,6 @@ class CC_EXPORT VideoFrameExternalResources {
 
     SOFTWARE_RESOURCE
   };
-
   ResourceType type = NONE;
   std::vector<viz::TransferableResource> resources;
   std::vector<viz::ReleaseCallback> release_callbacks;
@@ -77,7 +82,7 @@ class CC_EXPORT VideoFrameExternalResources {
 class CC_EXPORT VideoResourceUpdater {
  public:
   VideoResourceUpdater(viz::ContextProvider* context_provider,
-                       ResourceProvider* resource_provider,
+                       LayerTreeResourceProvider* resource_provider,
                        bool use_stream_video_draw_quad);
   ~VideoResourceUpdater();
 
@@ -88,6 +93,20 @@ class CC_EXPORT VideoResourceUpdater {
     use_r16_for_testing_ = use_r16_for_testing;
   }
 
+  void ObtainFrameResources(scoped_refptr<media::VideoFrame> video_frame);
+  void ReleaseFrameResources();
+  void AppendQuads(viz::RenderPass* render_pass,
+                   scoped_refptr<media::VideoFrame> frame,
+                   gfx::Transform transform,
+                   gfx::Size rotated_size,
+                   gfx::Rect visible_layer_rect,
+                   gfx::Rect clip_rect,
+                   bool is_clipped,
+                   bool context_opaque,
+                   float draw_opacity,
+                   int sorting_context_id,
+                   gfx::Rect visible_quad_rect);
+
  private:
   class PlaneResource {
    public:
@@ -178,12 +197,30 @@ class CC_EXPORT VideoResourceUpdater {
                             bool lost_resource);
 
   viz::ContextProvider* context_provider_;
-  ResourceProvider* resource_provider_;
+  LayerTreeResourceProvider* resource_provider_;
   const bool use_stream_video_draw_quad_;
   std::unique_ptr<media::PaintCanvasVideoRenderer> video_renderer_;
   std::vector<uint8_t> upload_pixels_;
   bool use_r16_for_testing_ = false;
 
+  VideoFrameExternalResources::ResourceType frame_resource_type_;
+  // TODO(danakj): Remove these, use TransferableResource for software path too.
+  unsigned software_resource_ = viz::kInvalidResourceId;
+  // Called once for |software_resource_|.
+  viz::ReleaseCallback software_release_callback_;
+
+  float frame_resource_offset_;
+  float frame_resource_multiplier_;
+  uint32_t frame_bits_per_channel_;
+
+  struct FrameResource {
+    FrameResource(viz::ResourceId id, gfx::Size size_in_pixels)
+        : id(id), size_in_pixels(size_in_pixels) {}
+    viz::ResourceId id;
+    gfx::Size size_in_pixels;
+  };
+  std::vector<FrameResource> frame_resources_;
+
   // Recycle resources so that we can reduce the number of allocations and
   // data transfers.
   ResourceList all_resources_;

cc/resources/video_resource_updater_unittest.cc

@@ -100,11 +100,14 @@ class VideoResourceUpdaterTest : public testing::Test {
   void SetUp() override {
     testing::Test::SetUp();
     shared_bitmap_manager_.reset(new SharedBitmapManagerAllocationCounter());
-    resource_provider3d_ = FakeResourceProvider::Create(
-        context_provider_.get(), shared_bitmap_manager_.get(),
-        high_bit_for_testing_);
-    resource_provider_software_ = FakeResourceProvider::Create(
-        nullptr, shared_bitmap_manager_.get(), high_bit_for_testing_);
+    resource_provider3d_ =
+        FakeResourceProvider::CreateLayerTreeResourceProvider(
+            context_provider_.get(), shared_bitmap_manager_.get(), nullptr,
+            high_bit_for_testing_);
+    resource_provider_software_ =
+        FakeResourceProvider::CreateLayerTreeResourceProvider(
+            nullptr, shared_bitmap_manager_.get(), nullptr,
+            high_bit_for_testing_);
   }
 
   scoped_refptr<media::VideoFrame> CreateTestYUVVideoFrame() {
@@ -242,8 +245,8 @@ class VideoResourceUpdaterTest : public testing::Test {
   WebGraphicsContext3DUploadCounter* context3d_;
   scoped_refptr<TestContextProvider> context_provider_;
   std::unique_ptr<SharedBitmapManagerAllocationCounter> shared_bitmap_manager_;
-  std::unique_ptr<ResourceProvider> resource_provider3d_;
-  std::unique_ptr<ResourceProvider> resource_provider_software_;
+  std::unique_ptr<LayerTreeResourceProvider> resource_provider3d_;
+  std::unique_ptr<LayerTreeResourceProvider> resource_provider_software_;
   gpu::SyncToken release_sync_token_;
   bool high_bit_for_testing_ = false;
 };

cc/test/fake_resource_provider.h

@@ -36,11 +36,13 @@ class FakeResourceProvider : public ResourceProvider {
   CreateLayerTreeResourceProvider(
       viz::ContextProvider* context_provider,
       viz::SharedBitmapManager* shared_bitmap_manager,
-      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager = nullptr) {
+      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager = nullptr,
+      bool high_bit_for_testing = false) {
     viz::ResourceSettings resource_settings;
     resource_settings.texture_id_allocation_chunk_size = 1;
     resource_settings.buffer_to_texture_target_map =
         viz::DefaultBufferToTextureTargetMapForTesting();
+    resource_settings.high_bit_for_testing = high_bit_for_testing;
     return std::make_unique<LayerTreeResourceProvider>(
         context_provider, shared_bitmap_manager, gpu_memory_buffer_manager,
         true, resource_settings);

components/viz/service/display/renderer_pixeltest.cc

@@ -1325,7 +1325,7 @@ class VideoGLRendererPixelTest : public cc::GLRendererPixelTest {
     GLRendererPixelTest::SetUp();
     bool use_stream_video_draw_quad = false;
     video_resource_updater_ = std::make_unique<cc::VideoResourceUpdater>(
-        output_surface_->context_provider(), resource_provider_.get(),
+        child_context_provider_.get(), child_resource_provider_.get(),
         use_stream_video_draw_quad);
   }
 

third_party/WebKit/Source/platform/graphics/VideoFrameResourceProvider.cpp

@@ -11,8 +11,15 @@
 #include "cc/resources/video_resource_updater.h"
 #include "components/viz/common/quads/render_pass.h"
 #include "components/viz/common/quads/solid_color_draw_quad.h"
+#include "components/viz/common/quads/texture_draw_quad.h"
+#include "components/viz/common/quads/yuv_video_draw_quad.h"
+#include "media/base/video_frame.h"
 #include "platform/wtf/WeakPtr.h"
 
+namespace cc {
+class VideoFrameExternalResources;
+}  // namespace cc
+
 namespace blink {
 
 VideoFrameResourceProvider::VideoFrameResourceProvider(
@@ -44,36 +51,41 @@ void VideoFrameResourceProvider::Initialize(
   context_provider_ = media_context_provider;
 
   viz::ContextProvider::ScopedContextLock lock(context_provider_);
-  // TODO(lethalantidote): Get real value for delegated_sync_points_required.
   resource_provider_ = std::make_unique<cc::LayerTreeResourceProvider>(
       media_context_provider, shared_bitmap_manager_,
-      gpu_memory_buffer_manager_, false, settings_.resource_settings);
+      gpu_memory_buffer_manager_, true, settings_.resource_settings);
 
   resource_updater_ = std::make_unique<cc::VideoResourceUpdater>(
       media_context_provider, resource_provider_.get(),
       settings_.use_stream_video_draw_quad);
 }
 
-void VideoFrameResourceProvider::AppendQuads(viz::RenderPass* render_pass) {
-  gfx::Rect rect(0, 0, 10000, 10000);
-  gfx::Rect visible_rect(0, 0, 10000, 10000);
+void VideoFrameResourceProvider::AppendQuads(
+    viz::RenderPass* render_pass,
+    scoped_refptr<media::VideoFrame> frame) {
+  viz::ContextProvider::ScopedContextLock lock(context_provider_);
+  resource_updater_->ObtainFrameResources(frame);
+  // TODO(lethalantidote) : update with true value;
+  bool contents_opaque = true;
+  gfx::Rect visible_layer_rect = gfx::Rect(frame->coded_size());
+  gfx::Rect clip_rect = gfx::Rect(frame->coded_size());
   bool is_clipped = false;
-  bool are_contents_opaque = true;
-  viz::SharedQuadState* shared_state =
-      render_pass->CreateAndAppendSharedQuadState();
-  shared_state->SetAll(gfx::Transform(), rect, rect, rect, is_clipped,
-                       are_contents_opaque, 1, SkBlendMode::kSrcOver, 0);
-  viz::SolidColorDrawQuad* solid_color_quad =
-      render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-  // Fluxuate colors for placeholder testing.
-  static int r = 0;
-  static int g = 0;
-  static int b = 0;
-  r++;
-  g += 2;
-  b += 3;
-  solid_color_quad->SetNew(shared_state, rect, visible_rect,
-                           SkColorSetRGB(r % 255, g % 255, b % 255), false);
+  float draw_opacity = 1.0f;
+  int sorting_context_id = 0;
+
+  // Internal to this compositor frame, this video quad is never occluded,
+  // thus the full quad is visible.
+  gfx::Rect visible_quad_rect = gfx::Rect(frame->coded_size());
+
+  resource_updater_->AppendQuads(
+      render_pass, frame, gfx::Transform(), frame->coded_size(),
+      visible_layer_rect, clip_rect, is_clipped, contents_opaque, draw_opacity,
+      sorting_context_id, visible_quad_rect);
+}
+
+void VideoFrameResourceProvider::ReleaseFrameResources() {
+  viz::ContextProvider::ScopedContextLock lock(context_provider_);
+  resource_updater_->ReleaseFrameResources();
 }
 
 void VideoFrameResourceProvider::PrepareSendToParent(

third_party/WebKit/Source/platform/graphics/VideoFrameResourceProvider.h

@@ -37,7 +37,8 @@ class PLATFORM_EXPORT VideoFrameResourceProvider {
 
   virtual void ObtainContextProvider();
   virtual void Initialize(viz::ContextProvider*);
-  virtual void AppendQuads(viz::RenderPass*);
+  virtual void AppendQuads(viz::RenderPass*, scoped_refptr<media::VideoFrame>);
+  virtual void ReleaseFrameResources();
 
   virtual void PrepareSendToParent(
       const cc::LayerTreeResourceProvider::ResourceIdArray& resource_ids,

third_party/WebKit/Source/platform/graphics/VideoFrameSubmitter.cpp

@@ -116,7 +116,7 @@ void VideoFrameSubmitter::SubmitFrame(
   render_pass->SetNew(1, gfx::Rect(video_frame->coded_size()),
                       gfx::Rect(video_frame->coded_size()), gfx::Transform());
   render_pass->filters = cc::FilterOperations();
-  resource_provider_->AppendQuads(render_pass.get());
+  resource_provider_->AppendQuads(render_pass.get(), video_frame);
   compositor_frame.metadata.begin_frame_ack = begin_frame_ack;
   compositor_frame.metadata.device_scale_factor = 1;
   compositor_frame.metadata.may_contain_video = true;
@@ -129,12 +129,12 @@ void VideoFrameSubmitter::SubmitFrame(
   }
   resource_provider_->PrepareSendToParent(resources,
                                           &compositor_frame.resource_list);
-
   compositor_frame.render_pass_list.push_back(std::move(render_pass));
 
   // TODO(lethalantidote): Address third/fourth arg in SubmitCompositorFrame.
   compositor_frame_sink_->SubmitCompositorFrame(
       current_local_surface_id_, std::move(compositor_frame), nullptr, 0);
+  resource_provider_->ReleaseFrameResources();
 }
 
 void VideoFrameSubmitter::OnBeginFrame(const viz::BeginFrameArgs& args) {

third_party/WebKit/Source/platform/graphics/VideoFrameSubmitterTest.cpp

@@ -88,7 +88,9 @@ class MockVideoFrameResourceProvider
   ~MockVideoFrameResourceProvider() = default;
 
   MOCK_METHOD1(Initialize, void(viz::ContextProvider*));
-  MOCK_METHOD1(AppendQuads, void(viz::RenderPass*));
+  MOCK_METHOD2(AppendQuads,
+               void(viz::RenderPass*, scoped_refptr<media::VideoFrame>));
+  MOCK_METHOD0(ReleaseFrameResources, void());
   MOCK_METHOD2(PrepareSendToParent,
                void(const cc::LayerTreeResourceProvider::ResourceIdArray&,
                     std::vector<viz::TransferableResource>*));
@@ -112,6 +114,11 @@ class VideoFrameSubmitterTest : public ::testing::Test {
     context_provider_->BindToCurrentThread();
   }
 
+  void SetUp() override {
+    MakeSubmitter();
+    scoped_task_environment_.RunUntilIdle();
+  }
+
   void MakeSubmitter() {
     resource_provider_ =
         new StrictMock<MockVideoFrameResourceProvider>(context_provider_.get());
@@ -183,8 +190,9 @@ TEST_F(VideoFrameSubmitterTest,
   EXPECT_CALL(*sink_, DoSubmitCompositorFrame(_, _));
   EXPECT_CALL(*provider_, PutCurrentFrame());
   EXPECT_CALL(*sink_, SetNeedsBeginFrame(false));
-  EXPECT_CALL(*resource_provider_, AppendQuads(_));
+  EXPECT_CALL(*resource_provider_, AppendQuads(_, _));
   EXPECT_CALL(*resource_provider_, PrepareSendToParent(_, _));
+  EXPECT_CALL(*resource_provider_, ReleaseFrameResources());
 
   submitter_->StopUsingProvider();
 
@@ -220,8 +228,9 @@ TEST_F(VideoFrameSubmitterTest, DidReceiveFrameSubmitsFrame) {
           gfx::Size(8, 8), base::TimeDelta())));
   EXPECT_CALL(*sink_, DoSubmitCompositorFrame(_, _));
   EXPECT_CALL(*provider_, PutCurrentFrame());
-  EXPECT_CALL(*resource_provider_, AppendQuads(_));
+  EXPECT_CALL(*resource_provider_, AppendQuads(_, _));
   EXPECT_CALL(*resource_provider_, PrepareSendToParent(_, _));
+  EXPECT_CALL(*resource_provider_, ReleaseFrameResources());
 
   submitter_->DidReceiveFrame();
   scoped_task_environment_.RunUntilIdle();
@@ -243,8 +252,9 @@ TEST_F(VideoFrameSubmitterTest, OnBeginFrameSubmitsFrame) {
           gfx::Size(8, 8), base::TimeDelta())));
   EXPECT_CALL(*sink_, DoSubmitCompositorFrame(_, _));
   EXPECT_CALL(*provider_, PutCurrentFrame());
-  EXPECT_CALL(*resource_provider_, AppendQuads(_));
+  EXPECT_CALL(*resource_provider_, AppendQuads(_, _));
   EXPECT_CALL(*resource_provider_, PrepareSendToParent(_, _));
+  EXPECT_CALL(*resource_provider_, ReleaseFrameResources());
 
   viz::BeginFrameArgs args = begin_frame_source_->CreateBeginFrameArgs(
       BEGINFRAME_FROM_HERE, now_src_.get());