cc: Remove unused metrics from RenderingStats.

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 361 matching lines @@
     // 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];
     combined_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][combined_bin];
 
     // Adjust bin state based on if active.
     active_bin = kBinIsActiveMap[tile_is_active][active_bin];
     pending_bin = kBinIsActiveMap[tile_is_active][pending_bin];
     combined_bin = kBinIsActiveMap[tile_is_active][combined_bin];
 
-    mts.tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
-    mts.tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
+    ManagedTileBin tree_bin[NUM_TREES];
+    tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
+    tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
 
     // 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 = NEVER_BIN;
     TilePriority tile_priority;
 
     switch (tree_priority) {
       case SAME_PRIORITY_FOR_BOTH_TREES:
         mts.bin = kBinPolicyMap[memory_policy][combined_bin];
         gpu_memmgr_stats_bin = combined_bin;
         tile_priority = tile->combined_priority();
         break;
       case SMOOTHNESS_TAKES_PRIORITY:
-        mts.bin = mts.tree_bin[ACTIVE_TREE];
+        mts.bin = tree_bin[ACTIVE_TREE];
         gpu_memmgr_stats_bin = active_bin;
         tile_priority = active_priority;
         break;
       case NEW_CONTENT_TAKES_PRIORITY:
-        mts.bin = mts.tree_bin[PENDING_TREE];
+        mts.bin = tree_bin[PENDING_TREE];
         gpu_memmgr_stats_bin = pending_bin;
         tile_priority = pending_priority;
         break;
     }
 
     if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
       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);
     }
 
     // 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 =
-        mts.tree_bin[ACTIVE_TREE] == NEVER_BIN &&
-        mts.tree_bin[PENDING_TREE] == NEVER_BIN;
+        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.time_to_needed_in_seconds = tile_priority.time_to_visible_in_seconds;
     mts.distance_to_visible_in_pixels =
         tile_priority.distance_to_visible_in_pixels;
     mts.required_for_activation = tile_priority.required_for_activation;
 
     mts.visible_and_ready_to_draw =
-        mts.tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
+        tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
 
     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
@@ skipping 384 matching lines @@
     decode_tasks.Insert(decode_task);
     existing_pixel_refs[id] = decode_task;
   }
 
   return RasterWorkerPool::CreateRasterTask(
       const_resource,
       tile->picture_pile(),
       tile->content_rect(),
       tile->contents_scale(),
       mts.raster_mode,
-      mts.tree_bin[PENDING_TREE] == NOW_BIN,
       mts.resolution,
       tile->layer_id(),
       static_cast<const void *>(tile),
       tile->source_frame_number(),
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile->id(),
                  base::Passed(&resource),
                  mts.raster_mode),
@@ skipping 87 matching lines @@
                                                          can_use_lcd_text));
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile;
   used_layer_counts_[tile->layer_id()]++;
   prioritized_tiles_dirty_ = true;
   return tile;
 }
 
 }  // namespace cc