cc: Unify BeginRetroFrames and non-RetroFrame paths in scheduler. [WIP]

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"
@@ skipping 72 matching lines @@
       primary_frame_source_(NULL),
       background_frame_source_(NULL),
       primary_frame_source_internal_(external_begin_frame_source.Pass()),
       background_frame_source_internal_(),
       vsync_observer_(NULL),
       settings_(scheduler_settings),
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
       task_runner_(task_runner),
       power_monitor_(power_monitor),
-      begin_retro_frame_posted_(false),
+      begin_frame_process_posted_(false),
       state_machine_(scheduler_settings),
       inside_process_scheduled_actions_(false),
       inside_action_(SchedulerStateMachine::ACTION_NONE),
       weak_factory_(this) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                "Scheduler::Scheduler",
                "settings",
                settings_.AsValue());
   DCHECK(client_);
   DCHECK(!state_machine_.BeginFrameNeeded());
 
-  begin_retro_frame_closure_ =
-      base::Bind(&Scheduler::BeginRetroFrame, weak_factory_.GetWeakPtr());
+  begin_frame_process_closure_ =
+      base::Bind(&Scheduler::ProcessBeginFrames, weak_factory_.GetWeakPtr());
   begin_impl_frame_deadline_closure_ = base::Bind(
       &Scheduler::OnBeginImplFrameDeadline, weak_factory_.GetWeakPtr());
   poll_for_draw_triggers_closure_ = base::Bind(
       &Scheduler::PollForAnticipatedDrawTriggers, weak_factory_.GetWeakPtr());
   advance_commit_state_closure_ = base::Bind(
       &Scheduler::PollToAdvanceCommitState, weak_factory_.GetWeakPtr());
 
   frame_source_ = BeginFrameSourceMultiplexer::Create();
   frame_source_->AddObserver(this);
 
@@ skipping 35 matching lines @@
   }
 }
 
 void Scheduler::TeardownPowerMonitoring() {
   if (settings_.disable_hi_res_timer_tasks_on_battery) {
     DCHECK(power_monitor_);
     power_monitor_->RemoveObserver(this);
   }
 }
 
-void Scheduler::OnPowerStateChange(bool on_battery_power) {
-  DCHECK(settings_.disable_hi_res_timer_tasks_on_battery);
-  state_machine_.SetImplLatencyTakesPriorityOnBattery(on_battery_power);
-}
-
 void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
                                       base::TimeDelta interval) {
   // TODO(brianderson): We should not be receiving 0 intervals.
   if (interval == base::TimeDelta())
     interval = BeginFrameArgs::DefaultInterval();
 
   if (vsync_observer_)
     vsync_observer_->OnUpdateVSyncParameters(timebase, interval);
 }
 
@@ skipping 65 matching lines @@
   if (!inside_process_scheduled_actions_) {
     DCHECK_EQ(state_machine_.NextAction(), SchedulerStateMachine::ACTION_NONE);
   }
 }
 
 void Scheduler::DidSwapBuffersComplete() {
   state_machine_.DidSwapBuffersComplete();
   ProcessScheduledActions();
 }
 
-void Scheduler::SetImplLatencyTakesPriority(bool impl_latency_takes_priority) {
-  state_machine_.SetImplLatencyTakesPriority(impl_latency_takes_priority);
-  ProcessScheduledActions();
-}
-
 void Scheduler::NotifyReadyToCommit() {
   TRACE_EVENT0("cc", "Scheduler::NotifyReadyToCommit");
   state_machine_.NotifyReadyToCommit();
   ProcessScheduledActions();
 }
 
 void Scheduler::BeginMainFrameAborted(bool did_handle) {
   TRACE_EVENT0("cc", "Scheduler::BeginMainFrameAborted");
   state_machine_.BeginMainFrameAborted(did_handle);
   ProcessScheduledActions();
 }
 
 void Scheduler::DidManageTiles() {
   state_machine_.DidManageTiles();
 }
 
 void Scheduler::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidLoseOutputSurface");
   state_machine_.DidLoseOutputSurface();
   if (frame_source_->NeedsBeginFrames())
     frame_source_->SetNeedsBeginFrames(false);
