Moving deadline adjustment from SyntheticBeginFrameSource into BeginFrameArgs.

cc/scheduler/scheduler.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/scheduler.h"
 
 #include <algorithm>
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 46 matching lines @@
 
 void Scheduler::SyntheticBeginFrameSource::OnTimerTick() {
   BeginFrameArgs begin_frame_args(
       CreateSyntheticBeginFrameArgs(time_source_->LastTickTime()));
   scheduler_->BeginFrame(begin_frame_args);
 }
 
 BeginFrameArgs
 Scheduler::SyntheticBeginFrameSource::CreateSyntheticBeginFrameArgs(
     base::TimeTicks frame_time) {
-  base::TimeTicks deadline =
-      time_source_->NextTickTime() - scheduler_->EstimatedParentDrawTime();
+  base::TimeTicks deadline = time_source_->NextTickTime();
   return BeginFrameArgs::Create(
       frame_time, deadline, scheduler_->VSyncInterval());
 }
 
 Scheduler::Scheduler(
     SchedulerClient* client,
     const SchedulerSettings& scheduler_settings,
     int layer_tree_host_id,
     const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner)
     : settings_(scheduler_settings),
@@ skipping 312 matching lines @@
 }
 
 // BeginFrame is the mechanism that tells us that now is a good time to start
 // making a frame. Usually this means that user input for the frame is complete.
 // If the scheduler is busy, we queue the BeginFrame to be handled later as
 // a BeginRetroFrame.
 void Scheduler::BeginFrame(const BeginFrameArgs& args) {
   TRACE_EVENT1("cc", "Scheduler::BeginFrame", "args", ToTrace(args));
   DCHECK(settings_.throttle_frame_production);
 
+  BeginFrameArgs adjusted_args(args);
+  adjusted_args.deadline -= EstimatedParentDrawTime();

[brianderson, 2014/06/10 18:24:23]

I had some reservations about putting the adjustment inside of the
SyntheticBeginFrameSource as well, but I think it still makes the most sense
because, when we are using a real BeginFrame message, the sender is supposed to
adjust the deadline based on it's own expected draw time.

I agree that it's a bit confusing to apply the EstimatedParentDrawTime in some
cases but not others. I wonder if we can clarify the usage and reasoning with
better naming or if we need to explain things better with comments.

+
   bool should_defer_begin_frame;
   if (settings_.using_synchronous_renderer_compositor) {
     should_defer_begin_frame = false;
   } else {
     should_defer_begin_frame =
         !begin_retro_frame_args_.empty() || begin_retro_frame_posted_ ||
         !last_set_needs_begin_frame_ ||
         (state_machine_.begin_impl_frame_state() !=
          SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   }
 
   if (should_defer_begin_frame) {
-    begin_retro_frame_args_.push_back(args);
+    begin_retro_frame_args_.push_back(adjusted_args);
     TRACE_EVENT_INSTANT0(
         "cc", "Scheduler::BeginFrame deferred", TRACE_EVENT_SCOPE_THREAD);
     return;
   }
 
-  BeginImplFrame(args);
+  BeginImplFrame(adjusted_args);
 }
 
 // BeginRetroFrame is called for BeginFrames that we've deferred because
 // the scheduler was in the middle of processing a previous BeginFrame.
 void Scheduler::BeginRetroFrame() {
   TRACE_EVENT0("cc", "Scheduler::BeginRetroFrame");
   DCHECK(!settings_.using_synchronous_renderer_compositor);
   DCHECK(begin_retro_frame_posted_);
   begin_retro_frame_posted_ = false;
 
@@ skipping 307 matching lines @@
 }
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT ||
           state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED);
 }
 
 }  // namespace cc