Pass returned resources to DidReceiveCompositorFrameAck

cc/surfaces/compositor_frame_sink_support_unittest.cc

 // Copyright 2017 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 "cc/surfaces/compositor_frame_sink_support.h"
 
 #include "base/debug/stack_trace.h"
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/surfaces/compositor_frame_sink_support_client.h"
 #include "cc/surfaces/frame_sink_id.h"
 #include "cc/surfaces/surface_id.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_external_begin_frame_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::UnorderedElementsAre;
 using testing::IsEmpty;
 using testing::SizeIs;
 using testing::Invoke;
 using testing::_;
-using testing::InSequence;
+using testing::Eq;
 
 namespace cc {
 namespace test {
 namespace {
 
 constexpr FrameSinkId kDisplayFrameSink(2, 0);
 constexpr FrameSinkId kParentFrameSink(3, 0);
 constexpr FrameSinkId kChildFrameSink1(65563, 0);
 constexpr FrameSinkId kChildFrameSink2(65564, 0);
 constexpr FrameSinkId kArbitraryFrameSink(1337, 7331);
 
 class MockCompositorFrameSinkSupportClient
     : public CompositorFrameSinkSupportClient {
  public:
   MockCompositorFrameSinkSupportClient() {
     ON_CALL(*this, ReclaimResources(_))
         .WillByDefault(Invoke(
             this,
             &MockCompositorFrameSinkSupportClient::ReclaimResourcesInternal));
+    ON_CALL(*this, DidReceiveCompositorFrameAck(_))
+        .WillByDefault(Invoke(
+            this,
+            &MockCompositorFrameSinkSupportClient::ReclaimResourcesInternal));
   }
 
   ReturnedResourceArray& last_returned_resources() {
     return last_returned_resources_;
   }
 
   // CompositorFrameSinkSupportClient implementation.
-  MOCK_METHOD0(DidReceiveCompositorFrameAck, void());
+  MOCK_METHOD1(DidReceiveCompositorFrameAck,
+               void(const ReturnedResourceArray&));
   MOCK_METHOD1(OnBeginFrame, void(const BeginFrameArgs&));
   MOCK_METHOD1(ReclaimResources, void(const ReturnedResourceArray&));
   MOCK_METHOD2(WillDrawSurface, void(const LocalSurfaceId&, const gfx::Rect&));
 
  private:
   void ReclaimResourcesInternal(const ReturnedResourceArray& resources) {
     last_returned_resources_ = resources;
   }
 
   ReturnedResourceArray last_returned_resources_;
@@ skipping 935 matching lines @@
   // Check that the support forwards the BeginFrameAck attached
   // to a CompositorFrame to the BeginFrameSource.
   BeginFrameAck ack2(0, 2, 2, true);
   CompositorFrame frame = MakeCompositorFrame();
   frame.metadata.begin_frame_ack = ack2;
   display_support().SubmitCompositorFrame(display_id.local_surface_id(),
                                           std::move(frame));
   EXPECT_EQ(ack2, begin_frame_source()->LastAckForObserver(&display_support()));
 }
 
-// Checks whether the resources are returned before we send an ack.
-TEST_F(CompositorFrameSinkSupportTest, ReturnResourcesBeforeAck) {
+// Checks that resources and ack are sent together if possible.
+TEST_F(CompositorFrameSinkSupportTest, ReturnResourcesWithAck) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   TransferableResource resource;
   resource.id = 1234;
   parent_support().SubmitCompositorFrame(
       parent_id.local_surface_id(),
       MakeCompositorFrameWithResources(empty_surface_ids(), {resource}));
-  {
-    InSequence x;
-    EXPECT_CALL(support_client_, ReclaimResources(_));
-    EXPECT_CALL(support_client_, DidReceiveCompositorFrameAck());
-  }
+  ReturnedResourceArray returned_resources;
+  TransferableResource::ReturnResources({resource}, &returned_resources);
+  EXPECT_CALL(support_client_, ReclaimResources(_)).Times(0);
+  EXPECT_CALL(support_client_,
+              DidReceiveCompositorFrameAck(Eq(returned_resources)));
   parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
                                          MakeCompositorFrame());
 }
 
 // Verifies that if a surface is marked destroyed and a new frame arrives for
 // it, it will be recovered.
 TEST_F(CompositorFrameSinkSupportTest, SurfaceResurrection) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id = MakeSurfaceId(kChildFrameSink1, 3);
 
@@ skipping 207 matching lines @@
   EXPECT_FALSE(dependency_tracker().has_deadline());
   EXPECT_FALSE(display_surface()->HasPendingFrame());
   EXPECT_TRUE(display_surface()->HasActiveFrame());
   EXPECT_THAT(display_surface()->blocking_surfaces(), IsEmpty());
   EXPECT_THAT(GetChildReferences(display_id),
               UnorderedElementsAre(parent_id1, parent_id2));
 }
 
 }  // namespace test
 }  // namespace cc