-  begin_retro_frame_args_.clear();
+  pending_begin_frame_args_.clear();
   ProcessScheduledActions();
 }
 
 void Scheduler::DidCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
   DCHECK(!frame_source_->NeedsBeginFrames());
   DCHECK(begin_impl_frame_deadline_task_.IsCancelled());
+
   state_machine_.DidCreateAndInitializeOutputSurface();
   ProcessScheduledActions();
+
+  // We want to start the first commit ASAP, so we post the LastBeginFrameArgs
+  // onto the retro queue and process it.
+  BeginFrameArgs missed = frame_source_->LastBeginFrameArgs();
+  missed.type = BeginFrameArgs::MISSED;
+  // Adjust the deadline
+  //missed.deadline = XXXXX
+  OnBeginFrame(missed);
 }
 
 void Scheduler::NotifyBeginMainFrameStarted() {
   TRACE_EVENT0("cc", "Scheduler::NotifyBeginMainFrameStarted");
   state_machine_.NotifyBeginMainFrameStarted();
 }
 
-base::TimeTicks Scheduler::AnticipatedDrawTime() const {
-  if (!frame_source_->NeedsBeginFrames() ||
-      begin_impl_frame_args_.interval <= base::TimeDelta())
-    return base::TimeTicks();
-
-  base::TimeTicks now = Now();
-  base::TimeTicks timebase = std::max(begin_impl_frame_args_.frame_time,
-                                      begin_impl_frame_args_.deadline);
-  int64 intervals = 1 + ((now - timebase) / begin_impl_frame_args_.interval);
-  return timebase + (begin_impl_frame_args_.interval * intervals);
-}
-
-base::TimeTicks Scheduler::LastBeginImplFrameTime() {
-  return begin_impl_frame_args_.frame_time;
-}
-
 void Scheduler::SetupNextBeginFrameIfNeeded() {
   if (!task_runner_.get())
     return;
 
   bool needs_begin_frame = state_machine_.BeginFrameNeeded();
 
   bool at_end_of_deadline =
       (state_machine_.begin_impl_frame_state() ==
        SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
 
   bool should_call_set_needs_begin_frame =
       // Always request the BeginFrame immediately if it wasn't needed before.
       (needs_begin_frame && !frame_source_->NeedsBeginFrames()) ||
       // Only stop requesting BeginFrames after a deadline.
       (!needs_begin_frame && frame_source_->NeedsBeginFrames() &&
        at_end_of_deadline);
 
   if (should_call_set_needs_begin_frame) {
     frame_source_->SetNeedsBeginFrames(needs_begin_frame);
   }
 
   if (at_end_of_deadline) {
-    frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
+    frame_source_->DidFinishFrame(pending_begin_frame_args_.size());
   }
 
-  PostBeginRetroFrameIfNeeded();
   SetupPollingMechanisms(needs_begin_frame);
 }
 
 // We may need to poll when we can't rely on BeginFrame to advance certain
 // state or to avoid deadlock.
 void Scheduler::SetupPollingMechanisms(bool needs_begin_frame) {
   bool needs_advance_commit_state_timer = false;
   // Setup PollForAnticipatedDrawTriggers if we need to monitor state but
   // aren't expecting any more BeginFrames. This should only be needed by
   // the synchronous compositor when BeginFrameNeeded is false.
@@ skipping 32 matching lines @@
       advance_commit_state_task_.Reset(advance_commit_state_closure_);
       task_runner_->PostDelayedTask(FROM_HERE,
                                     advance_commit_state_task_.callback(),
                                     begin_impl_frame_args_.interval * 2);
     }
   } else {
     advance_commit_state_task_.Cancel();
   }
 }
 
