cc: Simplify SetNeedsBeginFrames code in scheduler.

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/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 702 matching lines @@
   // 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())

[brianderson, 2015/03/19 01:25:54]

This condition isn't taken into account in the code ported to the Scheduler, but
we'll trigger the deadline immediately in this case and so it shouldn't matter.
Is that true?


... nm. I see that your test changes capture this change in behavior and the
tests look good to me.

[sunnyps, 2015/03/19 01:31:53]

Yes, the new way of calling SetNeedsBeginFrames(false) is more general than what
we had before.

Before we would call SetNBF(false) when the output surface was lost. I'm pretty
sure this was done because the output surface can be lost in between BeginFrames
(idle state).

Now we call SetBNF(false) if we're idle.

-    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 367 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