cc: Add DEFINE_ENUM macro.

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
+    [TileMemoryLimitPolicy_ARRAYSIZE][ManagedTileBin_ARRAYSIZE] = {
   {  // [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 489 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 < RasterMode_ARRAYSIZE; ++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 < RasterMode_ARRAYSIZE; ++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 < RasterMode_ARRAYSIZE; ++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 < RasterMode_ARRAYSIZE; ++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