+base::TimeDelta Scheduler::TimeForDrawing() {
+  return EstimatedParentDrawTime() + client_->DrawDurationEstimate();
+}
+
+base::TimeTicks Scheduler::CalculateDeadline(base::TimeTicks now, const BeginFrameArgs& args) {
+  // Synchronous renderer should doesn't use deadlines.
+  if (settings_.using_synchronous_renderer_compositor) {
+    return base::TimeTicks();
+  }
+
+  base::TimeTicks deadline = args.deadline;
+
+  // Decrease the deadline enough to give drawing enough time to happen.
+  deadline -= TimeForDrawing();
+  
+  if (false) { //is_low_end()) {
+    // On low end devices, if we start main thread rendering it can stave us
+    // of CPU. Hence, if we don't think the main will make this frame we should
+    // run the impl tasks right now.
+    base::TimeTicks main_thread_time = 
+       client_->BeginMainFrameToCommitDurationEstimate() +
+       client_->CommitToActivateDurationEstimate();
+
+    if (now + main_thread_time > deadline) {
+      deadline = now;
+    }
+  }
+  
+  return deadline;
+}
+
 // 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.
 bool Scheduler::OnBeginFrameMixInDelegate(const BeginFrameArgs& args) {
   TRACE_EVENT1("cc", "Scheduler::BeginFrame", "args", args.AsValue());
 
+  // Push the BeginFrame onto a queue for processing.
+  begin_retro_frame_args.push_back(args);
+
+  // If we aren't already processing frames, start processing now.
+  if (state_machine_.begin_impl_frame_state() == SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE) {
+    ProcessBeginFrames(nullptr);
+  // Otherwise, post a task to process the frames after the current processing
+  // is finished.
+  } else if (!begin_frame_process_posted_) {
+    begin_frame_process_posted_ = true;
+    task_runner_->PostTask(FROM_HERE, begin_frame_process_closure_, &begin_frame_process_posted_);
+  }
+
+  return true;
+}
+
+void Scheduler::ProcessBeginFrames(bool* clear_posted) {
+  DCHECK(!begin_retro_frame_args.empty());
+
+  if (clear_posted) {
+    *clear_posted = false;
+  }
+
+  // Capture now to use for all the deadline calculations
+  base::TimeTicks now = Now();
+
+  // If we have multiple frames to process, discard anything which we can't
+  // make it's deadline.
+  while (pending_begin_frame_args_.size() > 1) {
+    const BeginFrameArgs& args = pending_begin_frame_args_.front();
+
+    base::TimeTicks deadline = CalculateDeadline(now, args);
+    if (now >= deadline) {
+      TRACE_EVENT_INSTANT2(
+        "cc", "Scheduler::BeginFrame discarding", TRACE_EVENT_SCOPE_THREAD,
+        "expiration_time - now", (deadline - now).InMillisecondsF(),
+        "BeginFrameArgs", args.AsValue());
+      pending_begin_frame_args_.pop_front();
+      frame_source_->DidFinishFrame(pending_begin_frame_args_.size());
+    }
+  }
+
+  // Process the head of the queue.
+  BeginFrameArgs front_args = pending_begin_frame_args_.front();
+  pending_begin_frame_args_.pop_front();
+  front_args.deadline = CalculateDeadline(now, front_args);
+  BeginImplFrame(now, front_args);
+}
+
+
+void Scheduler::BeginImplFrame(base::TimeTicks now, const BeginFrameArgs& args) {
+  // Clear any pending impl frame deadline
+  begin_impl_frame_deadline_task_.Cancel();
+  begin_impl_frame_deadline_task_.Reset(begin_impl_frame_deadline_closure_);
+
+  // TODO(mithro): ?????
   // Deliver BeginFrames to children.
   if (settings_.forward_begin_frames_to_children &&
       state_machine_.children_need_begin_frames()) {
     BeginFrameArgs adjusted_args_for_children(args);
     // Adjust a deadline for child schedulers.
     // TODO(simonhong): Once we have commitless update, we can get rid of
     // BeginMainFrameToCommitDurationEstimate() +
     // CommitToActivateDurationEstimate().
     adjusted_args_for_children.deadline -=
         (client_->BeginMainFrameToCommitDurationEstimate() +
          client_->CommitToActivateDurationEstimate() +
-         client_->DrawDurationEstimate() + EstimatedParentDrawTime());
+         TimeForDrawing());
     client_->SendBeginFramesToChildren(adjusted_args_for_children);
   }
 
