android webview: allow cc to fail hardware draw

cc/trees/layer_tree_host_impl.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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
@@ skipping 347 matching lines @@
   if (!renderer_) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   // Must have an OutputSurface if |renderer_| is not NULL.
   DCHECK(output_surface_);
 
   // TODO(boliu): Make draws without root_layer work and move this below
-  // draw_and_swap_full_viewport_every_frame check. Tracked in crbug.com/264967.
+  // |resourceless_software_draw_| check. Tracked in crbug.com/264967.
   if (!active_tree_->root_layer()) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
-  if (output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
+  if (resourceless_software_draw_)
     return true;
 
   if (DrawViewportSize().IsEmpty()) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw empty viewport",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
   if (active_tree_->ViewportSizeInvalid()) {
     TRACE_EVENT_INSTANT0(
         "cc", "LayerTreeHostImpl::CanDraw viewport size recently changed",
@@ skipping 372 matching lines @@
   bool hud_wants_to_draw_ = active_tree_->hud_layer() &&
                             active_tree_->hud_layer()->IsAnimatingHUDContents();
   if (root_surface_has_contributing_layers &&
       root_surface_has_no_visible_damage &&
       active_tree_->LayersWithCopyOutputRequest().empty() &&
       !output_surface_->capabilities().can_force_reclaim_resources &&
       !hud_wants_to_draw_) {
     TRACE_EVENT0("cc",
                  "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
     frame->has_no_damage = true;
-    DCHECK(!output_surface_->capabilities()
-               .draw_and_swap_full_viewport_every_frame);
+    DCHECK(!resourceless_software_draw_);
     return DRAW_SUCCESS;
   }
 
   TRACE_EVENT_BEGIN2(
       "cc", "LayerTreeHostImpl::CalculateRenderPasses",
       "render_surface_layer_list.size()",
       static_cast<uint64>(frame->render_surface_layer_list->size()),
       "RequiresHighResToDraw", RequiresHighResToDraw());
 
   // Create the render passes in dependency order.
@@ skipping 158 matching lines @@
 
   // When we require high res to draw, abort the draw (almost) always. This does
   // not cause the scheduler to do a main frame, instead it will continue to try
   // drawing until we finally complete, so the copy request will not be lost.
   // TODO(weiliangc): Remove RequiresHighResToDraw. crbug.com/469175
   if (num_incomplete_tiles || num_missing_tiles) {
     if (RequiresHighResToDraw())
       draw_result = DRAW_ABORTED_MISSING_HIGH_RES_CONTENT;
   }
 
-  // When this capability is set we don't have control over the surface the
+  // When resourceless software draw, we don't have control over the surface the
   // compositor draws to, so even though the frame may not be complete, the
   // previous frame has already been potentially lost, so an incomplete frame is
   // better than nothing, so this takes highest precidence.
-  if (output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
+  if (resourceless_software_draw_)
     draw_result = DRAW_SUCCESS;
 
 #if DCHECK_IS_ON()
   for (const auto& render_pass : frame->render_passes) {
     for (const auto& quad : render_pass->quad_list)
       DCHECK(quad->shared_quad_state);
     DCHECK(frame->render_passes_by_id.find(render_pass->id) !=
            frame->render_passes_by_id.end());
   }
 #endif
@@ skipping 120 matching lines @@
   if (active_tree_->root_layer()) {
     gfx::Rect device_viewport_damage_rect = viewport_damage_rect_;
     viewport_damage_rect_ = gfx::Rect();
 
     active_tree_->root_layer()->render_surface()->damage_tracker()->
         AddDamageNextUpdate(device_viewport_damage_rect);
   }
 
   DrawResult draw_result = CalculateRenderPasses(frame);
   if (draw_result != DRAW_SUCCESS) {
-    DCHECK(!output_surface_->capabilities()
-               .draw_and_swap_full_viewport_every_frame);
+    DCHECK(!resourceless_software_draw_);
     return draw_result;
   }
 
   // If we return DRAW_SUCCESS, then we expect DrawLayers() to be called before
   // this function is called again.
   return draw_result;
 }
 
 void LayerTreeHostImpl::RemoveRenderPasses(FrameData* frame) {
   // There is always at least a root RenderPass.
@@ skipping 336 matching lines @@
 
   // When not toggling resourceless software draw, need to set redraw for
   // all changes to draw parameters. Damage will be set externally by Android
   // WebView for resourceless software draw toggles, so ignored here.
   const bool draw_params_changed = transform_changed || viewport_changed ||
                                    clip_changed || tile_priority_params_changed;
   if (!resourceless_software_draw_changed && draw_params_changed) {
     SetFullRootLayerDamage();
     SetNeedsRedraw();
   }
+
+  if (resourceless_software_draw_changed) {
+    client_->OnResourcelessSoftareDrawStateChanged(resourceless_software_draw);

[brianderson, 2015/10/21 22:43:04]

Is it possible this is triggered within a draw? Just wondering if we need to be
worried about any weird ordering issues.

[boliu, 2015/10/21 22:46:34]

As in inside LTHI::OnDraw? Nope

+    client_->OnCanDrawStateChanged(CanDraw());
+  }
 }
 
 void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   if (damage_rect.IsEmpty())
     return;
   NotifySwapPromiseMonitorsOfSetNeedsRedraw();
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
 void LayerTreeHostImpl::DidSwapBuffers() {
@@ skipping 88 matching lines @@
   base::TimeTicks frame_begin_time = CurrentBeginFrameArgs().frame_time;
   DCHECK(CanDraw());
 
   if (!frame->composite_events.empty()) {
     frame_timing_tracker_->SaveTimeStamps(frame_begin_time,
                                           frame->composite_events);
   }
 
   if (frame->has_no_damage) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
-    DCHECK(!output_surface_->capabilities()
-               .draw_and_swap_full_viewport_every_frame);
+    DCHECK(!resourceless_software_draw_);
     return;
   }
 
   DCHECK(!frame->render_passes.empty());
 
   fps_counter_->SaveTimeStamp(frame_begin_time,
                               !output_surface_->context_provider());
   rendering_stats_instrumentation_->IncrementFrameCount(1);
 
   memory_history_->SaveEntry(tile_manager_->memory_stats_from_last_assign());
@@ skipping 2058 matching lines @@
   if (active_tree()) {
     LayerAnimationValueProvider* layer = active_tree()->LayerById(layer_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc