cc: Removed low priority bin from tile management.

cc/resources/tile_manager.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/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 14 matching lines @@
 namespace {
 
 // Memory limit policy works by mapping some bin states to the NEVER bin.
 const ManagedTileBin kBinPolicyMap[NUM_TILE_MEMORY_LIMIT_POLICIES][NUM_BINS] = {
   {  // [ALLOW_NOTHING]
     NEVER_BIN,                  // [NOW_AND_READY_TO_DRAW_BIN]
     NEVER_BIN,                  // [NOW_BIN]
     NEVER_BIN,                  // [SOON_BIN]
     NEVER_BIN,                  // [EVENTUALLY_AND_ACTIVE_BIN]
     NEVER_BIN,                  // [EVENTUALLY_BIN]
-    NEVER_BIN,                  // [NEVER_AND_ACTIVE_BIN]
+    NEVER_BIN,                  // [AT_LAST_AND_ACTIVE_BIN]
+    NEVER_BIN,                  // [AT_LAST_BIN]
     NEVER_BIN                   // [NEVER_BIN]
   }, {  // [ALLOW_ABSOLUTE_MINIMUM]
     NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
     NOW_BIN,                    // [NOW_BIN]
     NEVER_BIN,                  // [SOON_BIN]
     NEVER_BIN,                  // [EVENTUALLY_AND_ACTIVE_BIN]
     NEVER_BIN,                  // [EVENTUALLY_BIN]
-    NEVER_BIN,                  // [NEVER_AND_ACTIVE_BIN]
+    NEVER_BIN,                  // [AT_LAST_AND_ACTIVE_BIN]
+    NEVER_BIN,                  // [AT_LAST_BIN]
     NEVER_BIN                   // [NEVER_BIN]
   }, {  // [ALLOW_PREPAINT_ONLY]
     NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
     NOW_BIN,                    // [NOW_BIN]
     SOON_BIN,                   // [SOON_BIN]
     NEVER_BIN,                  // [EVENTUALLY_AND_ACTIVE_BIN]
     NEVER_BIN,                  // [EVENTUALLY_BIN]
-    NEVER_BIN,                  // [NEVER_AND_ACTIVE_BIN]
+    NEVER_BIN,                  // [AT_LAST_AND_ACTIVE_BIN]
+    NEVER_BIN,                  // [AT_LAST_BIN]
     NEVER_BIN                   // [NEVER_BIN]
   }, {  // [ALLOW_ANYTHING]
     NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
     NOW_BIN,                    // [NOW_BIN]
     SOON_BIN,                   // [SOON_BIN]
     EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
     EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
-    NEVER_AND_ACTIVE_BIN,       // [NEVER_AND_ACTIVE_BIN]
+    AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
+    AT_LAST_BIN,                // [AT_LAST_BIN]
     NEVER_BIN                   // [NEVER_BIN]
   }
 };
 
 // Determine bin based on three categories of tiles: things we need now,
 // things we need soon, and eventually.
 inline ManagedTileBin BinFromTilePriority(const TilePriority& prio,
                                           TreePriority tree_priority,
                                           bool is_ready_to_draw,
                                           bool is_active) {
   // The amount of time for which we want to have prepainting coverage.
   const float kPrepaintingWindowTimeSeconds = 1.0f;
   const float kBackflingGuardDistancePixels = 314.0f;
 
   // Don't let low res tiles be in the now bin unless we're in a mode where
   // we're prioritizing checkerboard prevention.
   bool can_be_in_now_bin = tree_priority == SMOOTHNESS_TAKES_PRIORITY ||
                            prio.resolution != LOW_RESOLUTION;
 
   if (prio.distance_to_visible_in_pixels ==
       std::numeric_limits<float>::infinity())
-    return is_active ? NEVER_AND_ACTIVE_BIN : NEVER_BIN;
+    return NEVER_BIN;
 
   if (can_be_in_now_bin && prio.time_to_visible_in_seconds == 0)
     return is_ready_to_draw ? NOW_AND_READY_TO_DRAW_BIN : NOW_BIN;
 
   if (prio.resolution == NON_IDEAL_RESOLUTION)
     return is_active ? EVENTUALLY_AND_ACTIVE_BIN : EVENTUALLY_BIN;
 
   if (prio.distance_to_visible_in_pixels < kBackflingGuardDistancePixels ||
       prio.time_to_visible_in_seconds < kPrepaintingWindowTimeSeconds)
     return SOON_BIN;
@@ skipping 207 matching lines @@
                                                       tree_priority,
                                                       tile_is_ready_to_draw,
                                                       tile_is_active);
     // Note that |gpu_memmgr_stats_bin| does not care about memory_policy, so we
     // have to save it first.
     mts.gpu_memmgr_stats_bin = combined_bin;
 
     combined_bin = kBinPolicyMap[memory_policy][combined_bin];
 
     TilePriority* high_priority = NULL;
+    bool dual_bin_is_never = false;
     switch (tree_priority) {
       case SAME_PRIORITY_FOR_BOTH_TREES:
-        mts.bin[HIGH_PRIORITY_BIN] = mts.bin[LOW_PRIORITY_BIN] = combined_bin;
+        mts.bin = combined_bin;
+        dual_bin_is_never = (combined_bin == NEVER_BIN);
         high_priority = &combined_priority;
         break;
       case SMOOTHNESS_TAKES_PRIORITY:
-        mts.bin[HIGH_PRIORITY_BIN] = mts.tree_bin[ACTIVE_TREE];
-        mts.bin[LOW_PRIORITY_BIN] = mts.tree_bin[PENDING_TREE];
+        mts.bin = mts.tree_bin[ACTIVE_TREE];
+        dual_bin_is_never = (mts.tree_bin[PENDING_TREE] == NEVER_BIN);
         high_priority = &active_priority;
         break;
       case NEW_CONTENT_TAKES_PRIORITY:
-        mts.bin[HIGH_PRIORITY_BIN] = mts.tree_bin[PENDING_TREE];
-        mts.bin[LOW_PRIORITY_BIN] = mts.tree_bin[ACTIVE_TREE];
+        mts.bin = mts.tree_bin[PENDING_TREE];
+        dual_bin_is_never = (mts.tree_bin[ACTIVE_TREE] == NEVER_BIN);
         high_priority = &pending_priority;
         break;
     }
 
+    // Bump up the priority if we determined it's NEVER_BIN on one tree,
+    // but is still required on the other tree.
+    if (mts.bin == NEVER_BIN && !dual_bin_is_never)

[reveman, 2013/08/26 20:56:29]

would:

bool is_in_never_bin_on_both_trees =
    mts.tree_bin[ACTIVE_TREE] == NEVER_BIN &&
    mts.tree_bin[PENDING_TREE] == NEVER_BIN;

if (mts.bin == NEVER_BIN && !is_in_never_bin_on_both_trees)
  mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN;

give the same result?

[vmpstr, 2013/08/26 21:08:08]

Yep. That looks better to me, I've changed it.

+      mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN;
+
     DCHECK(high_priority != NULL);
 
     mts.resolution = high_priority->resolution;
     mts.time_to_needed_in_seconds = high_priority->time_to_visible_in_seconds;
     mts.distance_to_visible_in_pixels =
         high_priority->distance_to_visible_in_pixels;
     mts.required_for_activation = high_priority->required_for_activation;
 
     mts.visible_and_ready_to_draw =
         mts.tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
 
-    if (mts.is_in_never_bin_on_both_trees()) {
+    if (mts.bin == NEVER_BIN) {
       FreeResourcesForTile(tile);
       continue;
     }
 
     // Note that if the tile is visible_and_ready_to_draw, then we always want
     // the priority to be NOW_AND_READY_TO_DRAW_BIN, even if HIGH_PRIORITY_BIN
     // is something different. The reason for this is that if we're prioritizing
     // the pending tree, we still want visible tiles to take the highest
     // priority.
     ManagedTileBin priority_bin = mts.visible_and_ready_to_draw
                                   ? NOW_AND_READY_TO_DRAW_BIN
-                                  : mts.bin[HIGH_PRIORITY_BIN];
+                                  : mts.bin;
 
     // Insert the tile into a priority set.
     tiles->InsertTile(tile, priority_bin);
   }
 }
 
 void TileManager::ManageTiles() {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
 
   TileVector tiles_that_need_to_be_rasterized;
@@ skipping 159 matching lines @@
     mts.raster_mode = DetermineRasterMode(tile);
 
     ManagedTileState::TileVersion& tile_version =
         mts.tile_versions[mts.raster_mode];
 
     // If this tile doesn't need a resource, then nothing to do.
     if (!tile_version.requires_resource())
       continue;
 
     // If the tile is not needed, free it up.
-    if (mts.is_in_never_bin_on_both_trees()) {
+    if (mts.bin == NEVER_BIN) {
       FreeResourcesForTile(tile);
       continue;
     }
 
     size_t tile_bytes = 0;
     size_t tile_resources = 0;
 
     // It costs to maintain a resource.
     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
       if (mts.tile_versions[mode].resource_) {
@@ skipping 297 matching lines @@
     bytes_releasable_ += tile->bytes_consumed_if_allocated();
     ++resources_releasable_;
   }
 
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
 }
 
 }  // namespace cc