cc: Do not ignore layers without valid priorities during eviction.

cc/resources/picture_layer_tiling.h

 // 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.
 
 #ifndef CC_RESOURCES_PICTURE_LAYER_TILING_H_
 #define CC_RESOURCES_PICTURE_LAYER_TILING_H_
 
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 105 matching lines @@
     Tile* current_tile_;
     TilingData::Iterator visible_iterator_;
     TilingData::SpiralDifferenceIterator spiral_iterator_;
   };
 
   class CC_EXPORT TilingEvictionTileIterator {
    public:
     TilingEvictionTileIterator();
     TilingEvictionTileIterator(PictureLayerTiling* tiling,
                                TreePriority tree_priority,
-                               EvictionCategory category);
+                               EvictionCategory category,
+                               bool use_tile_priority_rects,
+                               bool use_twin_tile_priority_rects);
     ~TilingEvictionTileIterator();
 
     operator bool() const;
     const Tile* operator*() const;
     Tile* operator*();
     TilingEvictionTileIterator& operator++();
 
    private:
     const std::vector<Tile*>* eviction_tiles_;
     size_t current_eviction_tiles_index_;
@@ skipping 37 matching lines @@
 
   std::vector<Tile*> AllTilesForTesting() const {
     std::vector<Tile*> all_tiles;
     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
       all_tiles.push_back(it->second.get());
     return all_tiles;
   }
 
   void UpdateAllTilePrioritiesForTesting() {
     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-      UpdateTileAndTwinPriority(it->second.get());
+      UpdateTileAndTwinPriority(it->second.get(), true, true);
   }
 
   std::vector<scoped_refptr<Tile>> AllRefTilesForTesting() const {
     std::vector<scoped_refptr<Tile>> all_tiles;
     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
       all_tiles.push_back(it->second);
     return all_tiles;
   }
 
   void SetAllTilesOccludedForTesting() {
@@ skipping 118 matching lines @@
   bool RemoveTileAt(int i, int j, PictureLayerTiling* recycled_twin);
 
   // Computes a skewport. The calculation extrapolates the last visible
   // rect and the current visible rect to expand the skewport to where it
   // would be in |skewport_target_time| seconds. Note that the skewport
   // is guaranteed to contain the current visible rect.
   gfx::Rect ComputeSkewport(double current_frame_time_in_seconds,
                             const gfx::Rect& visible_rect_in_content_space)
       const;
 
-  void UpdateEvictionCacheIfNeeded(TreePriority tree_priority);
-  const std::vector<Tile*>* GetEvictionTiles(TreePriority tree_priority,
-                                             EvictionCategory category);
+  void UpdateEvictionCacheIfNeeded(TreePriority tree_priority,
+                                   bool tiling_has_valid_tile_priorities,
+                                   bool twin_tiling_has_valid_tile_priorities);
+  const std::vector<Tile*>* GetEvictionTiles(
+      TreePriority tree_priority,
+      EvictionCategory category,
+      bool tiling_has_valid_tile_priorities,
+      bool twin_tiling_has_valid_tile_priorities);
 
   void Invalidate(const Region& layer_region);
 
   void DoInvalidate(const Region& layer_region,
                     bool recreate_invalidated_tiles);
 
-  void UpdateTileAndTwinPriority(Tile* tile) const;
+  void UpdateTileAndTwinPriority(Tile* tile,
+                                 bool use_tile_priority_rects,
+                                 bool use_twin_tile_priority_rects) const;
   void UpdateTilePriority(Tile* tile) const;
 
   // Given properties.
   float contents_scale_;
   gfx::Size layer_bounds_;
   TileResolution resolution_;
   PictureLayerTilingClient* client_;
 
   // Internal data.
   TilingData tiling_data_;
@@ skipping 36 matching lines @@
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_