cc: Remove throttling of main frames for preventing NPAPI deadlock.

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 393 matching lines @@
   if (begin_frame_source_paused_)
     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_ && SwapThrottled();
-}
-
 bool SchedulerStateMachine::ShouldSendBeginMainFrame() const {
   if (!CouldSendBeginMainFrame())
     return false;
 
   // Do not send begin main frame too many times in a single frame or before
   // the first BeginFrame.
   if (send_begin_main_frame_funnel_)
     return false;
 
   // Only send BeginMainFrame when there isn't another commit pending already.
@@ skipping 16 matching lines @@
   // latency in that case.
   // TODO(brianderson): Allow sending BeginMainFrame while idle when the main
   // thread isn't consuming user input for non-synchronous compositor.
   if (!settings_.using_synchronous_renderer_compositor &&
       begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_IDLE) {
     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;
 
-  // 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 ImplLatencyTakesPriority.
     bool just_swapped_in_deadline =
         begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
         did_swap_in_last_frame_;
     if (SwapThrottled() && !just_swapped_in_deadline)
       return false;
@@ skipping 649 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