cc: Prevent tiles that are required for activation from being placed in NEVER_BIN.

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 572 matching lines @@
     // Get the pending priority and bin.
     TilePriority pending_priority = tile->priority(PENDING_TREE);
     ManagedTileBin pending_bin = BinFromTilePriority(pending_priority);
 
     bool pending_is_low_res = pending_priority.resolution == LOW_RESOLUTION;
     bool pending_is_non_ideal =
         pending_priority.resolution == NON_IDEAL_RESOLUTION;
     bool active_is_non_ideal =
         active_priority.resolution == NON_IDEAL_RESOLUTION;
 
-    // Adjust pending bin state for low res tiles. This prevents
-    // pending tree low-res tiles from being initialized before
-    // high-res tiles.
-    if (pending_is_low_res)
-      pending_bin = std::max(pending_bin, EVENTUALLY_BIN);
-
     // Adjust bin state based on if ready to draw.
     active_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][active_bin];
     pending_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][pending_bin];
 
     // Adjust bin state based on if active.
     active_bin = kBinIsActiveMap[tile_is_active][active_bin];
     pending_bin = kBinIsActiveMap[tile_is_active][pending_bin];
 
     // We never want to paint new non-ideal tiles, as we always have
     // a high-res tile covering that content (paint that instead).
     if (!tile_is_ready_to_draw && active_is_non_ideal)
       active_bin = NEVER_BIN;
     if (!tile_is_ready_to_draw && pending_is_non_ideal)
       pending_bin = NEVER_BIN;
 
-    // Compute combined bin.
-    ManagedTileBin combined_bin = std::min(active_bin, pending_bin);
-
     if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
       // The bin that the tile would have if the GPU memory manager had
       // a maximally permissive policy, send to the GPU memory manager
       // to determine policy.
-      ManagedTileBin gpu_memmgr_stats_bin = combined_bin;
+      ManagedTileBin gpu_memmgr_stats_bin = std::min(active_bin, pending_bin);
       if ((gpu_memmgr_stats_bin == NOW_BIN) ||
           (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
         memory_required_bytes_ += BytesConsumedIfAllocated(tile);
       if (gpu_memmgr_stats_bin != NEVER_BIN)
         memory_nice_to_have_bytes_ += BytesConsumedIfAllocated(tile);
     }
 
     ManagedTileBin tree_bin[NUM_TREES];
     tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
     tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
 
+    // Adjust pending bin state for low res tiles. This prevents pending tree
+    // low-res tiles from being initialized before high-res tiles.
+    if (pending_is_low_res)
+      tree_bin[PENDING_TREE] = std::max(tree_bin[PENDING_TREE], EVENTUALLY_BIN);
+
     TilePriority tile_priority;
     switch (tree_priority) {
       case SAME_PRIORITY_FOR_BOTH_TREES:
-        mts.bin = kBinPolicyMap[memory_policy][combined_bin];
+        mts.bin = std::min(tree_bin[ACTIVE_TREE], tree_bin[PENDING_TREE]);
         tile_priority = tile->combined_priority();
         break;
       case SMOOTHNESS_TAKES_PRIORITY:
         mts.bin = tree_bin[ACTIVE_TREE];
         tile_priority = active_priority;
         break;
       case NEW_CONTENT_TAKES_PRIORITY:
         mts.bin = tree_bin[PENDING_TREE];
         tile_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.
     bool is_in_never_bin_on_both_trees = tree_bin[ACTIVE_TREE] == NEVER_BIN &&
                                          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;
 
     mts.resolution = tile_priority.resolution;
     mts.priority_bin = tile_priority.priority_bin;
     mts.distance_to_visible = tile_priority.distance_to_visible;
     mts.required_for_activation = tile_priority.required_for_activation;
 
     mts.visible_and_ready_to_draw =
         tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
 
+    // Tiles that are required for activation shouldn't be in NEVER_BIN unless
+    // smoothness takes priority or memory policy allows nothing to be
+    // initialized.
+    DCHECK(!mts.required_for_activation || mts.bin != NEVER_BIN ||
+           tree_priority == SMOOTHNESS_TAKES_PRIORITY ||
+           memory_policy == ALLOW_NOTHING);
+
     // If the tile is in NEVER_BIN and it does not have an active task, then we
     // can release the resources early. If it does have the task however, we
     // should keep it in the prioritized tile set to ensure that AssignGpuMemory
     // can visit it.
     if (mts.bin == NEVER_BIN &&
         !mts.tile_versions[mts.raster_mode].raster_task_) {
       FreeResourcesForTile(tile);
       continue;
     }
 
@@ skipping 956 matching lines @@
 }
 
 void TileManager::SetRasterizersForTesting(Rasterizer* rasterizer,
                                            Rasterizer* gpu_rasterizer) {
   Rasterizer* rasterizers[2] = {rasterizer, gpu_rasterizer};
   rasterizer_delegate_ =
       RasterizerDelegate::Create(this, rasterizers, arraysize(rasterizers));
 }
 
 }  // namespace cc