Roll Chrome into Mojo.

cc/scheduler/scheduler_state_machine.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_state_machine.h"
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 678 matching lines @@
 }
 
 bool SchedulerStateMachine::BeginFrameNeededForChildren() const {
   if (HasInitializedOutputSurface())
     return children_need_begin_frames_;
 
   return false;
 }
 
 bool SchedulerStateMachine::BeginFrameNeeded() const {
+  // We can't handle BeginFrames when output surface isn't initialized.
+  // TODO(brianderson): Support output surface creation inside a BeginFrame.
+  if (!HasInitializedOutputSurface())
+    return false;
+
   if (SupportsProactiveBeginFrame()) {
     return (BeginFrameNeededToAnimateOrDraw() ||
             BeginFrameNeededForChildren() ||
             ProactiveBeginFrameWanted());
   }
 
   // Proactive BeginFrames are bad for the synchronous compositor because we
   // have to draw when we get the BeginFrame and could end up drawing many
   // duplicate frames if our new frame isn't ready in time.
   // To poll for state with the synchronous compositor without having to draw,
   // we rely on ShouldPollForAnticipatedDrawTriggers instead.
   // Synchronous compositor doesn't have a browser.
   DCHECK(!children_need_begin_frames_);
   return BeginFrameNeededToAnimateOrDraw();
 }
 
+bool SchedulerStateMachine::ShouldSetNeedsBeginFrames(
+    bool frame_source_needs_begin_frames) const {
+  bool needs_begin_frame = BeginFrameNeeded();
+
+  // Never call SetNeedsBeginFrames if the frame source has the right value.
+  if (needs_begin_frame == frame_source_needs_begin_frames)
+    return false;
+
+  // Always request the BeginFrame immediately if it's needed.
+  if (needs_begin_frame)
+    return true;
+
+  // Stop requesting BeginFrames after a deadline.
+  if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
+    return true;
+
+  // Stop requesting BeginFrames immediately when output surface is lost.
+  if (!HasInitializedOutputSurface())
+    return true;
+
+  return false;
+}
+
 bool SchedulerStateMachine::ShouldPollForAnticipatedDrawTriggers() const {
   // ShouldPollForAnticipatedDrawTriggers is what we use in place of
   // ProactiveBeginFrameWanted when we are using the synchronous
   // compositor.
   if (!SupportsProactiveBeginFrame()) {
     return !BeginFrameNeededToAnimateOrDraw() && ProactiveBeginFrameWanted();
   }
 
   // Non synchronous compositors should rely on
   // ProactiveBeginFrameWanted to poll for state instead.
@@ skipping 12 matching lines @@
 
 void SchedulerStateMachine::SetChildrenNeedBeginFrames(
     bool children_need_begin_frames) {
   DCHECK(settings_.forward_begin_frames_to_children);
   children_need_begin_frames_ = children_need_begin_frames;
 }
 
 // These are the cases where we definitely (or almost definitely) have a
 // new frame to animate and/or draw and can draw.
 bool SchedulerStateMachine::BeginFrameNeededToAnimateOrDraw() const {
-  // The output surface is the provider of BeginImplFrames, so we are not going
-  // to get them even if we ask for them.
-  if (!HasInitializedOutputSurface())
-    return false;
-
   // The forced draw respects our normal draw scheduling, so we need to
   // request a BeginImplFrame for it.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
     return true;
 
   return needs_animate_ || needs_redraw_;
 }
 
 // These are cases where we are very likely to draw soon, but might not
 // actually have a new frame to draw when we receive the next BeginImplFrame.
 // Proactively requesting the BeginImplFrame helps hide the round trip latency
 // of the SetNeedsBeginFrame request that has to go to the Browser.
 bool SchedulerStateMachine::ProactiveBeginFrameWanted() const {
-  // The output surface is the provider of BeginImplFrames,
-  // so we are not going to get them even if we ask for them.
-  if (!HasInitializedOutputSurface())
-    return false;
-
   // Do not be proactive when invisible.
   if (!visible_)
     return false;
 
   // We should proactively request a BeginImplFrame if a commit is pending
   // because we will want to draw if the commit completes quickly.
   if (needs_commit_ || commit_state_ != COMMIT_STATE_IDLE)
     return true;
 
   // If the pending tree activates quickly, we'll want a BeginImplFrame soon
@@ skipping 323 matching lines @@
       static_cast<int>(begin_impl_frame_state_),
       static_cast<int>(commit_state_),
       has_pending_tree_ ? 'T' : 'F',
       pending_tree_is_ready_for_activation_ ? 'T' : 'F',
       active_tree_needs_first_draw_ ? 'T' : 'F',
       max_pending_swaps_,
       pending_swaps_);
 }
 
 }  // namespace cc