Home | History | Annotate | Download | only in scheduler 
      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/logging.h"
     11 #include "cc/debug/devtools_instrumentation.h"
     12 #include "cc/debug/traced_value.h"
     13 #include "ui/gfx/frame_time.h"
     14 
     15 namespace cc {
     16 
     17 Scheduler::Scheduler(SchedulerClient* client,
     18                      const SchedulerSettings& scheduler_settings,
     19                      int layer_tree_host_id)
     20     : settings_(scheduler_settings),
     21       client_(client),
     22       layer_tree_host_id_(layer_tree_host_id),
     23       last_set_needs_begin_impl_frame_(false),
     24       state_machine_(scheduler_settings),
     25       inside_process_scheduled_actions_(false),
     26       inside_action_(SchedulerStateMachine::ACTION_NONE),
     27       weak_factory_(this) {
     28   DCHECK(client_);
     29   DCHECK(!state_machine_.BeginImplFrameNeeded());
     30 }
     31 
     32 Scheduler::~Scheduler() {}
     33 
     34 void Scheduler::SetCanStart() {
     35   state_machine_.SetCanStart();
     36   ProcessScheduledActions();
     37 }
     38 
     39 void Scheduler::SetVisible(bool visible) {
     40   state_machine_.SetVisible(visible);
     41   ProcessScheduledActions();
     42 }
     43 
     44 void Scheduler::SetCanDraw(bool can_draw) {
     45   state_machine_.SetCanDraw(can_draw);
     46   ProcessScheduledActions();
     47 }
     48 
     49 void Scheduler::NotifyReadyToActivate() {
     50   state_machine_.NotifyReadyToActivate();
     51   ProcessScheduledActions();
     52 }
     53 
     54 void Scheduler::ActivatePendingTree() {
     55   client_->ScheduledActionActivatePendingTree();
     56 }
     57 
     58 void Scheduler::SetNeedsCommit() {
     59   state_machine_.SetNeedsCommit();
     60   ProcessScheduledActions();
     61 }
     62 
     63 void Scheduler::SetNeedsForcedCommitForReadback() {
     64   state_machine_.SetNeedsCommit();
     65   state_machine_.SetNeedsForcedCommitForReadback();
     66   ProcessScheduledActions();
     67 }
     68 
     69 void Scheduler::SetNeedsRedraw() {
     70   state_machine_.SetNeedsRedraw();
     71   ProcessScheduledActions();
     72 }
     73 
     74 void Scheduler::SetNeedsManageTiles() {
     75   DCHECK(!IsInsideAction(SchedulerStateMachine::ACTION_MANAGE_TILES));
     76   state_machine_.SetNeedsManageTiles();
     77   ProcessScheduledActions();
     78 }
     79 
     80 void Scheduler::SetSwapUsedIncompleteTile(bool used_incomplete_tile) {
     81   state_machine_.SetSwapUsedIncompleteTile(used_incomplete_tile);
     82   ProcessScheduledActions();
     83 }
     84 
     85 void Scheduler::SetSmoothnessTakesPriority(bool smoothness_takes_priority) {
     86   state_machine_.SetSmoothnessTakesPriority(smoothness_takes_priority);
     87   ProcessScheduledActions();
     88 }
     89 
     90 void Scheduler::SetMainThreadNeedsLayerTextures() {
     91   state_machine_.SetMainThreadNeedsLayerTextures();
     92   ProcessScheduledActions();
     93 }
     94 
     95 void Scheduler::FinishCommit() {
     96   TRACE_EVENT0("cc", "Scheduler::FinishCommit");
     97   state_machine_.FinishCommit();
     98   ProcessScheduledActions();
     99 }
    100 
    101 void Scheduler::BeginMainFrameAborted(bool did_handle) {
    102   TRACE_EVENT0("cc", "Scheduler::BeginMainFrameAborted");
    103   state_machine_.BeginMainFrameAborted(did_handle);
    104   ProcessScheduledActions();
    105 }
    106 
    107 void Scheduler::DidManageTiles() {
    108   state_machine_.DidManageTiles();
    109 }
    110 
    111 void Scheduler::DidLoseOutputSurface() {
    112   TRACE_EVENT0("cc", "Scheduler::DidLoseOutputSurface");
    113   last_set_needs_begin_impl_frame_ = false;
    114   begin_impl_frame_deadline_closure_.Cancel();
    115   state_machine_.DidLoseOutputSurface();
    116   ProcessScheduledActions();
    117 }
    118 
    119 void Scheduler::DidCreateAndInitializeOutputSurface() {
    120   TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
    121   DCHECK(!last_set_needs_begin_impl_frame_);
    122   DCHECK(begin_impl_frame_deadline_closure_.IsCancelled());
    123   state_machine_.DidCreateAndInitializeOutputSurface();
    124   ProcessScheduledActions();
    125 }
    126 
    127 base::TimeTicks Scheduler::AnticipatedDrawTime() {
    128   TRACE_EVENT0("cc", "Scheduler::AnticipatedDrawTime");
    129 
    130   if (!last_set_needs_begin_impl_frame_ ||
    131       last_begin_impl_frame_args_.interval <= base::TimeDelta())
    132     return base::TimeTicks();
    133 
    134   base::TimeTicks now = gfx::FrameTime::Now();
    135   base::TimeTicks timebase = std::max(last_begin_impl_frame_args_.frame_time,
    136                                       last_begin_impl_frame_args_.deadline);
    137   int64 intervals =
    138       1 + ((now - timebase) / last_begin_impl_frame_args_.interval);
    139   return timebase + (last_begin_impl_frame_args_.interval * intervals);
    140 }
    141 
    142 base::TimeTicks Scheduler::LastBeginImplFrameTime() {
    143   return last_begin_impl_frame_args_.frame_time;
    144 }
    145 
    146 void Scheduler::SetupNextBeginImplFrameIfNeeded() {
    147   bool needs_begin_impl_frame =
    148       state_machine_.BeginImplFrameNeeded();
    149 
    150   bool at_end_of_deadline =
    151       state_machine_.begin_impl_frame_state() ==
    152           SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE;
    153 
    154   bool should_call_set_needs_begin_impl_frame =
    155       // Always request the BeginImplFrame immediately if it wasn't needed
    156       // before.
    157       (needs_begin_impl_frame && !last_set_needs_begin_impl_frame_) ||
    158       // We always need to explicitly request our next BeginImplFrame.
    159       at_end_of_deadline;
    160 
    161   if (should_call_set_needs_begin_impl_frame) {
    162     client_->SetNeedsBeginImplFrame(needs_begin_impl_frame);
    163     last_set_needs_begin_impl_frame_ = needs_begin_impl_frame;
    164   }
    165 
    166   bool needs_advance_commit_state_timer = false;
    167   // Setup PollForAnticipatedDrawTriggers if we need to monitor state but
    168   // aren't expecting any more BeginImplFrames. This should only be needed by
    169   // the synchronous compositor when BeginImplFrameNeeded is false.
    170   if (state_machine_.ShouldPollForAnticipatedDrawTriggers()) {
    171     DCHECK(!state_machine_.SupportsProactiveBeginImplFrame());
    172     DCHECK(!needs_begin_impl_frame);
    173     if (poll_for_draw_triggers_closure_.IsCancelled()) {
    174       poll_for_draw_triggers_closure_.Reset(
    175           base::Bind(&Scheduler::PollForAnticipatedDrawTriggers,
    176                      weak_factory_.GetWeakPtr()));
    177       base::MessageLoop::current()->PostDelayedTask(
    178           FROM_HERE,
    179           poll_for_draw_triggers_closure_.callback(),
    180           last_begin_impl_frame_args_.interval);
    181     }
    182   } else {
    183     poll_for_draw_triggers_closure_.Cancel();
    184 
    185     // At this point we'd prefer to advance through the commit flow by
    186     // drawing a frame, however it's possible that the frame rate controller
    187     // will not give us a BeginImplFrame until the commit completes.  See
    188     // crbug.com/317430 for an example of a swap ack being held on commit. Thus
    189     // we set a repeating timer to poll on ProcessScheduledActions until we
    190     // successfully reach BeginImplFrame.
    191     if (state_machine_.IsCommitStateWaiting())
    192       needs_advance_commit_state_timer = true;
    193   }
    194   if (needs_advance_commit_state_timer !=
    195       advance_commit_state_timer_.IsRunning()) {
    196     if (needs_advance_commit_state_timer &&
    197         last_begin_impl_frame_args_.IsValid()) {
    198     // Since we'd rather get a BeginImplFrame by the normally mechanism, we set
    199     // the interval to twice the interval from the previous frame.
    200       advance_commit_state_timer_.Start(
    201           FROM_HERE,
    202           last_begin_impl_frame_args_.interval * 2,
    203           base::Bind(&Scheduler::ProcessScheduledActions,
    204                      base::Unretained(this)));
    205     } else {
    206       advance_commit_state_timer_.Stop();
    207     }
    208   }
    209 }
    210 
    211 void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
    212   TRACE_EVENT0("cc", "Scheduler::BeginImplFrame");
    213   DCHECK(state_machine_.begin_impl_frame_state() ==
    214          SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
    215   DCHECK(state_machine_.HasInitializedOutputSurface());
    216   last_begin_impl_frame_args_ = args;
    217   last_begin_impl_frame_args_.deadline -= client_->DrawDurationEstimate();
    218   state_machine_.OnBeginImplFrame(last_begin_impl_frame_args_);
    219 
    220   if (settings_.switch_to_low_latency_if_possible) {
    221     state_machine_.SetSkipBeginMainFrameToReduceLatency(
    222         state_machine_.MainThreadIsInHighLatencyMode() &&
    223             CanCommitAndActivateBeforeDeadline());
    224   }
    225 
    226   ProcessScheduledActions();
    227 
    228   if (!state_machine_.HasInitializedOutputSurface())
    229     return;
    230 
    231   state_machine_.OnBeginImplFrameDeadlinePending();
    232   devtools_instrumentation::didBeginFrame(layer_tree_host_id_);
    233   if (settings_.using_synchronous_renderer_compositor) {
    234     // The synchronous renderer compositor has to make its GL calls
    235     // within this call to BeginImplFrame.
    236     // TODO(brianderson): Have the OutputSurface initiate the deadline tasks
    237     // so the sychronous renderer compositor can take advantage of splitting
    238     // up the BeginImplFrame and deadline as well.
    239     OnBeginImplFrameDeadline();
    240   } else if (!settings_.deadline_scheduling_enabled) {
    241     // We emulate the old non-deadline scheduler here by posting the
    242     // deadline task without any delay.
    243     PostBeginImplFrameDeadline(base::TimeTicks());
    244   } else if (state_machine_.ShouldTriggerBeginImplFrameDeadlineEarly()) {
    245     // We are ready to draw a new active tree immediately.
    246     PostBeginImplFrameDeadline(base::TimeTicks());
    247   } else if (state_machine_.needs_redraw()) {
    248     // We have an animation or fast input path on the impl thread that wants
    249     // to draw, so don't wait too long for a new active tree.
    250     PostBeginImplFrameDeadline(last_begin_impl_frame_args_.deadline);
    251   } else {
    252     // The impl thread doesn't have anything it wants to draw and we are just
    253     // waiting for a new active tree, so post the deadline for the next
    254     // expected BeginImplFrame start. This allows us to draw immediately when
    255     // there is a new active tree, instead of waiting for the next
    256     // BeginImplFrame.
    257     // TODO(brianderson): Handle long deadlines (that are past the next frame's
    258     // frame time) properly instead of using this hack.
    259     PostBeginImplFrameDeadline(last_begin_impl_frame_args_.frame_time +
    260                                last_begin_impl_frame_args_.interval);
    261   }
    262 }
    263 
    264 void Scheduler::PostBeginImplFrameDeadline(base::TimeTicks deadline) {
    265   begin_impl_frame_deadline_closure_.Cancel();
    266   begin_impl_frame_deadline_closure_.Reset(
    267       base::Bind(&Scheduler::OnBeginImplFrameDeadline,
    268                  weak_factory_.GetWeakPtr()));
    269   client_->PostBeginImplFrameDeadline(
    270       begin_impl_frame_deadline_closure_.callback(), deadline);
    271 }
    272 
    273 void Scheduler::OnBeginImplFrameDeadline() {
    274   TRACE_EVENT0("cc", "Scheduler::OnBeginImplFrameDeadline");
    275   DCHECK(state_machine_.HasInitializedOutputSurface());
    276   begin_impl_frame_deadline_closure_.Cancel();
    277   state_machine_.OnBeginImplFrameDeadline();
    278   ProcessScheduledActions();
    279 
    280   if (state_machine_.HasInitializedOutputSurface()) {
    281     // We only transition out of BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE when all
    282     // actions that occur back-to-back in response to entering
    283     // BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE have completed. This is important
    284     // because sending the BeginMainFrame will not occur if we transition to
    285     // BEGIN_IMPL_FRAME_STATE_IDLE too early.
    286     state_machine_.OnBeginImplFrameIdle();
    287   }
    288 
    289   client_->DidBeginImplFrameDeadline();
    290 }
    291 
    292 void Scheduler::PollForAnticipatedDrawTriggers() {
    293   TRACE_EVENT0("cc", "Scheduler::PollForAnticipatedDrawTriggers");
    294   poll_for_draw_triggers_closure_.Cancel();
    295   state_machine_.DidEnterPollForAnticipatedDrawTriggers();
    296   ProcessScheduledActions();
    297   state_machine_.DidLeavePollForAnticipatedDrawTriggers();
    298 }
    299 
    300 void Scheduler::DrawAndSwapIfPossible() {
    301   DrawSwapReadbackResult result =
    302       client_->ScheduledActionDrawAndSwapIfPossible();
    303   state_machine_.DidDrawIfPossibleCompleted(result.did_draw);
    304 }
    305 
    306 void Scheduler::DrawAndSwapForced() {
    307   client_->ScheduledActionDrawAndSwapForced();
    308 }
    309 
    310 void Scheduler::DrawAndReadback() {
    311   DrawSwapReadbackResult result = client_->ScheduledActionDrawAndReadback();
    312   DCHECK(!result.did_swap);
    313 }
    314 
    315 void Scheduler::ProcessScheduledActions() {
    316   // We do not allow ProcessScheduledActions to be recursive.
    317   // The top-level call will iteratively execute the next action for us anyway.
    318   if (inside_process_scheduled_actions_)
    319     return;
    320 
    321   base::AutoReset<bool> mark_inside(&inside_process_scheduled_actions_, true);
    322 
    323   SchedulerStateMachine::Action action;
    324   do {
    325     state_machine_.CheckInvariants();
    326     action = state_machine_.NextAction();
    327     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
    328                  "SchedulerStateMachine",
    329                  "state",
    330                  TracedValue::FromValue(state_machine_.AsValue().release()));
    331     state_machine_.UpdateState(action);
    332     base::AutoReset<SchedulerStateMachine::Action>
    333         mark_inside_action(&inside_action_, action);
    334     switch (action) {
    335       case SchedulerStateMachine::ACTION_NONE:
    336         break;
    337       case SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME:
    338         client_->ScheduledActionSendBeginMainFrame();
    339         break;
    340       case SchedulerStateMachine::ACTION_COMMIT:
    341         client_->ScheduledActionCommit();
    342         break;
    343       case SchedulerStateMachine::ACTION_UPDATE_VISIBLE_TILES:
    344         client_->ScheduledActionUpdateVisibleTiles();
    345         break;
    346       case SchedulerStateMachine::ACTION_ACTIVATE_PENDING_TREE:
    347         ActivatePendingTree();
    348         break;
    349       case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE:
    350         DrawAndSwapIfPossible();
    351         break;
    352       case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED:
    353         DrawAndSwapForced();
    354         break;
    355       case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT:
    356         // No action is actually performed, but this allows the state machine to
    357         // advance out of its waiting to draw state without actually drawing.
    358         break;
    359       case SchedulerStateMachine::ACTION_DRAW_AND_READBACK:
    360         DrawAndReadback();
    361         break;
    362       case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
    363         client_->ScheduledActionBeginOutputSurfaceCreation();
    364         break;
    365       case SchedulerStateMachine::ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD:
    366         client_->ScheduledActionAcquireLayerTexturesForMainThread();
    367         break;
    368       case SchedulerStateMachine::ACTION_MANAGE_TILES:
    369         client_->ScheduledActionManageTiles();
    370         break;
    371     }
    372   } while (action != SchedulerStateMachine::ACTION_NONE);
    373 
    374   SetupNextBeginImplFrameIfNeeded();
    375   client_->DidAnticipatedDrawTimeChange(AnticipatedDrawTime());
    376 
    377   if (state_machine_.ShouldTriggerBeginImplFrameDeadlineEarly())
    378     PostBeginImplFrameDeadline(base::TimeTicks());
    379 }
    380 
    381 bool Scheduler::WillDrawIfNeeded() const {
    382   return !state_machine_.PendingDrawsShouldBeAborted();
    383 }
    384 
    385 bool Scheduler::CanCommitAndActivateBeforeDeadline() const {
    386   // Check if the main thread computation and commit can be finished before the
    387   // impl thread's deadline.
    388   base::TimeTicks estimated_draw_time =
    389       last_begin_impl_frame_args_.frame_time +
    390       client_->BeginMainFrameToCommitDurationEstimate() +
    391       client_->CommitToActivateDurationEstimate();
    392 
    393   return estimated_draw_time < last_begin_impl_frame_args_.deadline;
    394 }
    395 
    396 }  // namespace cc
    397