cc: Use BeginFrameArgs

cc/scheduler/frame_rate_controller.cc

 // Copyright 2011 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/scheduler/frame_rate_controller.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 68 matching lines @@
     if (active)
       PostManualTick();
     else
       weak_factory_.InvalidateWeakPtrs();
   }
 
   if (just_activated) {
     // TODO(brianderson): Use an adaptive parent compositor deadline.
     base::TimeTicks frame_time = NextTickTime() - interval_;
     base::TimeTicks deadline = NextTickTime();
-    return BeginFrameArgs::Create(frame_time, deadline, interval_);
+    BeginFrameArgs args =
+        BeginFrameArgs::Create(frame_time, deadline, interval_);
+    args.AdjustDeadline(deadline_adjustment_);
+    return args;
   }
   return BeginFrameArgs();
 }
 
 void FrameRateController::SetMaxSwapsPending(int max_swaps_pending) {
   DCHECK_GE(max_swaps_pending, 0);
   max_swaps_pending_ = max_swaps_pending;
 }
 
 void FrameRateController::SetTimebaseAndInterval(base::TimeTicks timebase,
                                                  base::TimeDelta interval) {
+  timebase = base::TimeTicks();

[brianderson, 2013/07/18 02:02:49]

This is a hack to keep the phase from changing every few frames. I will remove
it before committing. See
https://code.google.com/p/chromium/issues/detail?id=252087

   interval_ = interval;
   if (is_time_source_throttling_)
     time_source_->SetTimebaseAndInterval(timebase, interval);
 }
 
 void FrameRateController::SetDeadlineAdjustment(base::TimeDelta delta) {
   deadline_adjustment_ = delta;
 }
 
 void FrameRateController::OnTimerTick() {
   TRACE_EVENT0("cc", "FrameRateController::OnTimerTick");
   DCHECK(active_);
 
   // Check if we have too many frames in flight.
   bool throttled =
       max_swaps_pending_ && num_frames_pending_ >= max_swaps_pending_;
   TRACE_COUNTER_ID1("cc", "ThrottledCompositor", task_runner_, throttled);
 
   if (client_) {
     // TODO(brianderson): Use an adaptive parent compositor deadline.
     base::TimeTicks frame_time = LastTickTime();
-    base::TimeTicks deadline = NextTickTime() + deadline_adjustment_;
-    client_->FrameRateControllerTick(
-        throttled,
-        BeginFrameArgs::Create(frame_time, deadline, interval_));
+    base::TimeTicks deadline = NextTickTime();
+    BeginFrameArgs args =
+        BeginFrameArgs::Create(frame_time, deadline, interval_);
+    args.AdjustDeadline(deadline_adjustment_);
+    client_->FrameRateControllerTick(throttled, args);
   }
 
   if (!is_time_source_throttling_ && !throttled)
     PostManualTick();
 }
 
 void FrameRateController::PostManualTick() {
   if (active_) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&FrameRateController::ManualTick,
@@ skipping 28 matching lines @@
 }
 
 base::TimeTicks FrameRateController::LastTickTime() {
   if (is_time_source_throttling_)
     return time_source_->LastTickTime();
 
   return base::TimeTicks::Now();
 }
 
 }  // namespace cc