[cc] Plumb BeginFrameAcks through SurfaceManager to DisplayScheduler.

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/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
@@ skipping 83 matching lines @@
                                        public SurfaceObserver {
  public:
   CompositorFrameSinkSupportTest()
       : support_(
             CompositorFrameSinkSupport::Create(&fake_support_client_,
                                                &manager_,
                                                kArbitraryFrameSinkId,
                                                kIsRoot,
                                                kHandlesFrameSinkIdInvalidation,
                                                kNeedsSyncPoints)),
+        begin_frame_source_(0.f, false),
         local_surface_id_(3, kArbitraryToken),
         frame_sync_token_(GenTestSyncToken(4)),
         consumer_sync_token_(GenTestSyncToken(5)) {
     manager_.AddObserver(this);
+    support_->SetBeginFrameSource(&begin_frame_source_);
   }
   ~CompositorFrameSinkSupportTest() override {
     manager_.RemoveObserver(this);
     support_->EvictCurrentSurface();
   }
 
   const SurfaceId& last_created_surface_id() const {
     return last_created_surface_id_;
   }
 
   // SurfaceObserver implementation.
   void OnSurfaceCreated(const SurfaceInfo& surface_info) override {
     last_created_surface_id_ = surface_info.id();
     last_surface_info_ = surface_info;
   }
-  void OnSurfaceDamaged(const SurfaceId& id, bool* changed) override {
+  void OnSurfaceDamaged(const SurfaceId& id,
+                        const BeginFrameAck& ack,
+                        bool* changed) override {
+    last_begin_frame_ack_ = ack;
     *changed = true;
   }
   void OnSurfaceDiscarded(const SurfaceId& surface_id) override {}
+  void OnSurfaceDestroyed(const SurfaceId& surface_id) override {}
+  void OnSurfaceDamageExpected(const SurfaceId& surface_id,
+                               const BeginFrameArgs& args) override {}
 
   void SubmitCompositorFrameWithResources(ResourceId* resource_ids,
                                           size_t num_resource_ids) {
     CompositorFrame frame = MakeCompositorFrame();
     for (size_t i = 0u; i < num_resource_ids; ++i) {
       TransferableResource resource;
       resource.id = resource_ids[i];
       resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
       resource.mailbox_holder.sync_token = frame_sync_token_;
       frame.resource_list.push_back(resource);
@@ skipping 35 matching lines @@
   void RefCurrentFrameResources() {
     Surface* surface = manager_.GetSurfaceForId(
         SurfaceId(support_->frame_sink_id(), local_surface_id_));
     support_->RefResources(surface->GetActiveFrame().resource_list);
   }
 
  protected:
   SurfaceManager manager_;
   FakeCompositorFrameSinkSupportClient fake_support_client_;
   std::unique_ptr<CompositorFrameSinkSupport> support_;
+  FakeExternalBeginFrameSource begin_frame_source_;
   LocalSurfaceId local_surface_id_;
   SurfaceId last_created_surface_id_;
   SurfaceInfo last_surface_info_;
+  BeginFrameAck last_begin_frame_ack_;
 
   // This is the sync token submitted with the frame. It should never be
   // returned to the client.
   const gpu::SyncToken frame_sync_token_;
 
   // This is the sync token returned by the consumer. It should always be
   // returned to the client.
   const gpu::SyncToken consumer_sync_token_;
 };
 
@@ skipping 577 matching lines @@
 
   frame.metadata.device_scale_factor = 2.5f;
 
   support_->SubmitCompositorFrame(local_surface_id_, std::move(frame));
   SurfaceId expected_surface_id(support_->frame_sink_id(), local_surface_id_);
   EXPECT_EQ(expected_surface_id, last_surface_info_.id());
   EXPECT_EQ(2.5f, last_surface_info_.device_scale_factor());
   EXPECT_EQ(gfx::Size(7, 8), last_surface_info_.size_in_pixels());
 }
 
+TEST_F(CompositorFrameSinkSupportTest, PassesOnBeginFrameAcks) {
+  // Request BeginFrames.
+  support_->SetNeedsBeginFrame(true);
+
+  // Issue a BeginFrame.
+  BeginFrameArgs args =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 1);
+  begin_frame_source_.TestOnBeginFrame(args);
+
+  // Check that the support and SurfaceManager forward the BeginFrameAck
+  // attached to a CompositorFrame to the SurfaceObserver.
+  BeginFrameAck ack(0, 1, 1, true);
+  CompositorFrame frame = MakeCompositorFrame();
+  frame.metadata.begin_frame_ack = ack;
+  support_->SubmitCompositorFrame(local_surface_id_, std::move(frame));
+  EXPECT_EQ(ack, last_begin_frame_ack_);
+
+  // Issue another BeginFrame.
+  args = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2);
+  begin_frame_source_.TestOnBeginFrame(args);
+
+  // Check that the support and SurfaceManager forward a DidNotProduceFrame ack
+  // to the SurfaceObserver.
+  BeginFrameAck ack2(0, 2, 2, false);
+  support_->DidNotProduceFrame(ack2);
+  EXPECT_EQ(ack2, last_begin_frame_ack_);
+
+  support_->SetNeedsBeginFrame(false);
+}
+
 }  // namespace
 
 }  // namespace test
 
 }  // namespace cc