cc: Add more eviction categories to picture layer impl.

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 18 matching lines @@
   explicit TileEvictionOrder(TreePriority tree_priority)
       : tree_priority_(tree_priority) {}
   ~TileEvictionOrder() {}
 
   bool operator()(const Tile* a, const Tile* b) {
     const TilePriority& a_priority =
         a->priority_for_tree_priority(tree_priority_);
     const TilePriority& b_priority =
         b->priority_for_tree_priority(tree_priority_);
 
-    // Evict a before b if their priority bins differ and a has the higher
-    // priority bin.
-    if (a_priority.priority_bin != b_priority.priority_bin)
-      return a_priority.priority_bin > b_priority.priority_bin;
-
-    // Or if a is not required and b is required.
-    if (a->required_for_activation() != b->required_for_activation())
-      return b->required_for_activation();
+    DCHECK(a_priority.priority_bin == b_priority.priority_bin);
+    DCHECK(a->required_for_activation() == b->required_for_activation());
 
     // Or if a is occluded and b is unoccluded.
     bool a_is_occluded = a->is_occluded_for_tree_priority(tree_priority_);
     bool b_is_occluded = b->is_occluded_for_tree_priority(tree_priority_);
     if (a_is_occluded != b_is_occluded)
       return a_is_occluded;
 
     // Or if a is farther away from visible.
     return a_priority.distance_to_visible > b_priority.distance_to_visible;
   }
@@ skipping 783 matching lines @@
     cache->previous_result = result;
   return result;
 }
 
 void PictureLayerTiling::UpdateEvictionCacheIfNeeded(
     TreePriority tree_priority) {
   if (eviction_tiles_cache_valid_ &&
       eviction_cache_tree_priority_ == tree_priority)
     return;
 
-  eventually_eviction_tiles_.clear();
-  soon_eviction_tiles_.clear();
-  now_eviction_tiles_.clear();
-  now_and_required_for_activation_eviction_tiles_.clear();
+  eviction_tiles_now_.clear();
+  eviction_tiles_now_and_rfa_.clear();
+  eviction_tiles_soon_.clear();
+  eviction_tiles_soon_and_rfa_.clear();
+  eviction_tiles_eventually_.clear();
+  eviction_tiles_eventually_and_rfa_.clear();
 
   for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     // TODO(vmpstr): This should update the priority if UpdateTilePriorities
     // changes not to do this.
     Tile* tile = it->second;
     const TilePriority& priority =
         tile->priority_for_tree_priority(tree_priority);
     switch (priority.priority_bin) {
       case TilePriority::EVENTUALLY:
-        eventually_eviction_tiles_.push_back(tile);
+        if (tile->required_for_activation())
+          eviction_tiles_eventually_and_rfa_.push_back(tile);
+        else
+          eviction_tiles_eventually_.push_back(tile);
         break;
       case TilePriority::SOON:
-        soon_eviction_tiles_.push_back(tile);
+        if (tile->required_for_activation())
+          eviction_tiles_soon_and_rfa_.push_back(tile);
+        else
+          eviction_tiles_soon_.push_back(tile);
         break;
       case TilePriority::NOW:
         if (tile->required_for_activation())
-          now_and_required_for_activation_eviction_tiles_.push_back(tile);
+          eviction_tiles_now_and_rfa_.push_back(tile);
         else
-          now_eviction_tiles_.push_back(tile);
+          eviction_tiles_now_.push_back(tile);
         break;
     }
   }
 
   // TODO(vmpstr): Do this lazily. One option is to have a "sorted" flag that
   // can be updated for each of the queues.
   TileEvictionOrder sort_order(tree_priority);
-  std::sort(eventually_eviction_tiles_.begin(),
-            eventually_eviction_tiles_.end(),
+  std::sort(eviction_tiles_now_.begin(), eviction_tiles_now_.end(), sort_order);
+  std::sort(eviction_tiles_now_and_rfa_.begin(),
+            eviction_tiles_now_and_rfa_.end(),
             sort_order);
   std::sort(
-      soon_eviction_tiles_.begin(), soon_eviction_tiles_.end(), sort_order);
-  std::sort(now_eviction_tiles_.begin(), now_eviction_tiles_.end(), sort_order);
-  std::sort(now_and_required_for_activation_eviction_tiles_.begin(),
-            now_and_required_for_activation_eviction_tiles_.end(),
+      eviction_tiles_soon_.begin(), eviction_tiles_soon_.end(), sort_order);
+  std::sort(eviction_tiles_soon_and_rfa_.begin(),
+            eviction_tiles_soon_and_rfa_.end(),
+            sort_order);
+  std::sort(eviction_tiles_eventually_.begin(),
+            eviction_tiles_eventually_.end(),
+            sort_order);
+  std::sort(eviction_tiles_eventually_and_rfa_.begin(),
+            eviction_tiles_eventually_and_rfa_.end(),
             sort_order);
 
   eviction_tiles_cache_valid_ = true;
   eviction_cache_tree_priority_ = tree_priority;
 }
 
 const std::vector<Tile*>* PictureLayerTiling::GetEvictionTiles(
     TreePriority tree_priority,
     EvictionCategory category) {
   UpdateEvictionCacheIfNeeded(tree_priority);
   switch (category) {
     case EVENTUALLY:
-      return &eventually_eviction_tiles_;
+      return &eviction_tiles_eventually_;
+    case EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION:
+      return &eviction_tiles_eventually_and_rfa_;
     case SOON:
-      return &soon_eviction_tiles_;
+      return &eviction_tiles_soon_;
+    case SOON_AND_REQUIRED_FOR_ACTIVATION:
+      return &eviction_tiles_soon_and_rfa_;
     case NOW:
-      return &now_eviction_tiles_;
+      return &eviction_tiles_now_;
     case NOW_AND_REQUIRED_FOR_ACTIVATION:
-      return &now_and_required_for_activation_eviction_tiles_;
+      return &eviction_tiles_now_and_rfa_;
   }
   NOTREACHED();
-  return &eventually_eviction_tiles_;
+  return &eviction_tiles_eventually_;
 }
 
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator()
     : tiling_(NULL), current_tile_(NULL) {}
 
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator(
     PictureLayerTiling* tiling,
     WhichTree tree)
     : tiling_(tiling), phase_(VISIBLE_RECT), tree_(tree), current_tile_(NULL) {
   if (!tiling_->has_visible_rect_tiles_) {
@@ skipping 153 matching lines @@
   DCHECK(*this);
   do {
     ++current_eviction_tiles_index_;
   } while (current_eviction_tiles_index_ != eviction_tiles_->size() &&
            !(*eviction_tiles_)[current_eviction_tiles_index_]->HasResources());
 
   return *this;
 }
 
 }  // namespace cc