cc: Remove unnecessary "default" cases from switch statements.

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>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/tile.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
 namespace {
 
 // Memory limit policy works by mapping some bin states to the NEVER bin.
-const ManagedTileBin kBinPolicyMap[NUM_TILE_MEMORY_LIMIT_POLICIES][NUM_BINS] = {
+const ManagedTileBin
+    kBinPolicyMap[MAX_TILE_MEMORY_LIMIT_POLICY + 1][MAX_BIN + 1] = {

[enne (OOO), 2013/08/23 00:44:38]

Ugh.

I really don't like how awkward this makes enums that want to have a
NUM_THINGERS in them.  Is this really necessary?

   {  // [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                   // [NEVER_BIN]
   }, {  // [ALLOW_ABSOLUTE_MINIMUM]
     NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
@@ skipping 215 matching lines @@
   TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
 
   const TileMemoryLimitPolicy memory_policy = global_state_.memory_limit_policy;
   const TreePriority tree_priority = global_state_.tree_priority;
 
   // For each tree, bin into different categories of tiles.
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = it->second;
     ManagedTileState& mts = tile->managed_state();
 
-    TilePriority prio[NUM_BIN_PRIORITIES];
+    TilePriority prio[MAX_BIN_PRIORITY + 1];
     switch (tree_priority) {
       case SAME_PRIORITY_FOR_BOTH_TREES:
         prio[HIGH_PRIORITY_BIN] = prio[LOW_PRIORITY_BIN] =
             tile->combined_priority();
         break;
       case SMOOTHNESS_TAKES_PRIORITY:
         prio[HIGH_PRIORITY_BIN] = tile->priority(ACTIVE_TREE);
         prio[LOW_PRIORITY_BIN] = tile->priority(PENDING_TREE);
         break;
       case NEW_CONTENT_TAKES_PRIORITY:
@@ skipping 38 matching lines @@
                             tile_is_active);
     mts.tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
 
     ManagedTileBin pending_bin =
         BinFromTilePriority(tile->priority(PENDING_TREE),
                             tree_priority,
                             tile_is_ready_to_draw,
                             tile_is_active);
     mts.tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
 
-    for (int i = 0; i < NUM_BIN_PRIORITIES; ++i)
+    for (int i = 0; i <= MAX_BIN_PRIORITY; ++i)
       mts.bin[i] = kBinPolicyMap[memory_policy][mts.bin[i]];
 
     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()) {
       FreeResourcesForTile(tile);
       continue;
     }
 
@@ skipping 197 matching lines @@
     // If the tile is not needed, free it up.
     if (mts.is_in_never_bin_on_both_trees()) {
       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) {
+    for (int mode = 0; mode <= MAX_RASTER_MODE; ++mode) {
       if (mts.tile_versions[mode].resource_) {
         tile_bytes += tile->bytes_consumed_if_allocated();
         tile_resources++;
       }
     }
 
     // Allow lower priority tiles with initialized resources to keep
     // their memory by only assigning memory to new raster tasks if
     // they can be scheduled.
     if (tiles_that_need_to_be_rasterized->size() < kMaxRasterTasks) {
@@ skipping 97 matching lines @@
 
     DCHECK_GE(bytes_releasable_, tile->bytes_consumed_if_allocated());
     DCHECK_GE(resources_releasable_, 1u);
 
     bytes_releasable_ -= tile->bytes_consumed_if_allocated();
     --resources_releasable_;
   }
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
-  for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
+  for (int mode = 0; mode <= MAX_RASTER_MODE; ++mode) {
     FreeResourceForTile(tile, static_cast<RasterMode>(mode));
   }
 }
 
 void TileManager::FreeUnusedResourcesForTile(Tile* tile) {
   DCHECK(tile->IsReadyToDraw());
   ManagedTileState& mts = tile->managed_state();
   RasterMode used_mode = HIGH_QUALITY_NO_LCD_RASTER_MODE;
-  for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
+  for (int mode = 0; mode < MAX_RASTER_MODE; ++mode) {
     if (mts.tile_versions[mode].IsReadyToDraw()) {
       used_mode = static_cast<RasterMode>(mode);
       break;
     }
   }
 
-  for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
+  for (int mode = 0; mode < MAX_RASTER_MODE; ++mode) {
     if (mode != used_mode)
       FreeResourceForTile(tile, static_cast<RasterMode>(mode));
   }
 }
 
 void TileManager::ScheduleTasks(
     const TileVector& tiles_that_need_to_be_rasterized) {
   TRACE_EVENT1("cc", "TileManager::ScheduleTasks",
                "count", tiles_that_need_to_be_rasterized.size());
   RasterWorkerPool::RasterTask::Queue tasks;
@@ skipping 154 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