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

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 <limits>
 
 #include "base/time/time.h"
@@ skipping 229 matching lines @@
        ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
     gfx::Rect visible_geometry_rect =
         quad_sink->UnoccludedContentRect(geometry_rect, draw_transform());
     if (visible_geometry_rect.IsEmpty())
       continue;
 
     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();
         quad->SetNew(
             shared_quad_state, geometry_rect, visible_geometry_rect, color);
         quad_sink->Append(quad.PassAs<DrawQuad>());
       } else {
         SkColor color = SafeOpaqueBackgroundColor();
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(shared_quad_state,
                      geometry_rect,
                      visible_geometry_rect,
                      color,
                      false);
         quad_sink->Append(quad.PassAs<DrawQuad>());
       }
 
       append_quads_data->num_missing_tiles++;
       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) {
       append_quads_data->approximated_visible_content_area +=
           visible_geometry_rect.width() * visible_geometry_rect.height();
     }
 
     if (seen_tilings.empty() || seen_tilings.back() != iter.CurrentTiling())
       seen_tilings.push_back(iter.CurrentTiling());
   }
@@ skipping 72 matching lines @@
                                  contents_scale_x(),
                                  current_frame_time_in_seconds);
 
   if (layer_tree_impl()->IsPendingTree())
     MarkVisibleResourcesAsRequired();
 
   // Tile priorities were modified.
   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());
     AddDamageRect(layer_damage_rect);
   }
 }
 
 void PictureLayerImpl::DidBecomeActive() {
   LayerImpl::DidBecomeActive();
   tilings_->DidBecomeActive();
@@ skipping 895 matching lines @@
 }
 
 WhichTree PictureLayerImpl::GetTree() const {
   return layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
 }
 
 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) {}
 
 PictureLayerImpl::LayerRasterTileIterator::LayerRasterTileIterator(
     PictureLayerImpl* layer,
     bool prioritize_low_res)
     : layer_(layer), current_stage_(0) {
   DCHECK(layer_);
   if (!layer_->tilings_ || !layer_->tilings_->num_tilings()) {
     current_stage_ = arraysize(stages_);
@@ skipping 203 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc