cc: Implement deadine scheduling disabled by default

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 58 matching lines @@
 BeginFrameArgs FrameRateController::SetActive(bool active) {
   if (active_ == active)
     return BeginFrameArgs();
   TRACE_EVENT1("cc", "FrameRateController::SetActive", "active", active);
   active_ = active;
 
   if (is_time_source_throttling_) {
     base::TimeTicks missed_tick_time = time_source_->SetActive(active);
     if (!missed_tick_time.is_null()) {
       base::TimeTicks deadline = NextTickTime();
-      return BeginFrameArgs::Create(missed_tick_time,
-                                    deadline,
-                                    interval_);
+      BeginFrameArgs args =
+          BeginFrameArgs::Create(missed_tick_time, deadline, interval_);
+      args.deadline += deadline_adjustment_;

[danakj, 2013/09/17 20:26:19]

Is this covered by a unit test?

[brianderson, 2013/09/17 21:08:24]

There are few ways to handle the first frame's deadline with different trade
offs (faster 1st frame vs lower latency). I'm not sure I want to add a test that
forces a particular implementation.

+      return args;
     }
   } else {
     if (active)
       PostManualTick();
     else
       weak_factory_.InvalidateWeakPtrs();
   }
 
   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) {
   interval_ = interval;
   if (is_time_source_throttling_)
     time_source_->SetTimebaseAndInterval(timebase, interval);
 }
 
 void FrameRateController::SetDeadlineAdjustment(base::TimeDelta delta) {

[danakj, 2013/09/17 20:26:19]

I find no callers of this function, is it just dead code? Trying to understand
what the deadline adjustment is.

[brianderson, 2013/09/17 21:08:24]

It's called in OutputSurface::InitializeBeginFrameEmulation. For the Browser
compositor, the deadline adjustment is 0. FOr the Renderer compositor, the
deadline is currently just BeginFrameArgs::DefaultDeadlineAdjustment()

   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.deadline += deadline_adjustment_;

[danakj, 2013/09/17 20:26:19]

why adjust the deadline after instead of just passing in the adjusted deadline?
is this a functional change? if not, the old way reads easier IMO. (same thing
up above)

[brianderson, 2013/09/17 21:08:24]

I used to have an AdjustDeadline method that would make it very obvious where
the deadlines were being modified, but decided it didn't add much value and
removed it. It doesn't make much sense to structure the code the way it is now
without that method, so I will revert to the old way.

+    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