-  // We have just called SetNeedsBeginFrame(true) and the BeginFrameSource has
-  // sent us the last BeginFrame we have missed. As we might not be able to
-  // actually make rendering for this call, handle it like a "retro frame".
-  // TODO(brainderson): Add a test for this functionality ASAP!
-  if (args.type == BeginFrameArgs::MISSED) {
-    begin_retro_frame_args_.push_back(args);
-    PostBeginRetroFrameIfNeeded();
-    return true;
+  // Start the ImplFrame
+  client_->BeginImplFrame(args);
+
+  // If we are asked to schedule a deadline in the past, just run the deadline
+  // right now.
+  if (now >= args.deadline) {
+    OnBeginImplFrameDeadline();
+    return;
   }
-
-  BeginFrameArgs adjusted_args(args);
-  adjusted_args.deadline -= EstimatedParentDrawTime();
-
-  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_ ||
-        !frame_source_->NeedsBeginFrames() ||
-        (state_machine_.begin_impl_frame_state() !=
-         SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
-  }
-
-  if (should_defer_begin_frame) {
-    begin_retro_frame_args_.push_back(adjusted_args);
-    TRACE_EVENT_INSTANT0(
-        "cc", "Scheduler::BeginFrame deferred", TRACE_EVENT_SCOPE_THREAD);
-    // Queuing the frame counts as "using it", so we need to return true.
-  } else {
-    BeginImplFrame(adjusted_args);
-  }
-  return true;
-}
-
-void Scheduler::SetChildrenNeedBeginFrames(bool children_need_begin_frames) {
-  DCHECK(settings_.forward_begin_frames_to_children);
-  state_machine_.SetChildrenNeedBeginFrames(children_need_begin_frames);
-  DCHECK_EQ(state_machine_.NextAction(), SchedulerStateMachine::ACTION_NONE);
-}
-
-// 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;
-
-  // If there aren't any retroactive BeginFrames, then we've lost the
-  // OutputSurface and should abort.
-  if (begin_retro_frame_args_.empty())
-    return;
-
-  // Discard expired BeginRetroFrames
-  // Today, we should always end up with at most one un-expired BeginRetroFrame
-  // because deadlines will not be greater than the next frame time. We don't
-  // DCHECK though because some systems don't always have monotonic timestamps.
-  // TODO(brianderson): In the future, long deadlines could result in us not
-  // draining the queue if we don't catch up. If we consistently can't catch
-  // up, our fallback should be to lower our frame rate.
-  base::TimeTicks now = Now();
-
-  while (!begin_retro_frame_args_.empty()) {
-    const BeginFrameArgs& args = begin_retro_frame_args_.front();
-    base::TimeTicks expiration_time = args.frame_time + args.interval;
-    if (now <= expiration_time)
-      break;
-    TRACE_EVENT_INSTANT2(
-        "cc", "Scheduler::BeginRetroFrame discarding", TRACE_EVENT_SCOPE_THREAD,
-        "expiration_time - now", (expiration_time - now).InMillisecondsF(),
-        "BeginFrameArgs", begin_retro_frame_args_.front().AsValue());
-    begin_retro_frame_args_.pop_front();
-    frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
-  }
-
-  if (begin_retro_frame_args_.empty()) {
-    TRACE_EVENT_INSTANT0("cc",
-                         "Scheduler::BeginRetroFrames all expired",
-                         TRACE_EVENT_SCOPE_THREAD);
-  } else {
-    BeginFrameArgs front = begin_retro_frame_args_.front();
-    begin_retro_frame_args_.pop_front();
-    BeginImplFrame(front);
-  }
-}
-
-// There could be a race between the posted BeginRetroFrame and a new
-// BeginFrame arriving via the normal mechanism. Scheduler::BeginFrame
-// will check if there is a pending BeginRetroFrame to ensure we handle
-// BeginFrames in FIFO order.
-void Scheduler::PostBeginRetroFrameIfNeeded() {
-  TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
-               "Scheduler::PostBeginRetroFrameIfNeeded",
-               "state",
-               AsValue());
-  if (!frame_source_->NeedsBeginFrames())
-    return;
-
-  if (begin_retro_frame_args_.empty() || begin_retro_frame_posted_)
-    return;
-
-  // begin_retro_frame_args_ should always be empty for the
-  // synchronous compositor.
-  DCHECK(!settings_.using_synchronous_renderer_compositor);
-
-  if (state_machine_.begin_impl_frame_state() !=
-      SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE)
-    return;
-
-  begin_retro_frame_posted_ = true;
-  task_runner_->PostTask(FROM_HERE, begin_retro_frame_closure_);
-}
-
-// BeginImplFrame starts a compositor frame that will wait up until a deadline
-// for a BeginMainFrame+activation to complete before it times out and draws
-// any asynchronous animation and scroll/pinch updates.
-void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
-  bool main_thread_is_in_high_latency_mode =
-      state_machine_.MainThreadIsInHighLatencyMode();
-  TRACE_EVENT2("cc",
-               "Scheduler::BeginImplFrame",
-               "args",
-               args.AsValue(),
-               "main_thread_is_high_latency",
-               main_thread_is_in_high_latency_mode);
-  TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
-                 "MainThreadLatency",
-                 main_thread_is_in_high_latency_mode);
-  DCHECK_EQ(state_machine_.begin_impl_frame_state(),
-            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
-  DCHECK(state_machine_.HasInitializedOutputSurface());
-
-  advance_commit_state_task_.Cancel();
-
-  base::TimeDelta draw_duration_estimate = client_->DrawDurationEstimate();
-  begin_impl_frame_args_ = args;
-  begin_impl_frame_args_.deadline -= draw_duration_estimate;
-
-  if (!state_machine_.impl_latency_takes_priority() &&
-      main_thread_is_in_high_latency_mode &&
-      CanCommitAndActivateBeforeDeadline()) {
-    state_machine_.SetSkipNextBeginMainFrameToReduceLatency();
-  }
-
-  client_->WillBeginImplFrame(begin_impl_frame_args_);
-  state_machine_.OnBeginImplFrame(begin_impl_frame_args_);
-  devtools_instrumentation::DidBeginFrame(layer_tree_host_id_);
-
-  ProcessScheduledActions();
-
-  state_machine_.OnBeginImplFrameDeadlinePending();
-
-  if (settings_.using_synchronous_renderer_compositor) {
-    // The synchronous renderer compositor has to make its GL calls
-    // within this call.
-    // TODO(brianderson): Have the OutputSurface initiate the deadline tasks
-    // so the synchronous renderer compositor can take advantage of splitting
-    // up the BeginImplFrame and deadline as well.
-    OnBeginImplFrameDeadline();
-  } else {
-    ScheduleBeginImplFrameDeadline(
-        AdjustedBeginImplFrameDeadline(args, draw_duration_estimate));
-  }
-}
-
-base::TimeTicks Scheduler::AdjustedBeginImplFrameDeadline(
-    const BeginFrameArgs& args,
-    base::TimeDelta draw_duration_estimate) const {
-  // The synchronous compositor does not post a deadline task.
-  DCHECK(!settings_.using_synchronous_renderer_compositor);
-  if (state_machine_.ShouldTriggerBeginImplFrameDeadlineEarly()) {
-    // We are ready to draw a new active tree immediately.
-    // We don't use Now() here because it's somewhat expensive to call.
-    return base::TimeTicks();
-  } else if (state_machine_.needs_redraw()) {
-    // We have an animation or fast input path on the impl thread that wants
-    // to draw, so don't wait too long for a new active tree.
-    return args.deadline - draw_duration_estimate;
-  } else {
-    // The impl thread doesn't have anything it wants to draw and we are just
-    // waiting for a new active tree, so post the deadline for the next
-    // expected BeginImplFrame start. This allows us to draw immediately when
-    // there is a new active tree, instead of waiting for the next
-    // BeginImplFrame.
-    // TODO(brianderson): Handle long deadlines (that are past the next frame's
-    // frame time) properly instead of using this hack.
-    return args.frame_time + args.interval;
-  }
-}
-
-void Scheduler::ScheduleBeginImplFrameDeadline(base::TimeTicks deadline) {
-  TRACE_EVENT1(
-      "cc", "Scheduler::ScheduleBeginImplFrameDeadline", "deadline", deadline);
-
-  begin_impl_frame_deadline_task_.Cancel();
-  begin_impl_frame_deadline_task_.Reset(begin_impl_frame_deadline_closure_);
-
-  base::TimeDelta delta = deadline - Now();
-  if (delta <= base::TimeDelta())
-    delta = base::TimeDelta();
+ 
+  // Else post a task for the deadline
   task_runner_->PostDelayedTask(
-      FROM_HERE, begin_impl_frame_deadline_task_.callback(), delta);
+      FROM_HERE, begin_impl_frame_deadline_task_.callback(), now - deadline);
 }
 
 void Scheduler::OnBeginImplFrameDeadline() {
   TRACE_EVENT0("cc", "Scheduler::OnBeginImplFrameDeadline");
   begin_impl_frame_deadline_task_.Cancel();
 
+  last_begin_impl_frame_args_ = current_begin_impl_frame_args_;
+
   // We split the deadline actions up into two phases so the state machine
-  // has a chance to trigger actions that should occur durring and after
-  // the deadline separately. For example:
+  // has a chance to trigger actions that should occur during and after the
+  // deadline separately. For example:
   // * Sending the BeginMainFrame will not occur after the deadline in
   //     order to wait for more user-input before starting the next commit.
   // * Creating a new OuputSurface will not occur during the deadline in
   //     order to allow the state machine to "settle" first.
   state_machine_.OnBeginImplFrameDeadline();
   ProcessScheduledActions();
   state_machine_.OnBeginImplFrameIdle();
   ProcessScheduledActions();
 
   client_->DidBeginImplFrameDeadline();
 }
 
