Allows VideoFrameSubmitter to return resources.

The VideoFrameSubmitter will signal to the VideoFrameResourceProvider to
PrepareSendToCompositor resources. When the compositor is done with
these resources, they must be returned.

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

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

@@ -76,4 +76,16 @@ void VideoFrameResourceProvider::AppendQuads(viz::RenderPass* render_pass) {
                            SkColorSetRGB(r % 255, g % 255, b % 255), false);
 }
 
+void VideoFrameResourceProvider::PrepareSendToParent(
+    const cc::LayerTreeResourceProvider::ResourceIdArray& resource_ids,
+    std::vector<viz::TransferableResource>* transferable_resources) {
+  resource_provider_->PrepareSendToParent(resource_ids, transferable_resources);
+}
+
+void VideoFrameResourceProvider::ReceiveReturnsFromParent(
+    const std::vector<viz::ReturnedResource>& transferable_resources) {
+  viz::ContextProvider::ScopedContextLock lock(context_provider_);
+  resource_provider_->ReceiveReturnsFromParent(transferable_resources);
+}
+
 }  // namespace blink

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

@@ -38,6 +38,12 @@ class PLATFORM_EXPORT VideoFrameResourceProvider {
   virtual void Initialize(viz::ContextProvider*);
   virtual void AppendQuads(viz::RenderPass*);
 
+  virtual void PrepareSendToParent(
+      const cc::LayerTreeResourceProvider::ResourceIdArray& resource_ids,
+      std::vector<viz::TransferableResource>* transferable_resources);
+  virtual void ReceiveReturnsFromParent(
+      const std::vector<viz::ReturnedResource>& transferable_resources);
+
  private:
   WebContextProviderCallback context_provider_callback_;
   viz::SharedBitmapManager* shared_bitmap_manager_;

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

@@ -6,6 +6,7 @@
 
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "cc/base/filter_operations.h"
+#include "cc/resources/resource_provider.h"
 #include "cc/resources/video_resource_updater.h"
 #include "cc/scheduler/video_frame_controller.h"
 #include "components/viz/common/surfaces/local_surface_id_allocator.h"
@@ -120,6 +121,15 @@ void VideoFrameSubmitter::SubmitFrame(
   compositor_frame.metadata.device_scale_factor = 1;
   compositor_frame.metadata.may_contain_video = true;
 
+  cc::ResourceProvider::ResourceIdArray resources;
+  for (auto* quad : render_pass->quad_list) {
+    for (viz::ResourceId resource_id : quad->resources) {
+      resources.push_back(resource_id);
+    }
+  }
+  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.
@@ -154,7 +164,19 @@ void VideoFrameSubmitter::OnBeginFrame(const viz::BeginFrameArgs& args) {
 }
 
 void VideoFrameSubmitter::DidReceiveCompositorFrameAck(
-    const WTF::Vector<viz::ReturnedResource>& resources) {}
+    const WTF::Vector<viz::ReturnedResource>& resources) {
+  DCHECK_CALLED_ON_VALID_THREAD(media_thread_checker_);
+  ReclaimResources(resources);
+}
+
+void VideoFrameSubmitter::ReclaimResources(
+    const WTF::Vector<viz::ReturnedResource>& resources) {
+  DCHECK_CALLED_ON_VALID_THREAD(media_thread_checker_);
+  WebVector<viz::ReturnedResource> temp_resources = resources;
+  std::vector<viz::ReturnedResource> std_resources =
+      temp_resources.ReleaseVector();
+  resource_provider_->ReceiveReturnsFromParent(std_resources);
+}
 
 void VideoFrameSubmitter::DidPresentCompositorFrame(
     uint32_t presentation_token,

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

@@ -64,7 +64,7 @@ class PLATFORM_EXPORT VideoFrameSubmitter
   void OnBeginFrame(const viz::BeginFrameArgs&) override;
   void OnBeginFramePausedChanged(bool paused) override {}
   void ReclaimResources(
-      const WTF::Vector<viz::ReturnedResource>& resources) override {}
+      const WTF::Vector<viz::ReturnedResource>& resources) override;
 
  private:
   void SubmitFrame(viz::BeginFrameAck, scoped_refptr<media::VideoFrame>);

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

@@ -41,7 +41,6 @@ class MockVideoFrameProvider : public cc::VideoFrameProvider {
   MOCK_METHOD0(HasCurrentFrame, bool());
   MOCK_METHOD0(GetCurrentFrame, scoped_refptr<media::VideoFrame>());
   MOCK_METHOD0(PutCurrentFrame, void());
-  MOCK_METHOD0(task_runner, scoped_refptr<base::SingleThreadTaskRunner>());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockVideoFrameProvider);
@@ -88,6 +87,12 @@ class MockVideoFrameResourceProvider
 
   MOCK_METHOD1(Initialize, void(viz::ContextProvider*));
   MOCK_METHOD1(AppendQuads, void(viz::RenderPass*));
+  MOCK_METHOD2(PrepareSendToParent,
+               void(const cc::LayerTreeResourceProvider::ResourceIdArray&,
+                    std::vector<viz::TransferableResource>*));
+  MOCK_METHOD1(
+      ReceiveReturnsFromParent,
+      void(const std::vector<viz::ReturnedResource>& transferable_resources));
   MOCK_METHOD0(ObtainContextProvider, void());
 
  private:
@@ -177,6 +182,7 @@ TEST_F(VideoFrameSubmitterTest,
   EXPECT_CALL(*provider_, PutCurrentFrame());
   EXPECT_CALL(*sink_, SetNeedsBeginFrame(false));
   EXPECT_CALL(*resource_provider_, AppendQuads(_));
+  EXPECT_CALL(*resource_provider_, PrepareSendToParent(_, _));
 
   submitter_->StopUsingProvider();
 
@@ -213,6 +219,7 @@ TEST_F(VideoFrameSubmitterTest, DidReceiveFrameSubmitsFrame) {
   EXPECT_CALL(*sink_, DoSubmitCompositorFrame(_, _));
   EXPECT_CALL(*provider_, PutCurrentFrame());
   EXPECT_CALL(*resource_provider_, AppendQuads(_));
+  EXPECT_CALL(*resource_provider_, PrepareSendToParent(_, _));
 
   submitter_->DidReceiveFrame();
   scoped_task_environment_.RunUntilIdle();
@@ -235,6 +242,7 @@ TEST_F(VideoFrameSubmitterTest, OnBeginFrameSubmitsFrame) {
   EXPECT_CALL(*sink_, DoSubmitCompositorFrame(_, _));
   EXPECT_CALL(*provider_, PutCurrentFrame());
   EXPECT_CALL(*resource_provider_, AppendQuads(_));
+  EXPECT_CALL(*resource_provider_, PrepareSendToParent(_, _));
 
   viz::BeginFrameArgs args = begin_frame_source_->CreateBeginFrameArgs(
       BEGINFRAME_FROM_HERE, now_src_.get());
@@ -295,4 +303,14 @@ TEST_F(VideoFrameSubmitterTest, NotRenderingDoesNotProduceFrame) {
   scoped_task_environment_.RunUntilIdle();
 }
 
+TEST_F(VideoFrameSubmitterTest, ReturnsResourceOnCompositorAck) {
+  MakeSubmitter();
+  scoped_task_environment_.RunUntilIdle();
+
+  WTF::Vector<viz::ReturnedResource> resources;
+  EXPECT_CALL(*resource_provider_, ReceiveReturnsFromParent(_));
+  submitter_->DidReceiveCompositorFrameAck(resources);
+  scoped_task_environment_.RunUntilIdle();
+}
+
 }  // namespace blink