[cc] Plumb BeginFrameAcks through SurfaceManager to DisplayScheduler.

cc/surfaces/compositor_frame_sink_support.cc

 // Copyright 2016 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 <algorithm>
 #include <utility>
 
 #include "cc/output/compositor_frame.h"
@@ skipping 68 matching lines @@
     return;
   DestroyCurrentSurface();
 }
 
 void CompositorFrameSinkSupport::SetNeedsBeginFrame(bool needs_begin_frame) {
   needs_begin_frame_ = needs_begin_frame;
   UpdateNeedsBeginFramesInternal();
 }
 
 void CompositorFrameSinkSupport::DidNotProduceFrame(const BeginFrameAck& ack) {
+  TRACE_EVENT2("cc", "CompositorFrameSinkSupport::DidNotProduceFrame",
+               "ack.source_id", ack.source_id, "ack.sequence_number",
+               ack.sequence_number);
   DCHECK_GE(ack.sequence_number, BeginFrameArgs::kStartingFrameNumber);
 
   // |has_damage| is not transmitted, but false by default.
   DCHECK(!ack.has_damage);
 
-  // TODO(eseckler): Forward |ack| via SurfaceObservers.
-
+  if (current_surface_)
+    surface_manager_->SurfaceModified(current_surface_->surface_id(), ack);
   if (begin_frame_source_)
     begin_frame_source_->DidFinishFrame(this);
 }
 
 bool CompositorFrameSinkSupport::SubmitCompositorFrame(
     const LocalSurfaceId& local_surface_id,
     CompositorFrame frame) {
   TRACE_EVENT0("cc", "CompositorFrameSinkSupport::SubmitCompositorFrame");
   DCHECK(local_surface_id.is_valid());
   DCHECK(!frame.render_pass_list.empty());
@@ skipping 52 matching lines @@
 
   if (!result)
     return false;
 
   if (current_surface_) {
     surface->SetPreviousFrameSurface(current_surface_.get());
     DestroyCurrentSurface();
   }
   current_surface_ = std::move(surface);
 
-  // TODO(eseckler): Forward |ack| via SurfaceObservers.
-
   if (begin_frame_source_)
     begin_frame_source_->DidFinishFrame(this);
 
   return true;
 }
 
 void CompositorFrameSinkSupport::UpdateSurfaceReferences(
     const SurfaceId& last_surface_id,
     const LocalSurfaceId& local_surface_id) {
   const bool surface_id_changed =
@@ skipping 110 matching lines @@
 
 void CompositorFrameSinkSupport::Init(SurfaceManager* surface_manager) {
   surface_manager_ = surface_manager;
   if (handles_frame_sink_id_invalidation_)
     surface_manager_->RegisterFrameSinkId(frame_sink_id_);
   surface_manager_->RegisterFrameSinkManagerClient(frame_sink_id_, this);
 }
 
 void CompositorFrameSinkSupport::OnBeginFrame(const BeginFrameArgs& args) {
   UpdateNeedsBeginFramesInternal();
+  if (current_surface_) {
+    surface_manager_->SurfaceDamageExpected(current_surface_->surface_id(),
+                                            args);
+  }
   last_begin_frame_args_ = args;
   if (client_)
     client_->OnBeginFrame(args);
 }
 
 const BeginFrameArgs& CompositorFrameSinkSupport::LastUsedBeginFrameArgs()
     const {
   return last_begin_frame_args_;
 }
 
 void CompositorFrameSinkSupport::OnBeginFrameSourcePausedChanged(bool paused) {}
 
 void CompositorFrameSinkSupport::OnSurfaceActivated(Surface* surface) {
   DCHECK(surface->HasActiveFrame());
+  const CompositorFrame& frame = surface->GetActiveFrame();
   if (!seen_first_frame_activation_) {
+    // SurfaceCreated only applies for the first Surface activation.
     seen_first_frame_activation_ = true;
 
-    const CompositorFrame& frame = surface->GetActiveFrame();
     gfx::Size frame_size = frame.render_pass_list.back()->output_rect.size();
-
-    // SurfaceCreated only applies for the first Surface activation. Thus,
-    // SurfaceFactory stops observing new activations after the first one.
     surface_manager_->SurfaceCreated(SurfaceInfo(
         surface->surface_id(), frame.metadata.device_scale_factor, frame_size));
   }
   // Fire SurfaceCreated first so that a temporary reference is added before it
   // is potentially transformed into a real reference by the client.
   ReferencedSurfacesChanged(surface->surface_id().local_surface_id(),
                             surface->active_referenced_surfaces());
-  if (!surface_manager_->SurfaceModified(surface->surface_id())) {
+  if (!surface_manager_->SurfaceModified(surface->surface_id(),
+                                         frame.metadata.begin_frame_ack)) {
     TRACE_EVENT_INSTANT0("cc", "Damage not visible.", TRACE_EVENT_SCOPE_THREAD);
     surface->RunDrawCallback();
   }
   surface_manager_->SurfaceActivated(surface);
 }
 
 void CompositorFrameSinkSupport::UpdateNeedsBeginFramesInternal() {
   if (!begin_frame_source_)
     return;
 
@@ skipping 18 matching lines @@
   surface_manager_->DestroySurface(std::move(current_surface_));
 }
 
 void CompositorFrameSinkSupport::RequestCopyOfSurface(
     std::unique_ptr<CopyOutputRequest> copy_request) {
   if (!current_surface_)
     return;
 
   DCHECK(current_surface_->compositor_frame_sink_support().get() == this);
   current_surface_->RequestCopyOfOutput(std::move(copy_request));
-  surface_manager_->SurfaceModified(current_surface_->surface_id());
+  BeginFrameAck ack;
+  ack.has_damage = true;
+  surface_manager_->SurfaceModified(current_surface_->surface_id(), ack);
 }
 
 }  // namespace cc