[cc] Only NOW-binned tiles should contribute to over-memory accounting

cc/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/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 477 matching lines @@
   // currently waiting for raster to idle state.
   // Call DidTileRasterStateChange() for each of these tiles to
   // have this state change take effect.
   for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = *it;
     if (tile->managed_state().raster_state == WAITING_FOR_RASTER_STATE)
       DidTileRasterStateChange(tile, IDLE_STATE);
   }
 
   size_t bytes_allocatable = global_state_.memory_limit_in_bytes - unreleasable_bytes;
-  size_t bytes_that_exceeded_memory_budget = 0;
+  size_t bytes_that_exceeded_memory_budget_in_now_bin = 0;
   size_t bytes_left = bytes_allocatable;
   for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = *it;
     size_t tile_bytes = tile->bytes_consumed_if_allocated();
     ManagedTileState& managed_tile_state = tile->managed_state();
     if (!managed_tile_state.can_be_freed)
       continue;
     if (managed_tile_state.bin[HIGH_PRIORITY_BIN] == NEVER_BIN &&
         managed_tile_state.bin[LOW_PRIORITY_BIN] == NEVER_BIN) {
       managed_tile_state.can_use_gpu_memory = false;
       FreeResourcesForTile(tile);
       continue;
     }
     if (tile_bytes > bytes_left) {
       managed_tile_state.can_use_gpu_memory = false;
-      bytes_that_exceeded_memory_budget += tile_bytes;
+      if (managed_tile_state.bin[HIGH_PRIORITY_BIN] == NOW_BIN ||
+          managed_tile_state.bin[LOW_PRIORITY_BIN] == NOW_BIN)
+          bytes_that_exceeded_memory_budget_in_now_bin += tile_bytes;
       FreeResourcesForTile(tile);
       continue;
     }
     bytes_left -= tile_bytes;
     managed_tile_state.can_use_gpu_memory = true;
     if (!managed_tile_state.resource &&
         !managed_tile_state.resource_is_being_initialized) {
       tiles_that_need_to_be_rasterized_.push_back(tile);
       DidTileRasterStateChange(tile, WAITING_FOR_RASTER_STATE);
     }
   }
 
-  ever_exceeded_memory_budget_ |= bytes_that_exceeded_memory_budget > 0;
+  ever_exceeded_memory_budget_ |=
+      bytes_that_exceeded_memory_budget_in_now_bin > 0;
   if (ever_exceeded_memory_budget_) {
       TRACE_COUNTER_ID2("cc", "over_memory_budget", this,
                         "budget", global_state_.memory_limit_in_bytes,
-                        "over", bytes_that_exceeded_memory_budget);
+                        "over", bytes_that_exceeded_memory_budget_in_now_bin);
   }
   memory_stats_from_last_assign_.total_budget_in_bytes =
       global_state_.memory_limit_in_bytes;
   memory_stats_from_last_assign_.bytes_allocated =
       bytes_allocatable - bytes_left;
   memory_stats_from_last_assign_.bytes_unreleasable = unreleasable_bytes;
   memory_stats_from_last_assign_.bytes_over =
-      bytes_that_exceeded_memory_budget;
+      bytes_that_exceeded_memory_budget_in_now_bin;
 
   // Reverse two tiles_that_need_* vectors such that pop_back gets
   // the highest priority tile.
   std::reverse(
       tiles_that_need_to_be_rasterized_.begin(),
       tiles_that_need_to_be_rasterized_.end());
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
@@ skipping 335 matching lines @@
     decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::Now() - decode_begin_time;
   }
 }
 
 }  // namespace cc