cc: Use multiple PrepareTiles approaches

cc/layers/picture_layer_impl.cc

 // Copyright 2012 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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 241 matching lines @@
   // Keep track of the tilings that were used so that tilings that are
   // unused can be considered for removal.
   last_append_quads_tilings_.clear();
 
   // Ignore missing tiles outside of viewport for tile priority. This is
   // normally the same as draw viewport but can be independently overridden by
   // embedders like Android WebView with SetExternalDrawConstraints.
   gfx::Rect scaled_viewport_for_tile_priority = gfx::ScaleToEnclosingRect(
       viewport_rect_for_tile_priority_in_content_space_, max_contents_scale);
 
+  // Determine if num_incomplete_tiles and num_missing_tiles can become 0
+  // if we wait long enough.
+  auto ideal_tiling = tilings_->FindTilingWithScale(ideal_contents_scale_);
+  bool ideal_tiling_visible_tiles_can_be_rasterized =
+      ideal_tiling && ideal_tiling->RasterSourceCoversCurrentVisibleTiles();
+  auto raster_tiling = tilings_->FindTilingWithScale(raster_contents_scale_);
+  bool raster_tiling_visible_tiles_can_be_rasterized =
+      raster_tiling && raster_tiling->RasterSourceCoversCurrentVisibleTiles();
+  append_quads_data->raster_source_covers_visible_high_res_tiles =
+      ideal_tiling_visible_tiles_can_be_rasterized ||
+      raster_tiling_visible_tiles_can_be_rasterized;
+
   size_t missing_tile_count = 0u;
-  size_t on_demand_missing_tile_count = 0u;
   only_used_low_res_last_append_quads_ = true;
   for (PictureLayerTilingSet::CoverageIterator iter(
            tilings_.get(), max_contents_scale,
            shared_quad_state->visible_content_rect, ideal_contents_scale_);
        iter; ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
     gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect();
     gfx::Rect visible_geometry_rect =
         scaled_occlusion.GetUnoccludedContentRect(geometry_rect);
     if (visible_geometry_rect.IsEmpty())
@@ skipping 85 matching lines @@
     if (iter.resolution() != LOW_RESOLUTION)
       only_used_low_res_last_append_quads_ = false;
 
     if (last_append_quads_tilings_.empty() ||
         last_append_quads_tilings_.back() != iter.CurrentTiling()) {
       last_append_quads_tilings_.push_back(iter.CurrentTiling());
     }
   }
 
   if (missing_tile_count) {
-    TRACE_EVENT_INSTANT2("cc",
-                         "PictureLayerImpl::AppendQuads checkerboard",
-                         TRACE_EVENT_SCOPE_THREAD,
-                         "missing_tile_count",
-                         missing_tile_count,
-                         "on_demand_missing_tile_count",
-                         on_demand_missing_tile_count);
+    TRACE_EVENT_INSTANT1("cc", "PictureLayerImpl::AppendQuads checkerboard",
+                         TRACE_EVENT_SCOPE_THREAD, "missing_tile_count",
+                         missing_tile_count);
   }
 
   // Aggressively remove any tilings that are not seen to save memory. Note
   // that this is at the expense of doing cause more frequent re-painting. A
   // better scheme would be to maintain a tighter visible_content_rect for the
   // finer tilings.
   CleanUpTilingsOnActiveLayer(last_append_quads_tilings_);
 }
 
 bool PictureLayerImpl::UpdateTiles(bool resourceless_software_draw) {
@@ skipping 842 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc