cc/scheduler/scheduler.cc

   1 // Copyright 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/scheduler/scheduler.h"
   6
   7 #include <algorithm>
   8 #include "base/auto_reset.h"
   9 #include "base/debug/trace_event.h"
  10 #include "base/debug/trace_event_argument.h"
  11 #include "base/logging.h"
  12 #include "base/single_thread_task_runner.h"
  13 #include "cc/debug/devtools_instrumentation.h"
  14 #include "cc/debug/traced_value.h"
  15 #include "cc/scheduler/delay_based_time_source.h"
  16 #include "ui/gfx/frame_time.h"
  17
  18 namespace cc {
  19
  20 Scheduler::SyntheticBeginFrameSource::SyntheticBeginFrameSource(
  21     Scheduler* scheduler,
  22     scoped_refptr<DelayBasedTimeSource> time_source)
  23     : scheduler_(scheduler), time_source_(time_source) {
  24   time_source_->SetClient(this);
  25 }
  26
  27 Scheduler::SyntheticBeginFrameSource::~SyntheticBeginFrameSource() {
  28 }
  29
  30 void Scheduler::SyntheticBeginFrameSource::CommitVSyncParameters(
  31     base::TimeTicks timebase,
  32     base::TimeDelta interval) {
  33   time_source_->SetTimebaseAndInterval(timebase, interval);
  34 }
  35
  36 void Scheduler::SyntheticBeginFrameSource::SetNeedsBeginFrame(
  37     bool needs_begin_frame,
  38     std::deque<BeginFrameArgs>* begin_retro_frame_args) {
  39   DCHECK(begin_retro_frame_args);
  40   base::TimeTicks missed_tick_time =
  41       time_source_->SetActive(needs_begin_frame);
  42   if (!missed_tick_time.is_null()) {
  43     begin_retro_frame_args->push_back(
  44         CreateSyntheticBeginFrameArgs(missed_tick_time));
  45   }
  46 }
  47
  48 bool Scheduler::SyntheticBeginFrameSource::IsActive() const {
  49   return time_source_->Active();
  50 }
  51
  52 void Scheduler::SyntheticBeginFrameSource::OnTimerTick() {
  53   BeginFrameArgs begin_frame_args(
  54       CreateSyntheticBeginFrameArgs(time_source_->LastTickTime()));
  55   scheduler_->BeginFrame(begin_frame_args);
  56 }
  57
  58 void Scheduler::SyntheticBeginFrameSource::AsValueInto(
  59     base::debug::TracedValue* state) const {
  60   time_source_->AsValueInto(state);
  61 }
  62
  63 BeginFrameArgs
  64 Scheduler::SyntheticBeginFrameSource::CreateSyntheticBeginFrameArgs(
  65     base::TimeTicks frame_time) {
  66   base::TimeTicks deadline = time_source_->NextTickTime();
  67   return BeginFrameArgs::Create(
  68       frame_time, deadline, scheduler_->VSyncInterval());
  69 }
  70
  71 Scheduler::Scheduler(
  72     SchedulerClient* client,
  73     const SchedulerSettings& scheduler_settings,
  74     int layer_tree_host_id,
  75     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
  76     : settings_(scheduler_settings),
  77       client_(client),
  78       layer_tree_host_id_(layer_tree_host_id),
  79       task_runner_(task_runner),
  80       vsync_interval_(BeginFrameArgs::DefaultInterval()),
  81       last_set_needs_begin_frame_(false),
  82       begin_unthrottled_frame_posted_(false),
  83       begin_retro_frame_posted_(false),
  84       state_machine_(scheduler_settings),
  85       inside_process_scheduled_actions_(false),
  86       inside_action_(SchedulerStateMachine::ACTION_NONE),
  87       weak_factory_(this) {
  88   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
  89                "Scheduler::Scheduler",
  90                "settings",
  91                settings_.AsValue());
  92   DCHECK(client_);
  93   DCHECK(!state_machine_.BeginFrameNeeded());
  94   if (settings_.main_frame_before_activation_enabled) {
  95     DCHECK(settings_.main_frame_before_draw_enabled);
  96   }
  97
  98   begin_retro_frame_closure_ =
  99       base::Bind(&Scheduler::BeginRetroFrame, weak_factory_.GetWeakPtr());
 100   begin_unthrottled_frame_closure_ =
 101       base::Bind(&Scheduler::BeginUnthrottledFrame, weak_factory_.GetWeakPtr());
 102   begin_impl_frame_deadline_closure_ = base::Bind(
 103       &Scheduler::OnBeginImplFrameDeadline, weak_factory_.GetWeakPtr());
 104   poll_for_draw_triggers_closure_ = base::Bind(
 105       &Scheduler::PollForAnticipatedDrawTriggers, weak_factory_.GetWeakPtr());
 106   advance_commit_state_closure_ = base::Bind(
 107       &Scheduler::PollToAdvanceCommitState, weak_factory_.GetWeakPtr());
 108
 109   if (!settings_.begin_frame_scheduling_enabled) {
 110     SetupSyntheticBeginFrames();
 111   }
 112 }
 113
 114 Scheduler::~Scheduler() {
 115   if (synthetic_begin_frame_source_) {
 116     synthetic_begin_frame_source_->SetNeedsBeginFrame(false,
 117                                                       &begin_retro_frame_args_);
 118   }
 119 }
 120
 121 void Scheduler::SetupSyntheticBeginFrames() {
 122   scoped_refptr<DelayBasedTimeSource> time_source;
 123   if (gfx::FrameTime::TimestampsAreHighRes()) {
 124     time_source = DelayBasedTimeSourceHighRes::Create(VSyncInterval(),
 125                                                       task_runner_.get());
 126   } else {
 127     time_source =
 128         DelayBasedTimeSource::Create(VSyncInterval(), task_runner_.get());
 129   }
 130   DCHECK(!synthetic_begin_frame_source_);
 131   synthetic_begin_frame_source_.reset(
 132       new SyntheticBeginFrameSource(this, time_source));
 133 }
 134
 135 base::TimeTicks Scheduler::Now() const {
 136   return gfx::FrameTime::Now();
 137 }
 138
 139 void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
 140                                       base::TimeDelta interval) {
 141   // TODO(brianderson): We should not be receiving 0 intervals.
 142   if (interval == base::TimeDelta())
 143     interval = BeginFrameArgs::DefaultInterval();
 144   vsync_interval_ = interval;
 145   if (!settings_.begin_frame_scheduling_enabled)
 146     synthetic_begin_frame_source_->CommitVSyncParameters(timebase, interval);
 147 }
 148
 149 void Scheduler::SetEstimatedParentDrawTime(base::TimeDelta draw_time) {
 150   DCHECK_GE(draw_time.ToInternalValue(), 0);
 151   estimated_parent_draw_time_ = draw_time;
 152 }
 153
 154 void Scheduler::SetCanStart() {
 155   state_machine_.SetCanStart();
 156   ProcessScheduledActions();
 157 }
 158
 159 void Scheduler::SetVisible(bool visible) {
 160   state_machine_.SetVisible(visible);
 161   ProcessScheduledActions();
 162 }
 163
 164 void Scheduler::SetCanDraw(bool can_draw) {
 165   state_machine_.SetCanDraw(can_draw);
 166   ProcessScheduledActions();
 167 }
 168
 169 void Scheduler::NotifyReadyToActivate() {
 170   state_machine_.NotifyReadyToActivate();
 171   ProcessScheduledActions();
 172 }
 173
 174 void Scheduler::SetNeedsCommit() {
 175   state_machine_.SetNeedsCommit();
 176   ProcessScheduledActions();
 177 }
 178
 179 void Scheduler::SetNeedsRedraw() {
 180   state_machine_.SetNeedsRedraw();
 181   ProcessScheduledActions();
 182 }
 183
 184 void Scheduler::SetNeedsAnimate() {
 185   state_machine_.SetNeedsAnimate();
 186   ProcessScheduledActions();
 187 }
 188
 189 void Scheduler::SetNeedsManageTiles() {
 190   DCHECK(!IsInsideAction(SchedulerStateMachine::ACTION_MANAGE_TILES));
 191   state_machine_.SetNeedsManageTiles();
 192   ProcessScheduledActions();
 193 }
 194
 195 void Scheduler::SetMaxSwapsPending(int max) {
 196   state_machine_.SetMaxSwapsPending(max);
 197 }
 198
 199 void Scheduler::DidSwapBuffers() {
 200   state_machine_.DidSwapBuffers();
 201
 202   // There is no need to call ProcessScheduledActions here because
 203   // swapping should not trigger any new actions.
 204   if (!inside_process_scheduled_actions_) {
 205     DCHECK_EQ(state_machine_.NextAction(), SchedulerStateMachine::ACTION_NONE);
 206   }
 207 }
 208
 209 void Scheduler::SetSwapUsedIncompleteTile(bool used_incomplete_tile) {
 210   state_machine_.SetSwapUsedIncompleteTile(used_incomplete_tile);
 211   ProcessScheduledActions();
 212 }
 213
 214 void Scheduler::DidSwapBuffersComplete() {
 215   state_machine_.DidSwapBuffersComplete();
 216   ProcessScheduledActions();
 217 }
 218
 219 void Scheduler::SetImplLatencyTakesPriority(bool impl_latency_takes_priority) {
 220   state_machine_.SetImplLatencyTakesPriority(impl_latency_takes_priority);
 221   ProcessScheduledActions();
 222 }
 223
 224 void Scheduler::NotifyReadyToCommit() {
 225   TRACE_EVENT0("cc", "Scheduler::NotifyReadyToCommit");
 226   state_machine_.NotifyReadyToCommit();
 227   ProcessScheduledActions();
 228 }
 229
 230 void Scheduler::BeginMainFrameAborted(bool did_handle) {
 231   TRACE_EVENT0("cc", "Scheduler::BeginMainFrameAborted");
 232   state_machine_.BeginMainFrameAborted(did_handle);
 233   ProcessScheduledActions();
 234 }
 235
 236 void Scheduler::DidManageTiles() {
 237   state_machine_.DidManageTiles();
 238 }
 239
 240 void Scheduler::DidLoseOutputSurface() {
 241   TRACE_EVENT0("cc", "Scheduler::DidLoseOutputSurface");
 242   state_machine_.DidLoseOutputSurface();
 243   last_set_needs_begin_frame_ = false;
 244   if (!settings_.begin_frame_scheduling_enabled) {
 245     synthetic_begin_frame_source_->SetNeedsBeginFrame(false,
 246                                                       &begin_retro_frame_args_);
 247   }
 248   begin_retro_frame_args_.clear();
 249   ProcessScheduledActions();
 250 }
 251
 252 void Scheduler::DidCreateAndInitializeOutputSurface() {
 253   TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
 254   DCHECK(!last_set_needs_begin_frame_);
 255   DCHECK(begin_impl_frame_deadline_task_.IsCancelled());
 256   state_machine_.DidCreateAndInitializeOutputSurface();
 257   ProcessScheduledActions();
 258 }
 259
 260 void Scheduler::NotifyBeginMainFrameStarted() {
 261   TRACE_EVENT0("cc", "Scheduler::NotifyBeginMainFrameStarted");
 262   state_machine_.NotifyBeginMainFrameStarted();
 263 }
 264
 265 base::TimeTicks Scheduler::AnticipatedDrawTime() const {
 266   if (!last_set_needs_begin_frame_ ||
 267       begin_impl_frame_args_.interval <= base::TimeDelta())
 268     return base::TimeTicks();
 269
 270   base::TimeTicks now = Now();
 271   base::TimeTicks timebase = std::max(begin_impl_frame_args_.frame_time,
 272                                       begin_impl_frame_args_.deadline);
 273   int64 intervals = 1 + ((now - timebase) / begin_impl_frame_args_.interval);
 274   return timebase + (begin_impl_frame_args_.interval * intervals);
 275 }
 276
 277 base::TimeTicks Scheduler::LastBeginImplFrameTime() {
 278   return begin_impl_frame_args_.frame_time;
 279 }
 280
 281 void Scheduler::SetupNextBeginFrameIfNeeded() {
 282   if (!task_runner_.get())
 283     return;
 284
 285   bool needs_begin_frame = state_machine_.BeginFrameNeeded();
 286
 287   if (settings_.throttle_frame_production) {
 288     SetupNextBeginFrameWhenVSyncThrottlingEnabled(needs_begin_frame);
 289   } else {
 290     SetupNextBeginFrameWhenVSyncThrottlingDisabled(needs_begin_frame);
 291   }
 292   SetupPollingMechanisms(needs_begin_frame);
 293 }
 294
 295 // When we are throttling frame production, we request BeginFrames
 296 // from the OutputSurface.
 297 void Scheduler::SetupNextBeginFrameWhenVSyncThrottlingEnabled(
 298     bool needs_begin_frame) {
 299   bool at_end_of_deadline =
 300       state_machine_.begin_impl_frame_state() ==
 301           SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE;
 302
 303   bool should_call_set_needs_begin_frame =
 304       // Always request the BeginFrame immediately if it wasn't needed before.
 305       (needs_begin_frame && !last_set_needs_begin_frame_) ||
 306       // Only stop requesting BeginFrames after a deadline.
 307       (!needs_begin_frame && last_set_needs_begin_frame_ && at_end_of_deadline);
 308
 309   if (should_call_set_needs_begin_frame) {
 310     if (settings_.begin_frame_scheduling_enabled) {
 311       client_->SetNeedsBeginFrame(needs_begin_frame);
 312     } else {
 313       synthetic_begin_frame_source_->SetNeedsBeginFrame(
 314           needs_begin_frame, &begin_retro_frame_args_);
 315     }
 316     last_set_needs_begin_frame_ = needs_begin_frame;
 317   }
 318
 319   PostBeginRetroFrameIfNeeded();
 320 }
 321
 322 // When we aren't throttling frame production, we initiate a BeginFrame
 323 // as soon as one is needed.
 324 void Scheduler::SetupNextBeginFrameWhenVSyncThrottlingDisabled(
 325     bool needs_begin_frame) {
 326   last_set_needs_begin_frame_ = needs_begin_frame;
 327
 328   if (!needs_begin_frame || begin_unthrottled_frame_posted_)
 329     return;
 330
 331   if (state_machine_.begin_impl_frame_state() !=
 332           SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE &&
 333       state_machine_.begin_impl_frame_state() !=
 334           SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) {
 335     return;
 336   }
 337
 338   begin_unthrottled_frame_posted_ = true;
 339   task_runner_->PostTask(FROM_HERE, begin_unthrottled_frame_closure_);
 340 }
 341
 342 // BeginUnthrottledFrame is used when we aren't throttling frame production.
 343 // This will usually be because VSync is disabled.
 344 void Scheduler::BeginUnthrottledFrame() {
 345   DCHECK(!settings_.throttle_frame_production);
 346   DCHECK(begin_retro_frame_args_.empty());
 347
 348   base::TimeTicks now = Now();
 349   base::TimeTicks deadline = now + vsync_interval_;
 350
 351   BeginFrameArgs begin_frame_args =
 352       BeginFrameArgs::Create(now, deadline, vsync_interval_);
 353   BeginImplFrame(begin_frame_args);
 354
 355   begin_unthrottled_frame_posted_ = false;
 356 }
 357
 358 // We may need to poll when we can't rely on BeginFrame to advance certain
 359 // state or to avoid deadlock.
 360 void Scheduler::SetupPollingMechanisms(bool needs_begin_frame) {
 361   bool needs_advance_commit_state_timer = false;
 362   // Setup PollForAnticipatedDrawTriggers if we need to monitor state but
 363   // aren't expecting any more BeginFrames. This should only be needed by
 364   // the synchronous compositor when BeginFrameNeeded is false.
 365   if (state_machine_.ShouldPollForAnticipatedDrawTriggers()) {
 366     DCHECK(!state_machine_.SupportsProactiveBeginFrame());
 367     DCHECK(!needs_begin_frame);
 368     if (poll_for_draw_triggers_task_.IsCancelled()) {
 369       poll_for_draw_triggers_task_.Reset(poll_for_draw_triggers_closure_);
 370       base::TimeDelta delay = begin_impl_frame_args_.IsValid()
 371                                   ? begin_impl_frame_args_.interval
 372                                   : BeginFrameArgs::DefaultInterval();
 373       task_runner_->PostDelayedTask(
 374           FROM_HERE, poll_for_draw_triggers_task_.callback(), delay);
 375     }
 376   } else {
 377     poll_for_draw_triggers_task_.Cancel();
 378
 379     // At this point we'd prefer to advance through the commit flow by
 380     // drawing a frame, however it's possible that the frame rate controller
 381     // will not give us a BeginFrame until the commit completes.  See
 382     // crbug.com/317430 for an example of a swap ack being held on commit. Thus
 383     // we set a repeating timer to poll on ProcessScheduledActions until we
 384     // successfully reach BeginFrame. Synchronous compositor does not use
 385     // frame rate controller or have the circular wait in the bug.
 386     if (IsBeginMainFrameSentOrStarted() &&
 387         !settings_.using_synchronous_renderer_compositor) {
 388       needs_advance_commit_state_timer = true;
 389     }
 390   }
 391
 392   if (needs_advance_commit_state_timer) {
 393     if (advance_commit_state_task_.IsCancelled() &&
 394         begin_impl_frame_args_.IsValid()) {
 395       // Since we'd rather get a BeginImplFrame by the normal mechanism, we
 396       // set the interval to twice the interval from the previous frame.
 397       advance_commit_state_task_.Reset(advance_commit_state_closure_);
 398       task_runner_->PostDelayedTask(FROM_HERE,
 399                                     advance_commit_state_task_.callback(),
 400                                     begin_impl_frame_args_.interval * 2);
 401     }
 402   } else {
 403     advance_commit_state_task_.Cancel();
 404   }
 405 }
 406
 407 // BeginFrame is the mechanism that tells us that now is a good time to start
 408 // making a frame. Usually this means that user input for the frame is complete.
 409 // If the scheduler is busy, we queue the BeginFrame to be handled later as
 410 // a BeginRetroFrame.
 411 void Scheduler::BeginFrame(const BeginFrameArgs& args) {
 412   TRACE_EVENT1("cc", "Scheduler::BeginFrame", "args", args.AsValue());
 413   DCHECK(settings_.throttle_frame_production);
 414
 415   BeginFrameArgs adjusted_args(args);
 416   adjusted_args.deadline -= EstimatedParentDrawTime();
 417
 418   bool should_defer_begin_frame;
 419   if (settings_.using_synchronous_renderer_compositor) {
 420     should_defer_begin_frame = false;
 421   } else {
 422     should_defer_begin_frame =
 423         !begin_retro_frame_args_.empty() || begin_retro_frame_posted_ ||
 424         !last_set_needs_begin_frame_ ||
 425         (state_machine_.begin_impl_frame_state() !=
 426          SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
 427   }
 428
 429   if (should_defer_begin_frame) {
 430     begin_retro_frame_args_.push_back(adjusted_args);
 431     TRACE_EVENT_INSTANT0(
 432         "cc", "Scheduler::BeginFrame deferred", TRACE_EVENT_SCOPE_THREAD);
 433     return;
 434   }
 435
 436   BeginImplFrame(adjusted_args);
 437 }
 438
 439 // BeginRetroFrame is called for BeginFrames that we've deferred because
 440 // the scheduler was in the middle of processing a previous BeginFrame.
 441 void Scheduler::BeginRetroFrame() {
 442   TRACE_EVENT0("cc", "Scheduler::BeginRetroFrame");
 443   DCHECK(!settings_.using_synchronous_renderer_compositor);
 444   DCHECK(begin_retro_frame_posted_);
 445   begin_retro_frame_posted_ = false;
 446
 447   // If there aren't any retroactive BeginFrames, then we've lost the
 448   // OutputSurface and should abort.
 449   if (begin_retro_frame_args_.empty())
 450     return;
 451
 452   // Discard expired BeginRetroFrames
 453   // Today, we should always end up with at most one un-expired BeginRetroFrame
 454   // because deadlines will not be greater than the next frame time. We don't
 455   // DCHECK though because some systems don't always have monotonic timestamps.
 456   // TODO(brianderson): In the future, long deadlines could result in us not
 457   // draining the queue if we don't catch up. If we consistently can't catch
 458   // up, our fallback should be to lower our frame rate.
 459   base::TimeTicks now = Now();
 460   base::TimeDelta draw_duration_estimate = client_->DrawDurationEstimate();
 461   while (!begin_retro_frame_args_.empty()) {
 462     base::TimeTicks adjusted_deadline = AdjustedBeginImplFrameDeadline(
 463         begin_retro_frame_args_.front(), draw_duration_estimate);
 464     if (now <= adjusted_deadline)
 465       break;
 466
 467     TRACE_EVENT_INSTANT2("cc",
 468                          "Scheduler::BeginRetroFrame discarding",
 469                          TRACE_EVENT_SCOPE_THREAD,
 470                          "deadline - now",
 471                          (adjusted_deadline - now).InMicroseconds(),
 472                          "BeginFrameArgs",
 473                          begin_retro_frame_args_.front().AsValue());
 474     begin_retro_frame_args_.pop_front();
 475   }
 476
 477   if (begin_retro_frame_args_.empty()) {
 478     DCHECK(settings_.throttle_frame_production);
 479     TRACE_EVENT_INSTANT0("cc",
 480                          "Scheduler::BeginRetroFrames all expired",
 481                          TRACE_EVENT_SCOPE_THREAD);
 482   } else {
 483     BeginImplFrame(begin_retro_frame_args_.front());
 484     begin_retro_frame_args_.pop_front();
 485   }
 486 }
 487
 488 // There could be a race between the posted BeginRetroFrame and a new
 489 // BeginFrame arriving via the normal mechanism. Scheduler::BeginFrame
 490 // will check if there is a pending BeginRetroFrame to ensure we handle
 491 // BeginFrames in FIFO order.
 492 void Scheduler::PostBeginRetroFrameIfNeeded() {
 493   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
 494                "Scheduler::PostBeginRetroFrameIfNeeded",
 495                "state",
 496                AsValue());
 497   if (!last_set_needs_begin_frame_)
 498     return;
 499
 500   if (begin_retro_frame_args_.empty() || begin_retro_frame_posted_)
 501     return;
 502
 503   // begin_retro_frame_args_ should always be empty for the
 504   // synchronous compositor.
 505   DCHECK(!settings_.using_synchronous_renderer_compositor);
 506
 507   if (state_machine_.begin_impl_frame_state() !=
 508       SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE)
 509     return;
 510
 511   begin_retro_frame_posted_ = true;
 512   task_runner_->PostTask(FROM_HERE, begin_retro_frame_closure_);
 513 }
 514
 515 // BeginImplFrame starts a compositor frame that will wait up until a deadline
 516 // for a BeginMainFrame+activation to complete before it times out and draws
 517 // any asynchronous animation and scroll/pinch updates.
 518 void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
 519   TRACE_EVENT1("cc", "Scheduler::BeginImplFrame", "args", args.AsValue());
 520   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
 521             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
 522   DCHECK(state_machine_.HasInitializedOutputSurface());
 523
 524   advance_commit_state_task_.Cancel();
 525
 526   base::TimeDelta draw_duration_estimate = client_->DrawDurationEstimate();
 527   begin_impl_frame_args_ = args;
 528   begin_impl_frame_args_.deadline -= draw_duration_estimate;
 529
 530   if (!state_machine_.impl_latency_takes_priority() &&
 531       state_machine_.MainThreadIsInHighLatencyMode() &&
 532       CanCommitAndActivateBeforeDeadline()) {
 533     state_machine_.SetSkipNextBeginMainFrameToReduceLatency();
 534   }
 535
 536   client_->WillBeginImplFrame(begin_impl_frame_args_);
 537   state_machine_.OnBeginImplFrame(begin_impl_frame_args_);
 538   devtools_instrumentation::DidBeginFrame(layer_tree_host_id_);
 539
 540   ProcessScheduledActions();
 541
 542   state_machine_.OnBeginImplFrameDeadlinePending();
 543   ScheduleBeginImplFrameDeadline(
 544       AdjustedBeginImplFrameDeadline(args, draw_duration_estimate));
 545 }
 546
 547 base::TimeTicks Scheduler::AdjustedBeginImplFrameDeadline(
 548     const BeginFrameArgs& args,
 549     base::TimeDelta draw_duration_estimate) const {
 550   if (settings_.using_synchronous_renderer_compositor) {
 551     // The synchronous compositor needs to draw right away.
 552     return base::TimeTicks();
 553   } else if (state_machine_.ShouldTriggerBeginImplFrameDeadlineEarly()) {
 554     // We are ready to draw a new active tree immediately.
 555     return base::TimeTicks();
 556   } else if (state_machine_.needs_redraw()) {
 557     // We have an animation or fast input path on the impl thread that wants
 558     // to draw, so don't wait too long for a new active tree.
 559     return args.deadline - draw_duration_estimate;
 560   } else {
 561     // The impl thread doesn't have anything it wants to draw and we are just
 562     // waiting for a new active tree, so post the deadline for the next
 563     // expected BeginImplFrame start. This allows us to draw immediately when
 564     // there is a new active tree, instead of waiting for the next
 565     // BeginImplFrame.
 566     // TODO(brianderson): Handle long deadlines (that are past the next frame's
 567     // frame time) properly instead of using this hack.
 568     return args.frame_time + args.interval;
 569   }
 570 }
 571
 572 void Scheduler::ScheduleBeginImplFrameDeadline(base::TimeTicks deadline) {
 573   TRACE_EVENT1(
 574       "cc", "Scheduler::ScheduleBeginImplFrameDeadline", "deadline", deadline);
 575   if (settings_.using_synchronous_renderer_compositor) {
 576     // The synchronous renderer compositor has to make its GL calls
 577     // within this call.
 578     // TODO(brianderson): Have the OutputSurface initiate the deadline tasks
 579     // so the sychronous renderer compositor can take advantage of splitting
 580     // up the BeginImplFrame and deadline as well.
 581     OnBeginImplFrameDeadline();
 582     return;
 583   }
 584   begin_impl_frame_deadline_task_.Cancel();
 585   begin_impl_frame_deadline_task_.Reset(begin_impl_frame_deadline_closure_);
 586
 587   base::TimeDelta delta = deadline - Now();
 588   if (delta <= base::TimeDelta())
 589     delta = base::TimeDelta();
 590   task_runner_->PostDelayedTask(
 591       FROM_HERE, begin_impl_frame_deadline_task_.callback(), delta);
 592 }
 593
 594 void Scheduler::OnBeginImplFrameDeadline() {
 595   TRACE_EVENT0("cc", "Scheduler::OnBeginImplFrameDeadline");
 596   begin_impl_frame_deadline_task_.Cancel();
 597
 598   // We split the deadline actions up into two phases so the state machine
 599   // has a chance to trigger actions that should occur durring and after
 600   // the deadline separately. For example:
 601   // * Sending the BeginMainFrame will not occur after the deadline in
 602   //     order to wait for more user-input before starting the next commit.
 603   // * Creating a new OuputSurface will not occur during the deadline in
 604   //     order to allow the state machine to "settle" first.
 605   state_machine_.OnBeginImplFrameDeadline();
 606   ProcessScheduledActions();
 607   state_machine_.OnBeginImplFrameIdle();
 608   ProcessScheduledActions();
 609
 610   client_->DidBeginImplFrameDeadline();
 611 }
 612
 613 void Scheduler::PollForAnticipatedDrawTriggers() {
 614   TRACE_EVENT0("cc", "Scheduler::PollForAnticipatedDrawTriggers");
 615   poll_for_draw_triggers_task_.Cancel();
 616   state_machine_.DidEnterPollForAnticipatedDrawTriggers();
 617   ProcessScheduledActions();
 618   state_machine_.DidLeavePollForAnticipatedDrawTriggers();
 619 }
 620
 621 void Scheduler::PollToAdvanceCommitState() {
 622   TRACE_EVENT0("cc", "Scheduler::PollToAdvanceCommitState");
 623   advance_commit_state_task_.Cancel();
 624   ProcessScheduledActions();
 625 }
 626
 627 void Scheduler::DrawAndSwapIfPossible() {
 628   DrawResult result = client_->ScheduledActionDrawAndSwapIfPossible();
 629   state_machine_.DidDrawIfPossibleCompleted(result);
 630 }
 631
 632 void Scheduler::ProcessScheduledActions() {
 633   // We do not allow ProcessScheduledActions to be recursive.
 634   // The top-level call will iteratively execute the next action for us anyway.
 635   if (inside_process_scheduled_actions_)
 636     return;
 637
 638   base::AutoReset<bool> mark_inside(&inside_process_scheduled_actions_, true);
 639
 640   SchedulerStateMachine::Action action;
 641   do {
 642     action = state_machine_.NextAction();
 643     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
 644                  "SchedulerStateMachine",
 645                  "state",
 646                  AsValue());
 647     VLOG(2) << "Scheduler::ProcessScheduledActions: "
 648             << SchedulerStateMachine::ActionToString(action) << " "
 649             << state_machine_.GetStatesForDebugging();
 650     state_machine_.UpdateState(action);
 651     base::AutoReset<SchedulerStateMachine::Action>
 652         mark_inside_action(&inside_action_, action);
 653     switch (action) {
 654       case SchedulerStateMachine::ACTION_NONE:
 655         break;
 656       case SchedulerStateMachine::ACTION_ANIMATE:
 657         client_->ScheduledActionAnimate();
 658         break;
 659       case SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME:
 660         client_->ScheduledActionSendBeginMainFrame();
 661         break;
 662       case SchedulerStateMachine::ACTION_COMMIT:
 663         client_->ScheduledActionCommit();
 664         break;
 665       case SchedulerStateMachine::ACTION_UPDATE_VISIBLE_TILES:
 666         client_->ScheduledActionUpdateVisibleTiles();
 667         break;
 668       case SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE:
 669         client_->ScheduledActionActivateSyncTree();
 670         break;
 671       case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE:
 672         DrawAndSwapIfPossible();
 673         break;
 674       case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED:
 675         client_->ScheduledActionDrawAndSwapForced();
 676         break;
 677       case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT:
 678         // No action is actually performed, but this allows the state machine to
 679         // advance out of its waiting to draw state without actually drawing.
 680         break;
 681       case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
 682         client_->ScheduledActionBeginOutputSurfaceCreation();
 683         break;
 684       case SchedulerStateMachine::ACTION_MANAGE_TILES:
 685         client_->ScheduledActionManageTiles();
 686         break;
 687     }
 688   } while (action != SchedulerStateMachine::ACTION_NONE);
 689
 690   SetupNextBeginFrameIfNeeded();
 691   client_->DidAnticipatedDrawTimeChange(AnticipatedDrawTime());
 692
 693   if (state_machine_.ShouldTriggerBeginImplFrameDeadlineEarly()) {
 694     DCHECK(!settings_.using_synchronous_renderer_compositor);
 695     ScheduleBeginImplFrameDeadline(base::TimeTicks());
 696   }
 697 }
 698
 699 bool Scheduler::WillDrawIfNeeded() const {
 700   return !state_machine_.PendingDrawsShouldBeAborted();
 701 }
 702
 703 scoped_refptr<base::debug::ConvertableToTraceFormat> Scheduler::AsValue()
 704     const {
 705   scoped_refptr<base::debug::TracedValue> state =
 706       new base::debug::TracedValue();
 707   AsValueInto(state.get());
 708   return state;
 709 }
 710
 711 void Scheduler::AsValueInto(base::debug::TracedValue* state) const {
 712   state->BeginDictionary("state_machine");
 713   state_machine_.AsValueInto(state, Now());
 714   state->EndDictionary();
 715   if (synthetic_begin_frame_source_) {
 716     state->BeginDictionary("synthetic_begin_frame_source_");
 717     synthetic_begin_frame_source_->AsValueInto(state);
 718     state->EndDictionary();
 719   }
 720
 721   state->BeginDictionary("scheduler_state");
 722   state->SetDouble("time_until_anticipated_draw_time_ms",
 723                    (AnticipatedDrawTime() - Now()).InMillisecondsF());
 724   state->SetDouble("vsync_interval_ms", vsync_interval_.InMillisecondsF());
 725   state->SetDouble("estimated_parent_draw_time_ms",
 726                    estimated_parent_draw_time_.InMillisecondsF());
 727   state->SetBoolean("last_set_needs_begin_frame_", last_set_needs_begin_frame_);
 728   state->SetBoolean("begin_unthrottled_frame_posted_",
 729                     begin_unthrottled_frame_posted_);
 730   state->SetBoolean("begin_retro_frame_posted_", begin_retro_frame_posted_);
 731   state->SetInteger("begin_retro_frame_args_", begin_retro_frame_args_.size());
 732   state->SetBoolean("begin_impl_frame_deadline_task_",
 733                     !begin_impl_frame_deadline_task_.IsCancelled());
 734   state->SetBoolean("poll_for_draw_triggers_task_",
 735                     !poll_for_draw_triggers_task_.IsCancelled());
 736   state->SetBoolean("advance_commit_state_task_",
 737                     !advance_commit_state_task_.IsCancelled());
 738   state->BeginDictionary("begin_impl_frame_args");
 739   begin_impl_frame_args_.AsValueInto(state);
 740   state->EndDictionary();
 741
 742   state->EndDictionary();
 743
 744   state->BeginDictionary("client_state");
 745   state->SetDouble("draw_duration_estimate_ms",
 746                    client_->DrawDurationEstimate().InMillisecondsF());
 747   state->SetDouble(
 748       "begin_main_frame_to_commit_duration_estimate_ms",
 749       client_->BeginMainFrameToCommitDurationEstimate().InMillisecondsF());
 750   state->SetDouble(
 751       "commit_to_activate_duration_estimate_ms",
 752       client_->CommitToActivateDurationEstimate().InMillisecondsF());
 753   state->EndDictionary();
 754 }
 755
 756 bool Scheduler::CanCommitAndActivateBeforeDeadline() const {
 757   // Check if the main thread computation and commit can be finished before the
 758   // impl thread's deadline.
 759   base::TimeTicks estimated_draw_time =
 760       begin_impl_frame_args_.frame_time +
 761       client_->BeginMainFrameToCommitDurationEstimate() +
 762       client_->CommitToActivateDurationEstimate();
 763
 764   TRACE_EVENT2(
 765       TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
 766       "CanCommitAndActivateBeforeDeadline",
 767       "time_left_after_drawing_ms",
 768       (begin_impl_frame_args_.deadline - estimated_draw_time).InMillisecondsF(),
 769       "state",
 770       AsValue());
 771
 772   return estimated_draw_time < begin_impl_frame_args_.deadline;
 773 }
 774
 775 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
 776   return (state_machine_.commit_state() ==
 777               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT ||
 778           state_machine_.commit_state() ==
 779               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED);
 780 }
 781
 782 }  // namespace cc