android webview: allow cc to fail hardware draw

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 238 matching lines @@
                     did_perform_swap_in_last_draw_);
   state->EndDictionary();
 }
 
 bool SchedulerStateMachine::PendingDrawsShouldBeAborted() const {
   // Normally when |visible_| is false, pending activations will be forced and
   // draws will be aborted. However, when the embedder is Android WebView,
   // software draws could be scheduled by the Android OS at any time and draws
   // should not be aborted in this case.
   bool is_output_surface_lost = (output_surface_state_ == OUTPUT_SURFACE_NONE);
-  if (settings_.using_synchronous_renderer_compositor)
-    return is_output_surface_lost || !can_draw_;
 
   // 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.
-  return is_output_surface_lost || !can_draw_ || !visible_;
+  // Note deliverately not checking |visible_| here because |can_draw_| already
+  // incorporates |visible_| state.
+  // TODO(boliu): This contradicts comment above that

[boliu, 2015/10/09 18:09:51]

Question for Brian:

So this patch shoves resourceless software (which requires always drawing) and
visible into CanDraw. Seems like I can't really get away with scheduler being
oblivious to whether the current draw is resourceless software draw or not. I
had a DCHECK_IMPLIES(!visible_, !can_draw_); before, but then of course that's
obviously doesn't hold with resourceless software mode.

Are you happy with adding this to PendingActivationsShouldBeForced:
if (!PendingDrawsShouldBeAborted())
  return false;

The alternative is to plumb resourceless software draw through to the scheduler,
which means this patch needs a rewrite.

Any thoughts?

[boliu, 2015/10/09 18:39:53]

This goes a bit deeper, since resourceless software can flip between true and
false very often. Is it possible to force activate (!visible &&
!resourcless_software), and then resourceless flips to true, and the pending
draw is not aborted?

(Actually articulating that, not sure what's wrong with that picture..)

+  // PendingDrawsShouldBeAborted is a superset of
+  // PendingActivationsShouldBeForced.
+  return is_output_surface_lost || !can_draw_;
 }
 
 bool SchedulerStateMachine::PendingActivationsShouldBeForced() const {
   // There is no output surface to trigger our activations.
   // If we do not force activations to make forward progress, we might deadlock
   // with the main thread.
   if (output_surface_state_ == OUTPUT_SURFACE_NONE)
     return true;
 
   // If we're not visible, we should force activation.
@@ skipping 824 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