cc: Fix disabled vsync state freezing

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/values.h"
@@ skipping 733 matching lines @@
   DCHECK_NE(texture_state_, LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD);
   main_thread_needs_layer_textures_ = true;
 }
 
 bool SchedulerStateMachine::BeginFrameNeededByImplThread() const {
   // 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.
-  if (settings_.using_synchronous_renderer_compositor)
+  if (!SupportsProactiveBeginFrame())
     return BeginFrameNeededToDrawByImplThread();
 
   return BeginFrameNeededToDrawByImplThread() ||
          ProactiveBeginFrameWantedByImplThread();
 }
 
 bool SchedulerStateMachine::ShouldPollForAnticipatedDrawTriggers() const {
   // ShouldPollForAnticipatedDrawTriggers is what we use in place of
   // ProactiveBeginFrameWantedByImplThread when we are using the synchronous
   // compositor.
-  if (settings_.using_synchronous_renderer_compositor) {
+  if (!SupportsProactiveBeginFrame()) {
     return !BeginFrameNeededToDrawByImplThread() &&
            ProactiveBeginFrameWantedByImplThread();
   }
 
   // Non synchronous compositors should rely on
   // ProactiveBeginFrameWantedByImplThread to poll for state instead.
   return false;
 }
 
+bool SchedulerStateMachine::SupportsProactiveBeginFrame() const {
+  // Both the synchronous compositor and disabled vsync settings
+  // make it undesirable to proactively request begin frames.
+  // If this is true, the scheduler should poll.
+  return !settings_.using_synchronous_renderer_compositor &&
+         settings_.throttle_frame_production;
+}
+
 // These are the cases where we definitely (or almost definitely) have a
 // new frame to draw and can draw.
 bool SchedulerStateMachine::BeginFrameNeededToDrawByImplThread() const {
   // The output surface is the provider of BeginFrames for the impl thread,
   // so we are not going to get them even if we ask for them.
   if (!HasInitializedOutputSurface())
     return false;
 
   // If we can't draw, don't tick until we are notified that we can draw again.
   if (!can_draw_)
@@ skipping 20 matching lines @@
 // 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 BeginFrame.
 // Proactively requesting the BeginFrame helps hide the round trip latency of
 // the SetNeedsBeginFrame request that has to go to the Browser.
 bool SchedulerStateMachine::ProactiveBeginFrameWantedByImplThread() const {
   // The output surface is the provider of BeginFrames for the impl thread,
   // so we are not going to get them even if we ask for them.
   if (!HasInitializedOutputSurface())
     return false;
 
-  // Do not be proactive if vsync is off.
-  if (!settings_.throttle_frame_production)
-    return false;
-
   // Do not be proactive when invisible.
   if (!visible_)
     return false;
 
   // We should proactively request a BeginFrame 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 BeginFrame soon
@@ skipping 170 matching lines @@
     case OUTPUT_SURFACE_ACTIVE:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace cc