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 242 matching lines @@
   // 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);
 
   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())
       continue;
 
     append_quads_data->visible_content_area +=
         visible_geometry_rect.width() * visible_geometry_rect.height();
 
+    bool raster_source_covers_tile = *iter;

[brianderson, 2015/05/16 02:39:57]

Enne, Vlad: Is this correct?

[vmpstr, 2015/05/18 17:20:48]

Not quite. We've talked about this offline a little bit, but I think we should
use CoversRect to detect this and we probably won't be able to get the number of
tiles out of this, so maybe just a bool for now.

[enne (OOO), 2015/05/18 21:40:50]

Yeah, false here means that the coverage iterator couldn't find tiles that were
ready to draw to cover it.  That could just mean that they weren't ready to
draw.  (It could theoretically mean that there weren't any tilings, but this
wouldn't happen in practice.)  It could mean that there weren't tiles at all,
and that usually implies that the raster source can't cover it.

We could get the number of tiles, but it'd kind of be a waste of work.  I like
vmpstr's idea of just one CoversRect and a bool.

     bool has_draw_quad = false;
-    if (*iter && iter->IsReadyToDraw()) {
+    if (!raster_source_covers_tile) {
+      // If there's no raster source, we will definitely checkerboard.
+      append_quads_data->num_tiles_missing_raster_source++;
+    } else if (iter->IsReadyToDraw()) {
       const TileDrawInfo& draw_info = iter->draw_info();
       switch (draw_info.mode()) {
         case TileDrawInfo::RESOURCE_MODE: {
           gfx::RectF texture_rect = iter.texture_rect();
 
           // The raster_contents_scale_ is the best scale that the layer is
           // trying to produce, even though it may not be ideal. Since that's
           // the best the layer can promise in the future, consider those as
           // complete. But if a tile is ideal scale, we don't want to consider
           // it incomplete and trying to replace it with a tile at a worse
@@ skipping 68 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 857 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc