cc: Add queue of BeginFrames to support long deadlines.

cc/output/output_surface.cc

 // Copyright (c) 2013 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/output/output_surface.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 83 matching lines @@
     : context3d_(context3d.Pass()),
       has_gl_discard_backbuffer_(false),
       has_swap_buffers_complete_callback_(false),
       device_scale_factor_(-1),
       weak_ptr_factory_(this),
       max_frames_pending_(0),
       pending_swap_buffers_(0),
       needs_begin_frame_(false),
       begin_frame_pending_(false),
       client_(NULL),
+      consecutive_missed_deadlines_(0),
       check_for_retroactive_begin_frame_pending_(false) {
 }
 
 OutputSurface::OutputSurface(
     scoped_ptr<cc::SoftwareOutputDevice> software_device)
     : software_device_(software_device.Pass()),
       has_gl_discard_backbuffer_(false),
       has_swap_buffers_complete_callback_(false),
       device_scale_factor_(-1),
       weak_ptr_factory_(this),
       max_frames_pending_(0),
       pending_swap_buffers_(0),
       needs_begin_frame_(false),
       begin_frame_pending_(false),
       client_(NULL),
+      consecutive_missed_deadlines_(0),
       check_for_retroactive_begin_frame_pending_(false) {
 }
 
 OutputSurface::OutputSurface(
     scoped_ptr<WebKit::WebGraphicsContext3D> context3d,
     scoped_ptr<cc::SoftwareOutputDevice> software_device)
     : context3d_(context3d.Pass()),
       software_device_(software_device.Pass()),
       has_gl_discard_backbuffer_(false),
       has_swap_buffers_complete_callback_(false),
       device_scale_factor_(-1),
       weak_ptr_factory_(this),
       max_frames_pending_(0),
       pending_swap_buffers_(0),
       needs_begin_frame_(false),
       begin_frame_pending_(false),
       client_(NULL),
