[cc] Show GPU memory usage and overage below FPS counter

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 445 matching lines @@
   // tiles_with_image_decoding_tasks_ list above we move all tiles
   // 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_left = global_state_.memory_limit_in_bytes - unreleasable_bytes;
+  size_t bytes_allocatable = global_state_.memory_limit_in_bytes - unreleasable_bytes;
   size_t bytes_that_exceeded_memory_budget = 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;
       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);
     }
   }
 
-  if (bytes_that_exceeded_memory_budget)
-    ever_exceeded_memory_budget_ = true;
-
+  ever_exceeded_memory_budget_ |= bytes_that_exceeded_memory_budget;
   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);
   }
+  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;
 
   // 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 260 matching lines @@
                                      RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   base::TimeTicks decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   stats->totalDeferredImageDecodeCount++;
   stats->totalDeferredImageDecodeTime +=
       base::TimeTicks::Now() - decode_begin_time;
 }
 
 }  // namespace cc