Move occlusion info to TilePriority.

cc/resources/picture_layer_tiling.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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 449 matching lines @@
   SetLiveTilesRect(eventually_rect);
 
   last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
   last_visible_rect_in_content_space_ = visible_rect_in_content_space;
 
   current_visible_rect_in_content_space_ = visible_rect_in_content_space;
   current_skewport_ = skewport;
   current_eventually_rect_ = eventually_rect;
   eviction_tiles_cache_valid_ = false;
 
-  TilePriority now_priority(resolution_, TilePriority::NOW, 0);
+  bool occluded = true;
+  TilePriority now_priority(resolution_, !occluded, TilePriority::NOW, 0);
+  TilePriority now_and_occluded_priority(
+      resolution_, occluded, TilePriority::NOW, 0);
   float content_to_screen_scale =
       1.0f / (contents_scale_ * layer_contents_scale);
 
   // Assign now priority to all visible tiles.
   bool include_borders = true;
   for (TilingData::Iterator iter(
            &tiling_data_, visible_rect_in_content_space, include_borders);
        iter;
        ++iter) {
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
     Tile* tile = find->second.get();
 
-    tile->SetPriority(tree, now_priority);
-
-    // Set whether tile is occluded or not.
+    // Determine whether tile is occluded or not.
     bool is_occluded = false;
     if (occlusion_tracker) {
       gfx::Rect tile_query_rect = ScaleToEnclosingRect(
           IntersectRects(tile->content_rect(), visible_rect_in_content_space),
           1.0f / contents_scale_);
       // TODO(vmpstr): Remove render_target and draw_transform from the
       // parameters so they can be hidden from the tiling.
       is_occluded = occlusion_tracker->Occluded(
           render_target, tile_query_rect, draw_transform);
     }
-    tile->set_is_occluded(is_occluded);
+
+    if (is_occluded) {
+      tile->SetPriority(tree, now_and_occluded_priority);
+    } else {
+      tile->SetPriority(tree, now_priority);
+    }
   }
 
   // Assign soon priority to skewport tiles.
   for (TilingData::DifferenceIterator iter(
            &tiling_data_, skewport, visible_rect_in_content_space);
        iter;
        ++iter) {
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
     Tile* tile = find->second.get();
 
     gfx::Rect tile_bounds =
         tiling_data_.TileBounds(iter.index_x(), iter.index_y());
 
     float distance_to_visible =
         visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
         content_to_screen_scale;
 
-    TilePriority priority(resolution_, TilePriority::SOON, distance_to_visible);
+    TilePriority priority(
+        resolution_, !occluded, TilePriority::SOON, distance_to_visible);
     tile->SetPriority(tree, priority);
   }
 
   // Assign eventually priority to interest rect tiles.
   for (TilingData::DifferenceIterator iter(
            &tiling_data_, eventually_rect, skewport);
        iter;
        ++iter) {
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
     Tile* tile = find->second.get();
 
     gfx::Rect tile_bounds =
         tiling_data_.TileBounds(iter.index_x(), iter.index_y());
 
     float distance_to_visible =
         visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
         content_to_screen_scale;
     TilePriority priority(
-        resolution_, TilePriority::EVENTUALLY, distance_to_visible);
+        resolution_, !occluded, TilePriority::EVENTUALLY, distance_to_visible);
     tile->SetPriority(tree, priority);
   }
 
   // Upgrade the priority on border tiles to be SOON.
   current_soon_border_rect_ = visible_rect_in_content_space;
   float border = kSoonBorderDistanceInScreenPixels / content_to_screen_scale;
   current_soon_border_rect_.Inset(-border, -border, -border, -border);
   for (TilingData::DifferenceIterator iter(
            &tiling_data_, current_soon_border_rect_, skewport);
        iter;
        ++iter) {
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
     Tile* tile = find->second.get();
 
     TilePriority priority(resolution_,
+                          !occluded,
                           TilePriority::SOON,
                           tile->priority(tree).distance_to_visible);
     tile->SetPriority(tree, priority);
   }
 }
 
 void PictureLayerTiling::SetLiveTilesRect(
     const gfx::Rect& new_live_tiles_rect) {
   DCHECK(new_live_tiles_rect.IsEmpty() ||
          TilingRect().Contains(new_live_tiles_rect));
@@ skipping 404 matching lines @@
   tiling_->UpdateEvictionCacheIfNeeded(tree_priority_);
   tile_iterator_ = tiling_->eviction_tiles_cache_.begin();
   is_valid_ = true;
   if (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
       !(*tile_iterator_)->HasResources()) {
     ++(*this);
   }
 }
 
 }  // namespace cc