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, task_runner)));
   } else {
     frame_rate_controller_.reset(new FrameRateController(task_runner));
   }
 
   frame_rate_controller_->SetClient(this);
   frame_rate_controller_->SetMaxSwapsPending(max_frames_pending_);
+  frame_rate_controller_->SetDeadlineAdjustment(
+      capabilities_.has_parent_compositor ?
+          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,
+                                            const 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(const BeginFrameArgs& args) {
   TRACE_EVENT2("cc", "OutputSurface::BeginFrame",
                "begin_frame_pending_", begin_frame_pending_,
                "pending_swap_buffers_", pending_swap_buffers_);
   if (begin_frame_pending_ ||
       (pending_swap_buffers_ >= max_frames_pending_ && max_frames_pending_ > 0))
     return;
   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