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 308 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;
+  } else if (num_missing_tiles) {
+    TRACE_EVENT_INSTANT0("cc", "Raster missing output.",
+                         TRACE_EVENT_SCOPE_THREAD);
+    draw_result = DRAW_ABORTED_MISSING_RASTER_OUTPUT_ANY_RES;
+  } 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 275 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 1180 matching lines @@
   new_target.SetToMin(layer_impl->MaxScrollOffset());
 
   curve->UpdateTarget(
       animation->TrimTimeToCurrentIteration(CurrentBeginFrameArgs().frame_time)
           .InSecondsF(),
       new_target);
 
   return true;
 }
 }  // namespace cc