Revert of cc: Change required_for_activation bookkeeping.

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 38 matching lines @@
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
       raster_contents_scale_(0.f),
       low_res_raster_contents_scale_(0.f),
       raster_source_scale_was_animating_(false),
       is_using_lcd_text_(tree_impl->settings().can_use_lcd_text),
       needs_post_commit_initialization_(true),
       should_update_tile_priorities_(false),
       should_use_low_res_tiling_(tree_impl->settings().create_low_res_tiling),
       use_gpu_rasterization_(false),
-      layer_needs_to_register_itself_(true),
-      uninitialized_tiles_required_for_activation_count_(0) {
-}
+      layer_needs_to_register_itself_(true) {}
 
 PictureLayerImpl::~PictureLayerImpl() {
   if (!layer_needs_to_register_itself_)
     layer_tree_impl()->tile_manager()->UnregisterPictureLayerImpl(this);
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
   return "cc::PictureLayerImpl";
 }
 
@@ skipping 328 matching lines @@
   }
 
   WhichTree tree =
       layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
 
   tilings_->UpdateTilePriorities(tree,
                                  visible_rect_in_content_space,
                                  contents_scale_x(),
                                  current_frame_time_in_seconds);
 
-  uninitialized_tiles_required_for_activation_count_ = 0;
   if (layer_tree_impl()->IsPendingTree())
     MarkVisibleResourcesAsRequired();
 
   // Tile priorities were modified.
   layer_tree_impl()->DidModifyTilePriorities();
 }
 
 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);
-
-    DCHECK_EQ(0, uninitialized_tiles_required_for_activation_count_);
-  } else if (layer_tree_impl()->IsPendingTree()) {
-    if (tile->required_for_activation()) {
-      DCHECK_GT(uninitialized_tiles_required_for_activation_count_, 0);
-      --uninitialized_tiles_required_for_activation_count_;
-    }
   }
 }
 
 void PictureLayerImpl::DidBecomeActive() {
   LayerImpl::DidBecomeActive();
   tilings_->DidBecomeActive();
   layer_tree_impl()->DidModifyTilePriorities();
 }
 
 void PictureLayerImpl::DidBeginTracing() {
@@ skipping 306 matching lines @@
 
   const ManagedTileState::TileVersion& tile_version =
       iter->GetTileVersionForDrawing();
   if (!tile_version.IsReadyToDraw() ||
       tile_version.mode() != ManagedTileState::TileVersion::RESOURCE_MODE)
     return 0;
 
   return tile_version.get_resource_id();
 }
 
-void PictureLayerImpl::MarkVisibleResourcesAsRequired() {
+void PictureLayerImpl::MarkVisibleResourcesAsRequired() const {
   DCHECK(layer_tree_impl()->IsPendingTree());
   DCHECK(!layer_tree_impl()->needs_update_draw_properties());
   DCHECK(ideal_contents_scale_);
   DCHECK_GT(tilings_->num_tilings(), 0u);
 
   // The goal of this function is to find the minimum set of tiles that need to
   // be ready to draw in order to activate without flashing content from a
   // higher res on the active tree to a lower res on the pending tree.
 
   gfx::Rect rect(visible_content_rect());
@@ skipping 87 matching lines @@
     MarkVisibleTilesAsRequired(
         low_res, twin_low_res, contents_scale_x(), rect, missing_region);
   }
 }
 
 bool PictureLayerImpl::MarkVisibleTilesAsRequired(
     PictureLayerTiling* tiling,
     const PictureLayerTiling* optional_twin_tiling,
     float contents_scale,
     const gfx::Rect& rect,
-    const Region& missing_region) {
+    const Region& missing_region) const {
   bool twin_had_missing_tile = false;
   for (PictureLayerTiling::CoverageIterator iter(tiling,
                                                  contents_scale,
                                                  rect);
        iter;
        ++iter) {
     Tile* tile = *iter;
     // A null tile (i.e. missing recording) can just be skipped.
     if (!tile)
       continue;
 
     // If the missing region doesn't cover it, this tile is fully
     // covered by acceptable tiles at other scales.
     if (!missing_region.Intersects(iter.geometry_rect()))
       continue;
 
     // If the twin tile doesn't exist (i.e. missing recording or so far away
     // that it is outside the visible tile rect) or this tile is shared between
     // with the twin, then this tile isn't required to prevent flashing.
     if (optional_twin_tiling) {
       Tile* twin_tile = optional_twin_tiling->TileAt(iter.i(), iter.j());
       if (!twin_tile || twin_tile == tile) {
         twin_had_missing_tile = true;
         continue;
       }
     }
-    DCHECK(!tile->required_for_activation());
+
     tile->MarkRequiredForActivation();
-    if (!tile->IsReadyToDraw())
-      ++uninitialized_tiles_required_for_activation_count_;
   }
   return twin_had_missing_tile;
 }
 
 void PictureLayerImpl::DoPostCommitInitialization() {
   DCHECK(needs_post_commit_initialization_);
   DCHECK(layer_tree_impl()->IsPendingTree());
 
   if (!tilings_)
     tilings_.reset(new PictureLayerTilingSet(this, bounds()));
@@ skipping 641 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