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 215 matching lines @@
                                 color,
                                 width);
       quad_sink->Append(debug_border_quad.PassAs<DrawQuad>());
     }
   }
 
   // Keep track of the tilings that were used so that tilings that are
   // unused can be considered for removal.
   std::vector<PictureLayerTiling*> seen_tilings;
 
-  bool had_checkerboard_quads = false;
+  size_t missing_tile_count = 0u;
+  size_t on_demand_missing_tile_count = 0u;
   for (PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);
        iter;
        ++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()) {
-      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) {
+            ++on_demand_missing_tile_count;
+            break;
+          }
+
+          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();
+      ++missing_tile_count;
       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());
   }
 
-  if (had_checkerboard_quads) {
-    TRACE_EVENT_INSTANT0("cc",
+  if (missing_tile_count) {
+    TRACE_EVENT_INSTANT2("cc",
                          "PictureLayerImpl::AppendQuads checkerboard",
-                         TRACE_EVENT_SCOPE_THREAD);
+                         TRACE_EVENT_SCOPE_THREAD,
+                         "missing_tile_count",
+                         missing_tile_count,
+                         "on_demand_missing_tile_count",
+                         on_demand_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(seen_tilings);
 }
 
 void PictureLayerImpl::DidUnregisterLayer() {
@@ skipping 61 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 904 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;
+
+  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = tilings_->tiling_at(i);
+    if (tiling->resolution() != HIGH_RESOLUTION &&
+        tiling->resolution() != LOW_RESOLUTION)
+      continue;
+
+    gfx::Rect rect(visible_content_rect());
+    for (PictureLayerTiling::CoverageIterator iter(
+             tiling, contents_scale_x(), rect);
+         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