cc: Use multiple PrepareTiles approaches

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 306 matching lines @@
   if (settings_.impl_side_painting) {
     // Impl-side painting needs an update immediately post-commit to have the
     // opportunity to create tilings.  Other paths can call UpdateDrawProperties
     // more lazily when needed prior to drawing.  Because invalidations may
     // be coming from the main thread, it's safe to do an update for lcd text
     // at this point and see if lcd text needs to be disabled on any layers.
     bool update_lcd_text = true;
     sync_tree()->UpdateDrawProperties(update_lcd_text);
     // Start working on newly created tiles immediately if needed.
     if (tile_manager_ && tile_priorities_dirty_) {
-      PrepareTiles();
+      bool for_commit = true;
+      client_->SetNeedsPrepareTilesOnImplThread(for_commit);
     } else {
       NotifyReadyToActivate();
 
       // Ensure we get ReadyToDraw signal even when PrepareTiles not run. This
       // is important for SingleThreadProxy and impl-side painting case. For
       // STP, we commit to active tree and RequiresHighResToDraw, and set
       // Scheduler to wait for ReadyToDraw signal to avoid Checkerboard.
       if (proxy_->CommitToActiveTree())
         NotifyReadyToDraw();
     }
@@ skipping 61 matching lines @@
 void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time) {
   if (input_handler_client_)
     input_handler_client_->Animate(monotonic_time);
   AnimatePageScale(monotonic_time);
   AnimateLayers(monotonic_time);
   AnimateScrollbars(monotonic_time);
   AnimateTopControls(monotonic_time);
 }
 
 void LayerTreeHostImpl::PrepareTiles() {
+  bool update_lcd_text = false;
+  if (pending_tree_)
+    pending_tree_->UpdateDrawProperties(update_lcd_text);
+  if (active_tree_)
+    active_tree_->UpdateDrawProperties(update_lcd_text);
+
   if (!tile_manager_)
     return;
   if (!tile_priorities_dirty_)
     return;
 
   tile_priorities_dirty_ = false;
   tile_manager_->PrepareTiles(global_tile_state_);
-
-  client_->DidPrepareTiles();
 }
 
 void LayerTreeHostImpl::StartPageScaleAnimation(
     const gfx::Vector2d& target_offset,
     bool anchor_point,
     float page_scale,
     base::TimeDelta duration) {
   if (!InnerViewportScrollLayer())
     return;
 
@@ skipping 355 matching lines @@
   // Typically when we are missing a texture and use a checkerboard quad, we
   // still draw the frame. However when the layer being checkerboarded is moving
   // due to an impl-animation, we drop the frame to avoid flashing due to the
   // texture suddenly appearing in the future.
   DrawResult draw_result = DRAW_SUCCESS;
 
   int layers_drawn = 0;
 
   const DrawMode draw_mode = GetDrawMode();
 
+  int num_layers_missing_raster_source = 0;
   int num_missing_tiles = 0;
   int num_incomplete_tiles = 0;
   bool have_copy_request = false;
   bool have_missing_animated_tiles = false;
 
   auto end = LayerIterator<LayerImpl>::End(frame->render_surface_layer_list);
   for (auto it =
            LayerIterator<LayerImpl>::Begin(frame->render_surface_layer_list);
        it != end; ++it) {
     RenderPassId target_render_pass_id =
@@ skipping 62 matching lines @@
       ++layers_drawn;
     }
 
     rendering_stats_instrumentation_->AddVisibleContentArea(
         append_quads_data.visible_content_area);
     rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
         append_quads_data.approximated_visible_content_area);
     rendering_stats_instrumentation_->AddCheckerboardedVisibleContentArea(
         append_quads_data.checkerboarded_visible_content_area);
 
+    if (!append_quads_data.raster_source_covers_visible_high_res_tiles)
+      num_layers_missing_raster_source++;
+
     num_missing_tiles += append_quads_data.num_missing_tiles;
     num_incomplete_tiles += append_quads_data.num_incomplete_tiles;
 
     if (append_quads_data.num_missing_tiles) {
+      // TODO(brianderson): Figure out what to do in this case and
+      // differentiate and prioritize scroll wheel, touch scroll, and
+      // animations.
       bool layer_has_animating_transform =
           it->screen_space_transform_is_animating() ||
           it->draw_transform_is_animating();
       if (layer_has_animating_transform)
         have_missing_animated_tiles = true;
     }
   }
 
-  if (have_missing_animated_tiles)
-    draw_result = DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
-
-  // 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;
+  if (output_surface_->capabilities().draw_and_swap_full_viewport_every_frame) {
+    // When this capability is set 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.
+    // TODO(brianderson): Use a forced draw instead of lying about the draw
+    // result.
+    draw_result = DRAW_SUCCESS;
+  } else if (num_layers_missing_raster_source) {
+    TRACE_EVENT_INSTANT0("cc", "Raster missing source.",
+                         TRACE_EVENT_SCOPE_THREAD);
+    draw_result = DRAW_ABORTED_MISSING_RASTER_SOURCE;

[enne (OOO), 2015/05/19 22:53:41]

Is it possible to separate this change into two patches: one about PrepareTiles
in more cases, and the other about checkerboarding?

This is the part I'm most unclear about.  I'm not sure we want to always abort
draws in these case?  Will this ever draw and checkerboard and get forced?

[brianderson, 2015/05/20 01:33:17]

Definitely need to split this patch up - I'll see what I can do.
My intent is to only allow checkerboards if the draw is forced - so it is very
explicit when our draw might checkerboard. The scheduler will force the draw
after detecting checkerboard by doing the following:


PREPARE_TILES_APPROACH_PRIORITIZE_LATENCY only calls DrawAndSwapIfPossible
PREPARE_TILES_APPROACH_ACCURATE_ACTIVE_WORK only calls DrawAndSwapForced

The first time DrawAndSwapIfPossible aborts due to checker, the scheduler
transitions to PREPARE_TILES_APPROACH_ACCURATE_ACTIVE_WORK until we quiesce.
PREPARE_TILES_APPROACH_ACCURATE_ACTIVE_WORK helps avoid checkerboards by waiting
for NotifyReadyToDraw.

One thing this patch doesn't do right now is reschedule the deadline immediately
after DrawAndSwapIfPossible aborts instead of waiting for the next frame. I need
to fix that.

+  } else if (num_missing_tiles) {
+    TRACE_EVENT_INSTANT0("cc", "Raster missing output.",
+                         TRACE_EVENT_SCOPE_THREAD);
+    draw_result = DRAW_ABORTED_MISSING_RASTER_OUTPUT_ANY;
+  } else if (num_incomplete_tiles) {
+    TRACE_EVENT_INSTANT0("cc", "Raster missing high res.",
+                         TRACE_EVENT_SCOPE_THREAD);
+    draw_result = DRAW_ABORTED_MISSING_RASTER_OUTPUT_HIGH_RES;
   }
 
-  // When this capability is set 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)
-    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
   DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
 
@@ skipping 297 matching lines @@
         visible_ ? GetMaxStagingResourceCount() : 0);
   }
 
   DidModifyTilePriorities();
 }
 
 void LayerTreeHostImpl::DidModifyTilePriorities() {
   DCHECK(settings_.impl_side_painting);
   // Mark priorities as dirty and schedule a PrepareTiles().
   tile_priorities_dirty_ = true;
-  client_->SetNeedsPrepareTilesOnImplThread();
+  bool for_commit = false;
+  client_->SetNeedsPrepareTilesOnImplThread(for_commit);
 }
 
 scoped_ptr<RasterTilePriorityQueue> LayerTreeHostImpl::BuildRasterQueue(
     TreePriority tree_priority,
     RasterTilePriorityQueue::Type type) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildRasterQueue");
 
   return RasterTilePriorityQueue::Create(active_tree_->picture_layers(),
                                          pending_tree_
                                              ? pending_tree_->picture_layers()
@@ skipping 427 matching lines @@
   ReleaseTreeResources();
   if (tile_manager_) {
     DestroyTileManager();
     CreateAndSetTileManager();
   }
   RecreateTreeResources();
 
   // We have released tilings for both active and pending tree.
   // We would not have any content to draw until the pending tree is activated.
   // Prevent the active tree from drawing until activation.
-  SetRequiresHighResToDraw();
+  SetRequiresHighResToDraw(true);
 
   tree_resources_for_gpu_rasterization_dirty_ = false;
 }
 
 const RendererCapabilitiesImpl&
 LayerTreeHostImpl::GetRendererCapabilities() const {
   CHECK(renderer_);
   return renderer_->Capabilities();
 }
 
 bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
-  ResetRequiresHighResToDraw();
+  SetRequiresHighResToDraw(false);
   if (frame.has_no_damage) {
     active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
     return false;
   }
   CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
   active_tree()->FinishSwapPromises(&metadata);
   for (auto& latency : metadata.latency_info) {
     TRACE_EVENT_FLOW_STEP0(
         "input,benchmark",
         "LatencyInfo.Flow",
@@ skipping 241 matching lines @@
 
   if (visible_ == visible)
     return;
   visible_ = visible;
   DidVisibilityChange(this, visible_);
   EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
 
   // If we just became visible, we have to ensure that we draw high res tiles,
   // to prevent checkerboard/low res flashes.
   if (visible_)
-    SetRequiresHighResToDraw();
+    SetRequiresHighResToDraw(true);
   else
     EvictAllUIResources();
 
-  // Evict tiles immediately if invisible since this tab may never get another
-  // draw or timer tick.
-  if (!visible_)
-    PrepareTiles();
-
   if (!renderer_)
     return;
 
   renderer_->SetVisible(visible);
 }
 
 void LayerTreeHostImpl::SetNeedsAnimate() {
   NotifySwapPromiseMonitorsOfSetNeedsRedraw();
   client_->SetNeedsAnimateOnImplThread();
 }
@@ skipping 271 matching lines @@
 
   int max_frames_pending = output_surface_->capabilities().max_frames_pending;
   if (max_frames_pending <= 0)
     max_frames_pending = OutputSurface::DEFAULT_MAX_FRAMES_PENDING;
   client_->SetMaxSwapsPendingOnImplThread(max_frames_pending);
   client_->OnCanDrawStateChanged(CanDraw());
 
   // There will not be anything to draw here, so set high res
   // to avoid checkerboards, typically when we are recovering
   // from lost context.
-  SetRequiresHighResToDraw();
+  SetRequiresHighResToDraw(true);
 
   return true;
 }
 
 void LayerTreeHostImpl::CommitVSyncParameters(base::TimeTicks timebase,
                                               base::TimeDelta interval) {
   client_->CommitVSyncParameters(timebase, interval);
 }
 
 void LayerTreeHostImpl::SetViewportSize(const gfx::Size& device_viewport_size) {
@@ skipping 1178 matching lines @@
   new_target.SetToMin(layer_impl->MaxScrollOffset());
 
   curve->UpdateTarget(
       animation->TrimTimeToCurrentIteration(CurrentBeginFrameArgs().frame_time)
           .InSecondsF(),
       new_target);
 
   return true;
 }
 }  // namespace cc