[cc] Add and use BeginFrameAck for DidFinishFrame.

cc/surfaces/display_scheduler.cc

 // Copyright 2015 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/display_scheduler.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/stl_util.h"
@@ skipping 55 matching lines @@
   TRACE_EVENT1("cc", "DisplayScheduler::SetRootSurfaceResourcesLocked",
                "locked", locked);
   root_surface_resources_locked_ = locked;
   ScheduleBeginFrameDeadline();
 }
 
 // This is used to force an immediate swap before a resize.
 void DisplayScheduler::ForceImmediateSwapIfPossible() {
   TRACE_EVENT0("cc", "DisplayScheduler::ForceImmediateSwapIfPossible");
   bool in_begin = inside_begin_frame_deadline_interval_;
-  AttemptDrawAndSwap();
+  bool did_draw = AttemptDrawAndSwap();
   if (in_begin)
-    begin_frame_source_->DidFinishFrame(this, 0);
+    DidFinishFrame(did_draw);
 }
 
 void DisplayScheduler::DisplayResized() {
   expecting_root_surface_damage_because_of_resize_ = true;
   expect_damage_from_root_surface_ = true;
   needs_draw_ = true;
   ScheduleBeginFrameDeadline();
 }
 
 // Notification that there was a resize or the root surface changed and
@@ skipping 32 matching lines @@
   StartObservingBeginFrames();
   ScheduleBeginFrameDeadline();
 }
 
 void DisplayScheduler::OutputSurfaceLost() {
   TRACE_EVENT0("cc", "DisplayScheduler::OutputSurfaceLost");
   output_surface_lost_ = true;
   ScheduleBeginFrameDeadline();
 }
 
-void DisplayScheduler::DrawAndSwap() {
+bool DisplayScheduler::DrawAndSwap() {
   TRACE_EVENT0("cc", "DisplayScheduler::DrawAndSwap");
   DCHECK_LT(pending_swaps_, max_pending_swaps_);
   DCHECK(!output_surface_lost_);
 
   bool success = client_->DrawAndSwap();
   if (!success)
-    return;
+    return false;
 
   child_surface_ids_to_expect_damage_from_ =
       base::STLSetIntersection<std::vector<SurfaceId>>(
           child_surface_ids_damaged_, child_surface_ids_damaged_prev_);
 
   child_surface_ids_damaged_prev_.swap(child_surface_ids_damaged_);
   child_surface_ids_damaged_.clear();
 
   needs_draw_ = false;
   all_active_child_surfaces_ready_to_draw_ =
       child_surface_ids_to_expect_damage_from_.empty();
 
   expect_damage_from_root_surface_ = root_surface_damaged_;
   root_surface_damaged_ = false;
+  return true;
 }
 
 bool DisplayScheduler::OnBeginFrameDerivedImpl(const BeginFrameArgs& args) {
   base::TimeTicks now = base::TimeTicks::Now();
   TRACE_EVENT2("cc", "DisplayScheduler::BeginFrame", "args", args.AsValue(),
                "now", now);
 
   if (inside_surface_damaged_) {
     // Repost this so that we don't run a missed BeginFrame on the same
     // callstack. Otherwise we end up running unexpected scheduler actions
@@ skipping 162 matching lines @@
   begin_frame_deadline_task_.Reset(begin_frame_deadline_closure_);
 
   base::TimeDelta delta =
       std::max(base::TimeDelta(), desired_deadline - base::TimeTicks::Now());
   task_runner_->PostDelayedTask(FROM_HERE,
                                 begin_frame_deadline_task_.callback(), delta);
   TRACE_EVENT2("cc", "Using new deadline", "delta", delta.ToInternalValue(),
                "desired_deadline", desired_deadline);
 }
 
-void DisplayScheduler::AttemptDrawAndSwap() {
+bool DisplayScheduler::AttemptDrawAndSwap() {
   inside_begin_frame_deadline_interval_ = false;
   begin_frame_deadline_task_.Cancel();
   begin_frame_deadline_task_time_ = base::TimeTicks();
 
   if (ShouldDraw()) {
     if (pending_swaps_ < max_pending_swaps_ && !root_surface_resources_locked_)
-      DrawAndSwap();
+      return DrawAndSwap();
   } else {
     // We are going idle, so reset expectations.
     child_surface_ids_to_expect_damage_from_.clear();
     child_surface_ids_damaged_prev_.clear();
     child_surface_ids_damaged_.clear();
     all_active_child_surfaces_ready_to_draw_ = true;
     expect_damage_from_root_surface_ = false;
 
     StopObservingBeginFrames();
   }
+  return false;
 }
 
 void DisplayScheduler::OnBeginFrameDeadline() {
   TRACE_EVENT0("cc", "DisplayScheduler::OnBeginFrameDeadline");
+  DCHECK(inside_begin_frame_deadline_interval_);
 
-  AttemptDrawAndSwap();
-  begin_frame_source_->DidFinishFrame(this, 0);
+  bool did_draw = AttemptDrawAndSwap();
+  DidFinishFrame(did_draw);
+}
+
+void DisplayScheduler::DidFinishFrame(bool did_draw) {
+  // TODO(eseckler): Determine and set correct |ack.latest_confirmed_frame|.
+  BeginFrameAck ack(current_begin_frame_args_.source_id,
+                    current_begin_frame_args_.sequence_number,
+                    current_begin_frame_args_.sequence_number, 0, did_draw);
+  begin_frame_source_->DidFinishFrame(this, ack);
 }
 
 void DisplayScheduler::DidSwapBuffers() {
   pending_swaps_++;
   TRACE_EVENT_ASYNC_BEGIN1("cc", "DisplayScheduler:pending_swaps", this,
                            "pending_frames", pending_swaps_);
 }
 
 void DisplayScheduler::DidReceiveSwapBuffersAck() {
   pending_swaps_--;
   TRACE_EVENT_ASYNC_END1("cc", "DisplayScheduler:pending_swaps", this,
                          "pending_frames", pending_swaps_);
   ScheduleBeginFrameDeadline();
 }
 
 }  // namespace cc