+void Scheduler::DidActivateSyncTree() {
+  // Main frame is committed and activated
+  last_main_frame_args_ = current_main_frame_args_;
+  current_main_frame_args_ = BeginFrameArgs();
+}
+
+BeginFrameArgs Scheduler::GetBeginMainFrameArgs() {
+  // Did the previous main frame meet the deadline?
+  bool last_main_frame_meet_deadline = (last_main_frame_args_.frame_time == last_impl_frame_args_.frame_time);
+
+  BeginFrameArgs args(current_impl_frame_args_);
+  // We aren't inside an active impl frame deadline, so we use the values of
+  // the last impl frame. 
+  // TODO(mithro): This includes deadline adjustment for draw time which could
+  // instead be given to the main frame.
+  if (!args.is_valid()) {
+    args = last_impl_frame_args_;
+  }
+
+  // Do we think the main frame can make the deadline?
+  base::TimeDelta main_thread_time = 
+     client_->BeginMainFrameToCommitDurationEstimate() +
+     client_->CommitToActivateDurationEstimate();
+  if (now + main_thread_time <= args.deadline) {
+    // If we think the BeginMainFrame will make the deadline, we should
+    // definitely go ahead.
+    return args;
+  }
+
+  base::TimeDelta will_missed_deadline_by = now + main_thread_time - args.deadline;
+
+/*
+  // If we think the BeginMainFrame will only miss by a little and we made the
+  // last deadline, we are going to give it a go and see if we actually miss.
+  // This exists because our estimates are rough and there is jitter in the
+  // system.
+  bool close_deadline_miss = (will_missed_deadline_by / base::TimeDelta::FromMilliseconds(1)) == 0;
+  if (last_main_frame_meet_deadline && close_deadline_miss) {
+    return args;
+  }
+*/
+
+  // Otherwise, we don't think the BeginMainFrame will make the deadline and
+  // have already missed the last frame.  What we do depends on if we think
+  // sending a BeginMainFrame now will effect the next frame's ability to meet
+  // the deadline.
+
+  // Work out what percentage of an normal interval the main thread rendering
+  // will take.
+  base::TimeDelta time_for_rendering = args.interval - (EstimatedParentDrawTime() + client_->DrawDurationEstimate());
+  double main_percentage_of_rendering_time = main_thread_time.InMillisecondsF() / time_for_rendering.InMillisecondsF();
+
+  if (main_percentage_of_rendering_time < 0.5) {
+    // As the main thread can render twice a frame, starting rendering is
+    // unlikely to cause us to miss the next frame. Let's try and catch the
+    // main thread up to the impl thread to help with latency.
+    // We keep the expired deadline so main thread knows it not to run any
+    // unimportant tasks. It will have time after we catch back up.
+    return args;
+  }
+
+  if (main_percentage_of_rendering_time > 1.0) {
+    // Values greater than 1.0 mean the main thread will never make a normal
+    // deadline.
+
+    // If we could meet 50% of the interval, then we assume that we will do
+    // that and start rendering ASAP.
+    if (main_percentage_of_rendering_time < 2.0) {
+      // Adjust the deadline to the next deadline we think the main thread will
+      // probably make.
+      while (args.deadline + time_for_rendering >= now) {
+        args.deadline += args.interval;
+      }
+      return args;
+    }
+
+    // If the main thread isn't even going to make 50% frame rate, just target
+    // throughput and render as fast as we can. We clear the deadline to inform
+    // the main thread that we are targeting throughput and want to minimize
+    // context switches.
+    args.deadline = base::TimeTicks();
+    return args; 
+  }
+
+  // If main_percentage_of_rendering_time is between 0.5 and 1.0, then if we
+  // start rendering too late it will break the next frame too. However, we
+  // have to be careful we don't drop *every* main frame on the floor.
+
+  // If we are missing the deadline by the "slack" in the next frame, then we
+  // should go ahead.
+  base::TimeDelta slack_in_next_frame = time_for_rendering - main_thread_time;
+  if (will_miss_deadline_by < slack_in_next_frame) {
+    // We don't adjust the deadline because we want this main frame to return
+    // as early as possible to give the next main frame as much chance as
+    // possible.
+    return args;
+  }
+
+  if (last_main_frame_meet_deadline == DROPPED) {
+    // Drop this main frame to allow the next main frame to start as soon as
+    // the BeginFrame message occurs.
+    return args;
+  } else {
+    return BeginFrameArgs();
+  }
+}
+
+void Scheduler::SetChildrenNeedBeginFrames(bool children_need_begin_frames) {
+  DCHECK(settings_.forward_begin_frames_to_children);
+  state_machine_.SetChildrenNeedBeginFrames(children_need_begin_frames);
+  DCHECK_EQ(state_machine_.NextAction(), SchedulerStateMachine::ACTION_NONE);
+}
+
+
 void Scheduler::PollForAnticipatedDrawTriggers() {
   TRACE_EVENT0("cc", "Scheduler::PollForAnticipatedDrawTriggers");
   poll_for_draw_triggers_task_.Cancel();
   state_machine_.DidEnterPollForAnticipatedDrawTriggers();
   ProcessScheduledActions();
   state_machine_.DidLeavePollForAnticipatedDrawTriggers();
 }
 
 void Scheduler::PollToAdvanceCommitState() {
   TRACE_EVENT0("cc", "Scheduler::PollToAdvanceCommitState");
@@ skipping 27 matching lines @@
     state_machine_.UpdateState(action);
     base::AutoReset<SchedulerStateMachine::Action>
         mark_inside_action(&inside_action_, action);
     switch (action) {
       case SchedulerStateMachine::ACTION_NONE:
         break;
       case SchedulerStateMachine::ACTION_ANIMATE:
         client_->ScheduledActionAnimate();
         break;
       case SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME:
+
+        // FIXME:!!!!!!!
+        BeginFrameArgs args = GetBeginMainFrameArgs();
+        if (!args.IsValid())
+          continue;
+        current_main_frame_args_ = args;
+        // FIXME:!!!!!!!
+
         client_->ScheduledActionSendBeginMainFrame();
         break;
       case SchedulerStateMachine::ACTION_COMMIT:
         client_->ScheduledActionCommit();
         break;
       case SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE:
         client_->ScheduledActionActivateSyncTree();
         break;
       case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE:
         DrawAndSwapIfPossible();
         break;
       case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED:
         client_->ScheduledActionDrawAndSwapForced();
         break;
       case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT:
         // No action is actually performed, but this allows the state machine to
         // advance out of its waiting to draw state without actually drawing.
         break;
       case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
         client_->ScheduledActionBeginOutputSurfaceCreation();
         break;
       case SchedulerStateMachine::ACTION_MANAGE_TILES:
         client_->ScheduledActionManageTiles();
         break;
     }
   } while (action != SchedulerStateMachine::ACTION_NONE);
 
   SetupNextBeginFrameIfNeeded();
