cc: Change texture locking check point

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/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 285 matching lines @@
 bool SchedulerStateMachine::PendingDrawsShouldBeAborted() const {
   // These are all the cases where we normally cannot or do not want to draw
   // but, if needs_redraw_ is true and we do not draw to make forward progress,
   // we might deadlock with the main thread.
   // This should be a superset of PendingActivationsShouldBeForced() since
   // activation of the pending tree is blocked by drawing of the active tree and
   // the main thread might be blocked on activation of the most recent commit.
   if (PendingActivationsShouldBeForced())
     return true;
 
+  // Impl thread should not draw anymore when texture is acquired by main thread
+  // because texture is controlled under main thread.
+  if (texture_state_ == LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD)
+    return true;
+
   // Additional states where we should abort draws.
   // Note: We don't force activation in these cases because doing so would
   // result in checkerboarding on resize, becoming visible, etc.
   if (!can_draw_)
     return true;
   if (!visible_)
     return true;
   return false;
 }
 
 bool SchedulerStateMachine::PendingActivationsShouldBeForced() const {
   // These are all the cases where, if we do not force activations to make
   // forward progress, we might deadlock with the main thread.
 
-  // The impl thread cannot lock layer textures unless the pending
-  // tree can be activated to unblock the commit.
-  if (texture_state_ == LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD)
-    return true;
-
   // There is no output surface to trigger our activations.
   if (output_surface_state_ == OUTPUT_SURFACE_LOST)
     return true;
 
   return false;
 }
 
 bool SchedulerStateMachine::ShouldBeginOutputSurfaceCreation() const {
   // Don't try to initialize too early.
   if (!can_start_)
@@ skipping 219 matching lines @@
   if (ShouldBeginOutputSurfaceCreation())
     return ACTION_BEGIN_OUTPUT_SURFACE_CREATION;
   return ACTION_NONE;
 }
 
 void SchedulerStateMachine::CheckInvariants() {
   // We should never try to perform a draw for readback and forced draw due to
   // timeout simultaneously.
   DCHECK(!(forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW &&
            readback_state_ == READBACK_STATE_WAITING_FOR_DRAW_AND_READBACK));
+  // Main thread should never have the texture locked when there is a pending

[brianderson, 2014/03/06 17:56:25]

nit: line break above comment.

[simonhong, 2014/03/06 21:04:48]

Done.

+  // tree.
+  if (has_pending_tree_)

[brianderson, 2014/03/06 17:56:25]

Can you change this to:
if (has_pending_tree_ || active_tree_needs_first_draw_)

The impl thread shouldn't give up it's lock until after the commit has been
drawn for the first time.

[simonhong, 2014/03/06 21:04:48]

Done.

+    DCHECK(texture_state_ != LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD);
 }
 
 void SchedulerStateMachine::UpdateState(Action action) {
   switch (action) {
     case ACTION_NONE:
       return;
 
     case ACTION_UPDATE_VISIBLE_TILES:
       last_frame_number_update_visible_tiles_was_called_ =
           current_frame_number_;
@@ skipping 576 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