cc: Add BeginFrameArgs

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 <set>
 #include <string>
 #include <vector>
 
@@ skipping 86 matching lines @@
   if (throttle_frame_production){
     frame_rate_controller_.reset(
         new FrameRateController(
             DelayBasedTimeSource::Create(interval, thread)));
   } else {
     frame_rate_controller_.reset(new FrameRateController(thread));
   }
 
   frame_rate_controller_->SetClient(this);
   frame_rate_controller_->SetMaxSwapsPending(max_frames_pending_);
+  frame_rate_controller_->SetDeadlineAdjustment(
+      capabilities_.has_parent_compositor ?

[piman, 2013/06/14 22:53:46]

What does has_parent_compositor really mean? Is the adjustment here taking into
account more than 2 levels of compositing (e.g. <webview> tag)?
Is the adjustment something that should be plumbed from the parent compositor?

[brianderson, 2013/06/14 23:32:12]

On platforms that support BeginFrame natively, this code path will not be used
and the adjustment will be included in the BeginFrame itself.

This code path is used for all other platforms to emulate BeginFrame until we
get the BeginFrame message from the parent compositor.

This adjustment does not take into account more than 2 levels of compositing.
This code path will not be used by WebView. Are there other cases where would
need more than 2 levels?

+          BeginFrameArgs::DefaultDeadlineAdjustment() : base::TimeDelta());
 
   // The new frame rate controller will consume the swap acks of the old
   // frame rate controller, so we set that expectation up here.
   for (int i = 0; i < pending_swap_buffers_; i++)
     frame_rate_controller_->DidSwapBuffers();
 }
 
 void OutputSurface::SetMaxFramesPending(int max_frames_pending) {
   if (frame_rate_controller_)
     frame_rate_controller_->SetMaxSwapsPending(max_frames_pending);
   max_frames_pending_ = max_frames_pending;
 }
 
 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::FrameRateControllerTick(bool throttled) {
+void OutputSurface::FrameRateControllerTick(bool throttled,
+                                            BeginFrameArgs args) {
   DCHECK(frame_rate_controller_);
   if (!throttled)
-    BeginFrame(frame_rate_controller_->LastTickTime());
+    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);
   begin_frame_pending_ = false;
   if (frame_rate_controller_)
     frame_rate_controller_->SetActive(enable);
 }
 
-void OutputSurface::BeginFrame(base::TimeTicks frame_time) {
+void OutputSurface::BeginFrame(BeginFrameArgs args) {
   if (begin_frame_pending_ ||
       (pending_swap_buffers_ >= max_frames_pending_ && max_frames_pending_ > 0))
     return;
   TRACE_EVENT1("cc", "OutputSurface::BeginFrame",
                "pending_swap_buffers_", pending_swap_buffers_);
   begin_frame_pending_ = true;
-  client_->BeginFrame(frame_time);
+  client_->BeginFrame(args);
 }
 
 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();
 }
@@ skipping 155 matching lines @@
 
 void OutputSurface::PostSwapBuffersComplete() {
   base::MessageLoop::current()->PostTask(
        FROM_HERE,
        base::Bind(&OutputSurface::OnSwapBuffersComplete,
                   weak_ptr_factory_.GetWeakPtr(),
                   static_cast<CompositorFrameAck*>(NULL)));
 }
 
 }  // namespace cc