-  client_->DidAnticipatedDrawTimeChange(AnticipatedDrawTime());
-
   if (state_machine_.ShouldTriggerBeginImplFrameDeadlineEarly()) {
     DCHECK(!settings_.using_synchronous_renderer_compositor);
-    ScheduleBeginImplFrameDeadline(base::TimeTicks());
+    OnBeginImplFrameDeadline();
   }
 }
 
 bool Scheduler::WillDrawIfNeeded() const {
   return !state_machine_.PendingDrawsShouldBeAborted();
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat> Scheduler::AsValue()
     const {
   scoped_refptr<base::debug::TracedValue> state =
@@ skipping 18 matching lines @@
     state->EndDictionary();
   }
 
   state->BeginDictionary("scheduler_state");
   state->SetDouble("time_until_anticipated_draw_time_ms",
                    (AnticipatedDrawTime() - Now()).InMillisecondsF());
   state->SetDouble("estimated_parent_draw_time_ms",
                    estimated_parent_draw_time_.InMillisecondsF());
   state->SetBoolean("last_set_needs_begin_frame_",
                     frame_source_->NeedsBeginFrames());
-  state->SetBoolean("begin_retro_frame_posted_", begin_retro_frame_posted_);
-  state->SetInteger("begin_retro_frame_args_", begin_retro_frame_args_.size());
+  state->SetBoolean("begin_frame_process_posted_", begin_frame_process_posted_);
+  state->SetInteger("pending_begin_frame_args_", pending_begin_frame_args_.size());
   state->SetBoolean("begin_impl_frame_deadline_task_",
                     !begin_impl_frame_deadline_task_.IsCancelled());
   state->SetBoolean("poll_for_draw_triggers_task_",
                     !poll_for_draw_triggers_task_.IsCancelled());
   state->SetBoolean("advance_commit_state_task_",
                     !advance_commit_state_task_.IsCancelled());
   state->BeginDictionary("begin_impl_frame_args");
   begin_impl_frame_args_.AsValueInto(state);
   state->EndDictionary();
 
   state->EndDictionary();
 
   state->BeginDictionary("client_state");
   state->SetDouble("draw_duration_estimate_ms",
                    client_->DrawDurationEstimate().InMillisecondsF());
   state->SetDouble(
       "begin_main_frame_to_commit_duration_estimate_ms",
       client_->BeginMainFrameToCommitDurationEstimate().InMillisecondsF());
   state->SetDouble(
       "commit_to_activate_duration_estimate_ms",
       client_->CommitToActivateDurationEstimate().InMillisecondsF());
   state->EndDictionary();
 }
 
-bool Scheduler::CanCommitAndActivateBeforeDeadline() const {
-  // Check if the main thread computation and commit can be finished before the
-  // impl thread's deadline.
-  base::TimeTicks estimated_draw_time =
-      begin_impl_frame_args_.frame_time +
-      client_->BeginMainFrameToCommitDurationEstimate() +
-      client_->CommitToActivateDurationEstimate();
-
-  TRACE_EVENT2(
-      TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
-      "CanCommitAndActivateBeforeDeadline",
-      "time_left_after_drawing_ms",
-      (begin_impl_frame_args_.deadline - estimated_draw_time).InMillisecondsF(),
-      "state",
-      AsValue());
-
-  return estimated_draw_time < begin_impl_frame_args_.deadline;
-}
-
 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