Revert 272635 "cc: Examine layers to determine if we're ready to..."

trunk/src/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;
 
-  size_t missing_tile_count = 0u;
-  size_t on_demand_missing_tile_count = 0u;
+  bool had_checkerboard_quads = false;
   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();
 
-    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 (!*iter || !iter->IsReadyToDraw()) {
+      had_checkerboard_quads = true;
       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 (missing_tile_count) {
-    TRACE_EVENT_INSTANT2("cc",
+  if (had_checkerboard_quads) {
+    TRACE_EVENT_INSTANT0("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_SCOPE_THREAD);
   }
 
   // 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::NotifyTileStateChanged(const Tile* tile) {
+void PictureLayerImpl::NotifyTileInitialized(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