cc: Avoid deadlock with the UI thread and NPAPI in more cases

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 384 matching lines @@
   if (!visible_)
     return false;
 
   // Do not make a new commits when it is deferred.
   if (defer_commits_)
     return false;
 
   return true;
 }
 
+bool SchedulerStateMachine::SendingBeginMainFrameMightCauseDeadlock() const {
+  // NPAPI is the only case where the UI thread makes synchronous calls to the
+  // Renderer main thread. During that synchronous call, we may not get a
+  // SwapAck for the UI thread, which may prevent BeginMainFrame's from
+  // completing if there's enough back pressure. If the BeginMainFrame can't
+  // make progress, the Renderer can't service the UI thread's synchronous call
+  // and we have deadlock.
+  // This returns true if there's too much backpressure to finish a commit
+  // if we were to initiate a BeginMainFrame.
+  return has_pending_tree_ && active_tree_needs_first_draw_ &&
+         pending_swaps_ >= max_pending_swaps_;
+}
+
 bool SchedulerStateMachine::ShouldSendBeginMainFrame() const {
   if (!CouldSendBeginMainFrame())
     return false;
 
   // Do not send begin main frame too many times in a single frame.
   if (send_begin_main_frame_funnel_)
     return false;
 
   // Only send BeginMainFrame when there isn't another commit pending already.
+  // Other parts of the state machine indirectly defer the BeginMainFrame
+  // by transitioning to WAITING commit states rather than going
+  // immediately to IDLE.
   if (commit_state_ != COMMIT_STATE_IDLE)
     return false;
 
   // Don't send BeginMainFrame early if we are prioritizing the active tree
   // because of impl_latency_takes_priority_.
   if (impl_latency_takes_priority_ &&
       (has_pending_tree_ || active_tree_needs_first_draw_)) {
     return false;
   }
 
   // We should not send BeginMainFrame while we are in
   // BEGIN_IMPL_FRAME_STATE_IDLE since we might have new
   // user input arriving soon.
   // TODO(brianderson): Allow sending BeginMainFrame while idle when the main
   // thread isn't consuming user input.
   if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_IDLE &&
       BeginFrameNeeded())
     return false;
 
   // We need a new commit for the forced redraw. This honors the
   // single commit per interval because the result will be swapped to screen.
+  // TODO(brianderson): Remove this or move it below the
+  // SendingBeginMainFrameMightCauseDeadlock check since  we want to avoid
+  // ever returning true from this method if we might cause deadlock.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT)
     return true;
 
   // We shouldn't normally accept commits if there isn't an OutputSurface.
   if (!HasInitializedOutputSurface())
     return false;
 
-  // SwapAck throttle the BeginMainFrames unless we just swapped.
-  // TODO(brianderson): Remove this restriction to improve throughput.
-  bool just_swapped_in_deadline =
-      begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
-      did_perform_swap_in_last_draw_;
-  if (pending_swaps_ >= max_pending_swaps_ && !just_swapped_in_deadline)
+  // Make sure the BeginMainFrame can finish eventually if we start it.
+  if (SendingBeginMainFrameMightCauseDeadlock())
     return false;
 
+  if (!settings_.main_frame_while_swap_throttled_enabled) {
+    // SwapAck throttle the BeginMainFrames unless we just swapped to
+    // potentially improve impl-thread latency over main-thread throughput.
+    // TODO(brianderson): Remove this restriction to improve throughput or
+    // make it conditional on impl_latency_takes_priority_.
+    bool just_swapped_in_deadline =
+        begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
+        did_perform_swap_in_last_draw_;
+    if (pending_swaps_ >= max_pending_swaps_ && !just_swapped_in_deadline)
+      return false;
+  }
+
   if (skip_begin_main_frame_to_reduce_latency_)
     return false;
 
   return true;
 }
 
 bool SchedulerStateMachine::ShouldCommit() const {
   if (commit_state_ != COMMIT_STATE_READY_TO_COMMIT)
     return false;
 
   // We must not finish the commit until the pending tree is free.
   if (has_pending_tree_) {
     DCHECK(settings_.main_frame_before_activation_enabled);
     return false;
   }
 
-  // Prioritize drawing the previous commit before finishing the next commit.
-  if (active_tree_needs_first_draw_)
-    return false;
+  // If impl-side-painting, commit to the pending tree as soon as we can.
+  if (settings_.impl_side_painting)
+    return true;
 
-  return true;
+  // If we only have an active tree, it is incorrect to replace it
+  // before we've drawn it when we aren't impl-side-painting.
+  DCHECK(!settings_.impl_side_painting);
+  return !active_tree_needs_first_draw_;
 }
 
 bool SchedulerStateMachine::ShouldPrepareTiles() const {
   // PrepareTiles only really needs to be called immediately after commit
   // and then periodically after that. Use a funnel to make sure we average
   // one PrepareTiles per BeginImplFrame in the long run.
   if (prepare_tiles_funnel_ > 0)
     return false;
 
   // Limiting to once per-frame is not enough, since we only want to
@@ skipping 657 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