+      consecutive_missed_deadlines_(0),
       check_for_retroactive_begin_frame_pending_(false) {
 }
 
 void OutputSurface::InitializeBeginFrameEmulation(
     base::SingleThreadTaskRunner* task_runner,
     bool throttle_frame_production,
     base::TimeDelta interval) {
   if (throttle_frame_production) {
     frame_rate_controller_.reset(
         new FrameRateController(
@@ skipping 22 matching lines @@
 
 void OutputSurface::OnVSyncParametersChanged(base::TimeTicks timebase,
                                              base::TimeDelta interval) {
   TRACE_EVENT2("cc", "OutputSurface::OnVSyncParametersChanged",
                "timebase", (timebase - base::TimeTicks()).InSecondsF(),
                "interval", interval.InSecondsF());
   if (frame_rate_controller_)
     frame_rate_controller_->SetTimebaseAndInterval(timebase, interval);
 }
 
+void OutputSurface::AddSkippedBeginFrame(const BeginFrameArgs& skipped) {
+  if (skipped.IsValid() &&
+      (skipped_begin_frame_args_.empty() ||
+       skipped.frame_time != skipped_begin_frame_args_.back().frame_time)) {
+    skipped_begin_frame_args_.push_back(skipped);
+  }
+}
+
 void OutputSurface::FrameRateControllerTick(bool throttled,
                                             const BeginFrameArgs& args) {
   DCHECK(frame_rate_controller_);
   if (throttled)
-    skipped_begin_frame_args_ = args;
+    AddSkippedBeginFrame(args);
   else
     BeginFrame(args);
 }
 
 // Forwarded to OutputSurfaceClient
 void OutputSurface::SetNeedsRedrawRect(gfx::Rect damage_rect) {
   TRACE_EVENT0("cc", "OutputSurface::SetNeedsRedrawRect");
   client_->SetNeedsRedrawRect(damage_rect);
 }
 
 void OutputSurface::SetNeedsBeginFrame(bool enable) {
   TRACE_EVENT1("cc", "OutputSurface::SetNeedsBeginFrame", "enable", enable);
   needs_begin_frame_ = enable;
   begin_frame_pending_ = false;
   if (frame_rate_controller_) {
     BeginFrameArgs skipped = frame_rate_controller_->SetActive(enable);
-    if (skipped.IsValid())
-      skipped_begin_frame_args_ = skipped;
+    AddSkippedBeginFrame(skipped);
   }
   if (needs_begin_frame_)
     PostCheckForRetroactiveBeginFrame();
 }
 
 void OutputSurface::BeginFrame(const BeginFrameArgs& args) {
   TRACE_EVENT2("cc", "OutputSurface::BeginFrame",
                "begin_frame_pending_", begin_frame_pending_,
                "pending_swap_buffers_", pending_swap_buffers_);
   if (!needs_begin_frame_ || begin_frame_pending_ ||
       (pending_swap_buffers_ >= max_frames_pending_ &&
        max_frames_pending_ > 0)) {
-    skipped_begin_frame_args_ = args;
+    AddSkippedBeginFrame(args);
   } else {
     begin_frame_pending_ = true;
+    consecutive_missed_deadlines_ = 0;
     client_->BeginFrame(args);
-    // args might be an alias for skipped_begin_frame_args_.
-    // Do not reset it before calling BeginFrame!
-    skipped_begin_frame_args_ = BeginFrameArgs();
   }
 }
 
 base::TimeTicks OutputSurface::RetroactiveBeginFrameDeadline() {
+  if (consecutive_missed_deadlines_) {

[Sami, 2013/08/13 16:44:08]

I think the interaction between CheckForRetroactiveBeginFrame and
RetroactiveBeginFrameDeadline is getting confusing. Could we simplify this so
that we adjust the deadlines going into skipped_begin_frame_args_ make sense
w.r.t. DefaultRetroactiveBeginFramePeriod()? That way we could always just pick
the oldest skipped BeginFrame whose deadline hasn't passed.

+    return skipped_begin_frame_args_.front().frame_time +
+           skipped_begin_frame_args_.front().interval;
+  }
+
   // TODO(brianderson): Remove the alternative deadline once we have better
   // deadline estimations.
   base::TimeTicks alternative_deadline =
-      skipped_begin_frame_args_.frame_time +
+      skipped_begin_frame_args_.front().frame_time +
       BeginFrameArgs::DefaultRetroactiveBeginFramePeriod();
-  return std::max(skipped_begin_frame_args_.deadline, alternative_deadline);
+  return std::max(skipped_begin_frame_args_.front().deadline,
+                  alternative_deadline);
 }
 
 void OutputSurface::PostCheckForRetroactiveBeginFrame() {
-  if (!skipped_begin_frame_args_.IsValid() ||
+  if (skipped_begin_frame_args_.empty() ||
       check_for_retroactive_begin_frame_pending_)
     return;
 
   base::MessageLoop::current()->PostTask(
      FROM_HERE,
      base::Bind(&OutputSurface::CheckForRetroactiveBeginFrame,
                 weak_ptr_factory_.GetWeakPtr()));
   check_for_retroactive_begin_frame_pending_ = true;
 }
 
 void OutputSurface::CheckForRetroactiveBeginFrame() {
+  check_for_retroactive_begin_frame_pending_ = false;
+  if (skipped_begin_frame_args_.empty())
+    return;
+
   TRACE_EVENT0("cc", "OutputSurface::CheckForRetroactiveBeginFrame");
-  check_for_retroactive_begin_frame_pending_ = false;
-  if (base::TimeTicks::Now() < RetroactiveBeginFrameDeadline())
-    BeginFrame(skipped_begin_frame_args_);
+  base::TimeTicks now = base::TimeTicks::Now();
+  while (skipped_begin_frame_args_.size() > 1 &&
+         now > skipped_begin_frame_args_.front().deadline) {
+      skipped_begin_frame_args_.pop_front();
+      consecutive_missed_deadlines_++;
+  }
+
+  if (now < RetroactiveBeginFrameDeadline())
+    BeginFrame(skipped_begin_frame_args_.front());
+  else
+    consecutive_missed_deadlines_++;
+
+  skipped_begin_frame_args_.pop_front();
 }
 
 void OutputSurface::DidSwapBuffers() {
   begin_frame_pending_ = false;
   pending_swap_buffers_++;
   TRACE_EVENT1("cc", "OutputSurface::DidSwapBuffers",
                "pending_swap_buffers_", pending_swap_buffers_);
   if (frame_rate_controller_)
     frame_rate_controller_->DidSwapBuffers();
   PostCheckForRetroactiveBeginFrame();
@@ skipping 193 matching lines @@
                "discard_backbuffer", discard_backbuffer);
   // Just ignore the memory manager when it says to set the limit to zero
   // bytes. This will happen when the memory manager thinks that the renderer
   // is not visible (which the renderer knows better).
   if (policy.bytes_limit_when_visible)
     client_->SetMemoryPolicy(policy);
   client_->SetDiscardBackBufferWhenNotVisible(discard_backbuffer);
 }
 
 }  // namespace cc