Re-land: cc: Examine layers to determine if we're ready to activate.

cc/layers/picture_layer_impl.cc

Index: cc/layers/picture_layer_impl.cc
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 8a4e30ee8aeed23cd721254522ffaaeb664b46f8..7c2478e0b88ed5f77f212303714539b875e08e54 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -247,8 +247,72 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
     append_quads_data->visible_content_area +=
         visible_geometry_rect.width() * visible_geometry_rect.height();
 
-    if (!*iter || !iter->IsReadyToDraw()) {

[enne (OOO), 2014/05/16 21:18:32]

What is the change to AppendQuads for? It's very hard to follow the diff.

[reveman, 2014/05/21 22:11:39]

This is just moving the code and adding the allow_rasterize_on_demand check to
picture_pile_mode as "IsReadyToDraw" no longer means we can draw the tile. We
need to checkerboard if the tile version is in picture_pile_mode and renderer
doesn't allow on-demand raster.

-      had_checkerboard_quads = true;
+    scoped_ptr<DrawQuad> draw_quad;
+    if (*iter && iter->IsReadyToDraw()) {
+      const ManagedTileState::TileVersion& tile_version =
+          iter->GetTileVersionForDrawing();
+      switch (tile_version.mode()) {
+        case ManagedTileState::TileVersion::RESOURCE_MODE: {
+          gfx::RectF texture_rect = iter.texture_rect();
+          gfx::Rect opaque_rect = iter->opaque_rect();
+          opaque_rect.Intersect(geometry_rect);
+
+          if (iter->contents_scale() != ideal_contents_scale_)
+            append_quads_data->had_incomplete_tile = true;
+
+          scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
+          quad->SetNew(shared_quad_state,
+                       geometry_rect,
+                       opaque_rect,
+                       visible_geometry_rect,
+                       tile_version.get_resource_id(),
+                       texture_rect,
+                       iter.texture_size(),
+                       tile_version.contents_swizzled());
+          draw_quad = quad.PassAs<DrawQuad>();
+          break;
+        }
+        case ManagedTileState::TileVersion::PICTURE_PILE_MODE: {
+          if (layer_tree_impl()
+                  ->GetRendererCapabilities()
+                  .allow_rasterize_on_demand) {

[vmpstr, 2014/05/16 17:09:06]

can you flip this if:

if (!...)
  break;

...

Also, can you add a flag similar to had_checkerboard_quads so that we can see in
traces when we draw what would be a rasterize on demand, but instead
checkerboard because we don't support it?

[reveman, 2014/05/21 22:11:39]

Done.

+            gfx::RectF texture_rect = iter.texture_rect();
+            gfx::Rect opaque_rect = iter->opaque_rect();
+            opaque_rect.Intersect(geometry_rect);
+
+            ResourceProvider* resource_provider =
+                layer_tree_impl()->resource_provider();
+            ResourceFormat format =
+                resource_provider->memory_efficient_texture_format();
+            scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
+            quad->SetNew(shared_quad_state,
+                         geometry_rect,
+                         opaque_rect,
+                         visible_geometry_rect,
+                         texture_rect,
+                         iter.texture_size(),
+                         format,
+                         iter->content_rect(),
+                         iter->contents_scale(),
+                         pile_);
+            draw_quad = quad.PassAs<DrawQuad>();
+          }
+          break;
+        }
+        case ManagedTileState::TileVersion::SOLID_COLOR_MODE: {
+          scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+          quad->SetNew(shared_quad_state,
+                       geometry_rect,
+                       visible_geometry_rect,
+                       tile_version.get_solid_color(),
+                       false);
+          draw_quad = quad.PassAs<DrawQuad>();
+          break;
+        }
+      }
+    }
+
+    if (!draw_quad) {
       if (draw_checkerboard_for_missing_tiles()) {
         scoped_ptr<CheckerboardDrawQuad> quad = CheckerboardDrawQuad::Create();
         SkColor color = DebugColors::DefaultCheckerboardColor();
@@ -270,69 +334,10 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
       append_quads_data->had_incomplete_tile = true;
       append_quads_data->approximated_visible_content_area +=
           visible_geometry_rect.width() * visible_geometry_rect.height();
+      had_checkerboard_quads = true;
       continue;
     }
 
-    const ManagedTileState::TileVersion& tile_version =
-        iter->GetTileVersionForDrawing();
-    scoped_ptr<DrawQuad> draw_quad;
-    switch (tile_version.mode()) {
-      case ManagedTileState::TileVersion::RESOURCE_MODE: {
-        gfx::RectF texture_rect = iter.texture_rect();
-        gfx::Rect opaque_rect = iter->opaque_rect();
-        opaque_rect.Intersect(geometry_rect);
-
-        if (iter->contents_scale() != ideal_contents_scale_)
-          append_quads_data->had_incomplete_tile = true;
-
-        scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
-        quad->SetNew(shared_quad_state,
-                     geometry_rect,
-                     opaque_rect,
-                     visible_geometry_rect,
-                     tile_version.get_resource_id(),
-                     texture_rect,
-                     iter.texture_size(),
-                     tile_version.contents_swizzled());
-        draw_quad = quad.PassAs<DrawQuad>();
-        break;
-      }
-      case ManagedTileState::TileVersion::PICTURE_PILE_MODE: {
-        gfx::RectF texture_rect = iter.texture_rect();
-        gfx::Rect opaque_rect = iter->opaque_rect();
-        opaque_rect.Intersect(geometry_rect);
-
-        ResourceProvider* resource_provider =
-            layer_tree_impl()->resource_provider();
-        ResourceFormat format =
-            resource_provider->memory_efficient_texture_format();
-        scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
-        quad->SetNew(shared_quad_state,
-                     geometry_rect,
-                     opaque_rect,
-                     visible_geometry_rect,
-                     texture_rect,
-                     iter.texture_size(),
-                     format,
-                     iter->content_rect(),
-                     iter->contents_scale(),
-                     pile_);
-        draw_quad = quad.PassAs<DrawQuad>();
-        break;
-      }
-      case ManagedTileState::TileVersion::SOLID_COLOR_MODE: {
-        scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-        quad->SetNew(shared_quad_state,
-                     geometry_rect,
-                     visible_geometry_rect,
-                     tile_version.get_solid_color(),
-                     false);
-        draw_quad = quad.PassAs<DrawQuad>();
-        break;
-      }
-    }
-
-    DCHECK(draw_quad);
     quad_sink->Append(draw_quad.Pass());
 
     if (iter->priority(ACTIVE_TREE).resolution != HIGH_RESOLUTION) {
@@ -425,7 +430,7 @@ void PictureLayerImpl::UpdateTilePriorities() {
   layer_tree_impl()->DidModifyTilePriorities();
 }
 
-void PictureLayerImpl::NotifyTileInitialized(const Tile* tile) {
+void PictureLayerImpl::NotifyTileStateChanged(const Tile* tile) {
   if (layer_tree_impl()->IsActiveTree()) {
     gfx::RectF layer_damage_rect =
         gfx::ScaleRect(tile->content_rect(), 1.f / tile->contents_scale());
@@ -1341,6 +1346,30 @@ bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
+bool PictureLayerImpl::AllTilesRequiredForActivationAreReadyToDraw() const {
+  if (!layer_tree_impl()->IsPendingTree())
+    return true;
+
+  if (!tilings_)
+    return true;
+
+  gfx::Rect rect(visible_content_rect());
+  for (PictureLayerTilingSet::CoverageIterator iter(

[enne (OOO), 2014/05/16 21:18:32]

Sorry but I think this is not correct.

What you need to do is iterate through both the high and low res tilings with
the tiling iterator, but keep the same body of the for loop.

The coverage iterator is really just for drawing.  If a tile is not ready to
draw (and may be required), it will not return it in the iteration, and will
fall back to some non-ideal tile at a different scale.  Therefore, you can skip
over required tiles that are not ready.

Please add a unit test for this case, if you don't mind.

+           tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);
+       iter;
+       ++iter) {
+    const Tile* tile = *iter;
+    // A null tile (i.e. missing recording) can just be skipped.
+    if (!tile)
+      continue;
+
+    if (tile->required_for_activation() && !tile->IsReadyToDraw())
+      return false;
+  }
+
+  return true;
+}
+
 PictureLayerImpl::LayerRasterTileIterator::LayerRasterTileIterator()
     : layer_(NULL) {}