Track occlusion per tree on Tile.

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 865 matching lines @@
                                                  contents_scale,
                                                  rect);
        iter;
        ++iter) {
     Tile* tile = *iter;
     // A null tile (i.e. missing recording) can just be skipped.
     if (!tile)
       continue;
 
     // If the tile is occluded, don't mark it as required for activation.
-    if (tile->is_occluded())
+    WhichTree tree =

[danakj, 2014/07/07 19:26:28]

This method should only be called on the pending tree. There's a DCHECK at the
top of PictureLayerImpl::MarkVisibleResourcesAsRequired as such, so you can
hard-code PENDING_TREE here.

[jbedley, 2014/07/07 20:25:13]

Done.

+        layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
+    if (tile->is_occluded(tree))
       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.
@@ skipping 557 matching lines @@
 
   stages_[2].iterator_type = HIGH_RES;
   stages_[2].tile_type = TilePriority::SOON;
 
   stages_[3].iterator_type = HIGH_RES;
   stages_[3].tile_type = TilePriority::EVENTUALLY;
 
   IteratorType index = stages_[current_stage_].iterator_type;
   TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type;
   if (!iterators_[index] || iterators_[index].get_type() != tile_type ||
-      (*iterators_[index])->is_occluded())
+      (*iterators_[index])->is_occluded(tree))
     ++(*this);
 }
 
 PictureLayerImpl::LayerRasterTileIterator::~LayerRasterTileIterator() {}
 
 PictureLayerImpl::LayerRasterTileIterator::operator bool() const {
   return layer_ && static_cast<size_t>(current_stage_) < arraysize(stages_);
 }
 
 PictureLayerImpl::LayerRasterTileIterator&
 PictureLayerImpl::LayerRasterTileIterator::
 operator++() {
+  WhichTree tree =
+      layer_->layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
+
   IteratorType index = stages_[current_stage_].iterator_type;
   TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type;
 
   // First advance the iterator.
   if (iterators_[index])
     ++iterators_[index];
 
   while (iterators_[index] && iterators_[index].get_type() == tile_type &&
-         (*iterators_[index])->is_occluded())
+         (*iterators_[index])->is_occluded(tree))
     ++iterators_[index];
 
   if (iterators_[index] && iterators_[index].get_type() == tile_type)
     return *this;
 
   // Next, advance the stage.
   int stage_count = arraysize(stages_);
   ++current_stage_;
   while (current_stage_ < stage_count) {
     index = stages_[current_stage_].iterator_type;
     tile_type = stages_[current_stage_].tile_type;
 
     if (iterators_[index] && iterators_[index].get_type() == tile_type &&
-        !(*iterators_[index])->is_occluded())
+        !(*iterators_[index])->is_occluded(tree))
       break;
     ++current_stage_;
   }
   return *this;
 }
 
 Tile* PictureLayerImpl::LayerRasterTileIterator::operator*() {
   DCHECK(*this);
 
   IteratorType index = stages_[current_stage_].iterator_type;
@@ skipping 124 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