cc: Remove separate x/y raster scales.

cc/tiles/picture_layer_tiling.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/tiles/picture_layer_tiling.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 11 matching lines @@
 #include "cc/tiles/prioritized_tile.h"
 #include "cc/tiles/tile.h"
 #include "cc/tiles/tile_priority.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
-namespace {
-// The math is similar to gfx::Rect::ManhattanInternalDistance except that each
-// component is scaled by the specified |scale|.
-float ComputeScaledManhattalInternalDistance(const gfx::Rect& a,
-                                             const gfx::Rect& b,
-                                             const gfx::SizeF& scale) {
-  gfx::Rect combined(a);
-  combined.Union(b);
-
-  float x =
-      scale.width() * std::max(0, combined.width() - a.width() - b.width() + 1);
-  float y = scale.height() *
-            std::max(0, combined.height() - a.height() - b.height() + 1);
-  return x + y;
-}
-}  // namespace
 
 PictureLayerTiling::PictureLayerTiling(
     WhichTree tree,
-    const gfx::SizeF& raster_scales,
+    float contents_scale,
     scoped_refptr<RasterSource> raster_source,
     PictureLayerTilingClient* client,
     float min_preraster_distance,
     float max_preraster_distance)
-    : raster_scales_(raster_scales),
+    : contents_scale_(contents_scale),
       client_(client),
       tree_(tree),
       raster_source_(raster_source),
       min_preraster_distance_(min_preraster_distance),
       max_preraster_distance_(max_preraster_distance) {
   DCHECK(!raster_source->IsSolidColor());
   gfx::Size content_bounds =
-      gfx::ScaleToCeiledSize(raster_source_->GetSize(), raster_scales_.width(),
-                             raster_scales_.height());
+      gfx::ScaleToCeiledSize(raster_source_->GetSize(), contents_scale_);
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
 
-  DCHECK(!gfx::ScaleToFlooredSize(raster_source_->GetSize(),
-                                  raster_scales_.width(),
-                                  raster_scales_.height())
+  DCHECK(!gfx::ScaleToFlooredSize(raster_source_->GetSize(), contents_scale_)
               .IsEmpty())
       << "Tiling created with scale too small as contents become empty."
       << " Layer bounds: " << raster_source_->GetSize().ToString()
-      << " Raster scales: " << raster_scales_.ToString();
+      << " Raster scale: " << contents_scale_;
 
   tiling_data_.SetTilingSize(content_bounds);
   tiling_data_.SetMaxTextureSize(tile_size);
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
 }
 
 Tile* PictureLayerTiling::CreateTile(const Tile::CreateInfo& info) {
   const int i = info.tiling_i_index;
@@ skipping 34 matching lines @@
       // If this is the pending tree, then the active twin tiling may contain
       // the previous content ID of these tiles. In that case, we need only
       // partially raster the tile content.
       if (tile && invalidation && TilingMatchesTileIndices(active_twin)) {
         if (const Tile* old_tile =
                 active_twin->TileAt(key.index_x, key.index_y)) {
           gfx::Rect tile_rect = tile->content_rect();
           gfx::Rect invalidated;
           for (Region::Iterator iter(*invalidation); iter.has_rect();
                iter.next()) {
-            gfx::Rect invalid_content_rect = gfx::ScaleToEnclosingRect(
-                iter.rect(), raster_scales_.width(), raster_scales_.height());
+            gfx::Rect invalid_content_rect =
+                gfx::ScaleToEnclosingRect(iter.rect(), contents_scale_);
             invalid_content_rect.Intersect(tile_rect);
             invalidated.Union(invalid_content_rect);
           }
           tile->SetInvalidated(invalidated, old_tile->id());
         }
       }
     }
   }
   VerifyLiveTilesRect(false);
 }
@@ skipping 38 matching lines @@
                        pending_twin->current_eventually_rect_,
                        pending_twin->current_occlusion_in_layer_space_);
 }
 
 void PictureLayerTiling::SetRasterSourceAndResize(
     scoped_refptr<RasterSource> raster_source) {
   DCHECK(!raster_source->IsSolidColor());
   gfx::Size old_layer_bounds = raster_source_->GetSize();
   raster_source_ = std::move(raster_source);
   gfx::Size new_layer_bounds = raster_source_->GetSize();
-  gfx::Size content_bounds = gfx::ScaleToCeiledSize(
-      new_layer_bounds, raster_scales_.width(), raster_scales_.height());
+  gfx::Size content_bounds =
+      gfx::ScaleToCeiledSize(new_layer_bounds, contents_scale_);
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
 
   if (tile_size != tiling_data_.max_texture_size()) {
     tiling_data_.SetTilingSize(content_bounds);
     tiling_data_.SetMaxTextureSize(tile_size);
     // When the tile size changes, the TilingData positions no longer work
     // as valid keys to the TileMap, so just drop all tiles and clear the live
     // tiles rect.
     Reset();
     return;
@@ skipping 73 matching lines @@
   // 16 is fast enough. If an invalidation is huge we will fall back to a
   // unordered_map instead of a vector in the SmallMap.
   base::SmallMap<std::unordered_map<TileMapKey, gfx::Rect, TileMapKeyHash>, 16>
       remove_tiles;
   gfx::Rect expanded_live_tiles_rect =
       tiling_data_.ExpandRectToTileBounds(live_tiles_rect_);
   for (Region::Iterator iter(layer_invalidation); iter.has_rect();
        iter.next()) {
     gfx::Rect layer_rect = iter.rect();
     // The pixels which are invalid in content space.
-    gfx::Rect invalid_content_rect = gfx::ScaleToEnclosingRect(
-        layer_rect, raster_scales_.width(), raster_scales_.height());
+    gfx::Rect invalid_content_rect =
+        gfx::ScaleToEnclosingRect(layer_rect, contents_scale_);
     gfx::Rect coverage_content_rect = invalid_content_rect;
     // Avoid needless work by not bothering to invalidate where there aren't
     // tiles.
     coverage_content_rect.Intersect(expanded_live_tiles_rect);
     if (coverage_content_rect.IsEmpty())
       continue;
     // Since the content_rect needs to invalidate things that only touch a
     // border of a tile, we need to include the borders while iterating.
     bool include_borders = true;
     for (TilingData::Iterator iter(&tiling_data_, coverage_content_rect,
@@ skipping 15 matching lines @@
       Tile::CreateInfo info = CreateInfoForTile(key.index_x, key.index_y);
       if (Tile* tile = CreateTile(info))
         tile->SetInvalidated(invalid_content_rect, old_tile->id());
     }
   }
 }
 
 Tile::CreateInfo PictureLayerTiling::CreateInfoForTile(int i, int j) const {
   gfx::Rect tile_rect = tiling_data_.TileBoundsWithBorder(i, j);
   tile_rect.set_size(tiling_data_.max_texture_size());
-  gfx::Rect enclosing_layer_rect = gfx::ScaleToEnclosingRect(
-      tile_rect, 1.f / raster_scales_.width(), 1.f / raster_scales_.height());
+  gfx::Rect enclosing_layer_rect =
+      gfx::ScaleToEnclosingRect(tile_rect, 1.f / contents_scale_);
   return Tile::CreateInfo(this, i, j, enclosing_layer_rect, tile_rect,
-                          raster_scales_);
+                          contents_scale_);
 }
 
 bool PictureLayerTiling::ShouldCreateTileAt(
     const Tile::CreateInfo& info) const {
   const int i = info.tiling_i_index;
   const int j = info.tiling_j_index;
   // Active tree should always create a tile. The reason for this is that active
   // tree represents content that we draw on screen, which means that whenever
   // we check whether a tile should exist somewhere, the answer is yes. This
   // doesn't mean it will actually be created (if raster source doesn't cover
@@ skipping 18 matching lines @@
   if (!active_twin->raster_source()->CoversRect(info.enclosing_layer_rect))
     return true;
 
   const Region* layer_invalidation = client_->GetPendingInvalidation();
 
   // If this tile is invalidated, then the pending tree should create one.
   // Do the intersection test in content space to match the corresponding check
   // on the active tree and avoid floating point inconsistencies.
   for (Region::Iterator iter(*layer_invalidation); iter.has_rect();
        iter.next()) {
-    gfx::Rect invalid_content_rect = gfx::ScaleToEnclosingRect(
-        iter.rect(), raster_scales_.width(), raster_scales_.height());
+    gfx::Rect invalid_content_rect =
+        gfx::ScaleToEnclosingRect(iter.rect(), contents_scale_);
     if (invalid_content_rect.Intersects(info.content_rect))
       return true;
   }
   // If the active tree doesn't have a tile here, but it's in the pending tree's
   // visible rect, then the pending tree should create a tile. This can happen
   // if the pending visible rect is outside of the active tree's live tiles
   // rect. In those situations, we need to block activation until we're ready to
   // display content, which will have to come from the pending tree.
   if (!active_twin->TileAt(i, j) &&
       current_visible_rect_.Intersects(info.content_rect))
@@ skipping 13 matching lines @@
 
 PictureLayerTiling::CoverageIterator::CoverageIterator(
     const PictureLayerTiling* tiling,
     float coverage_scale,
     const gfx::Rect& coverage_rect)
     : tiling_(tiling), coverage_rect_(coverage_rect) {
   DCHECK(tiling_);
   // In order to avoid artifacts in geometry_rect scaling and clamping to ints,
   // the |coverage_scale| should always be at least as big as the tiling's
   // raster scales.
-  DCHECK_GE(coverage_scale, tiling_->raster_scales_.width());
-  DCHECK_GE(coverage_scale, tiling_->raster_scales_.height());
+  DCHECK_GE(coverage_scale, tiling_->contents_scale_);
 
   // Clamp |coverage_rect| to the bounds of this tiling's raster source.
   coverage_rect_max_bounds_ =
       gfx::ScaleToCeiledSize(tiling->raster_source_->GetSize(), coverage_scale);
   coverage_rect_.Intersect(gfx::Rect(coverage_rect_max_bounds_));
   if (coverage_rect_.IsEmpty())
     return;
 
-  coverage_to_content_scale_ =
-      gfx::SizeF(tiling_->raster_scales_.width() / coverage_scale,
-                 tiling_->raster_scales_.height() / coverage_scale);
+  coverage_to_content_scale_ = tiling_->contents_scale_ / coverage_scale;
 
   // Find the indices of the texel samples that enclose the rect we want to
   // cover.
   // Because we don't know the target transform at this point, we have to be
   // pessimistic, i.e. assume every point (a pair of real number, not necessary
   // snapped to a pixel sample) inside of the content rect may be sampled.
   // This code maps the boundary points into contents space, then find out the
   // enclosing texture samples. For example, assume we have:
   // dest_scale : content_scale = 1.23 : 1
   // dest_rect = (l:123, t:234, r:345, b:456)
   // Then it follows that:
   // content_rect = (l:100.00, t:190.24, r:280.49, b:370.73)
   // Without MSAA, the sample point of a texel is at the center of that texel,
   // thus the sample points we need to cover content_rect are:
   // wanted_texels(sample coordinates) = (l:99.5, t:189.5, r:280.5, b:371.5)
   // Or in integer index:
   // wanted_texels(integer index) = (l:99, t:189, r:280, b:371)
-  gfx::RectF content_rect = gfx::ScaleRect(gfx::RectF(coverage_rect_),
-                                           coverage_to_content_scale_.width(),
-                                           coverage_to_content_scale_.height());
+  gfx::RectF content_rect =
+      gfx::ScaleRect(gfx::RectF(coverage_rect_), coverage_to_content_scale_);
   content_rect.Offset(-0.5f, -0.5f);
   gfx::Rect wanted_texels = gfx::ToEnclosingRect(content_rect);
 
   const TilingData& data = tiling_->tiling_data_;
   left_ = data.LastBorderTileXIndexFromSrcCoord(wanted_texels.x());
   top_ = data.LastBorderTileYIndexFromSrcCoord(wanted_texels.y());
   right_ = std::max(
       left_, data.FirstBorderTileXIndexFromSrcCoord(wanted_texels.right()));
   bottom_ = std::max(
       top_, data.FirstBorderTileYIndexFromSrcCoord(wanted_texels.bottom()));
@@ skipping 41 matching lines @@
     // error in both u/v axis can't exceed
     // 255 * (1 - (1 - 1/1024) * (1 - 1/1024)) ~= 0.498
     // i.e. The color value can never flip over a rounding threshold.
     constexpr float epsilon = 1.f / 1024.f;
     texel_extent.Inset(-epsilon, -epsilon);
   }
 
   // Convert texel_extent to coverage scale, which is what we have to report
   // geometry_rect in.
   current_geometry_rect_ = gfx::ToEnclosedRect(
-      gfx::ScaleRect(texel_extent, 1.f / coverage_to_content_scale_.width(),
-                     1.f / coverage_to_content_scale_.height()));
+      gfx::ScaleRect(texel_extent, 1.f / coverage_to_content_scale_));
   {
     // Adjust external edges to cover the whole layer in dest space.
     //
     // For external edges, extend the tile to scaled layer bounds. This is
     // needed to fully cover the coverage space because the sample extent
     // doesn't cover the last 0.5 texel to layer edge, and also the coverage
     // space can be rounded up for up to 1 pixel. This overhang will never be
     // sampled as the AA fragment shader clamps sample coordinate and
     // antialiasing itself.
     const TilingData& data = tiling_->tiling_data_;
@@ skipping 44 matching lines @@
 gfx::Rect PictureLayerTiling::CoverageIterator::geometry_rect() const {
   return current_geometry_rect_;
 }
 
 gfx::RectF PictureLayerTiling::CoverageIterator::texture_rect() const {
   auto tex_origin = gfx::PointF(
       tiling_->tiling_data_.TileBoundsWithBorder(tile_i_, tile_j_).origin());
 
   // Convert from dest space => content space => texture space.
   gfx::RectF texture_rect(current_geometry_rect_);
-  texture_rect.Scale(coverage_to_content_scale_.width(),
-                     coverage_to_content_scale_.height());
+  texture_rect.Scale(coverage_to_content_scale_);
   texture_rect.Intersect(gfx::RectF(gfx::SizeF(tiling_->tiling_size())));
   if (texture_rect.IsEmpty())
     return texture_rect;
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
 
   return texture_rect;
 }
 
 std::unique_ptr<Tile> PictureLayerTiling::TakeTileAt(int i, int j) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
@@ skipping 25 matching lines @@
     const gfx::Rect& eventually_rect_in_layer_space,
     float ideal_contents_scale,
     const Occlusion& occlusion_in_layer_space) {
   // If we have, or had occlusions, mark the tiles as 'not done' to ensure that
   // we reiterate the tiles for rasterization.
   if (occlusion_in_layer_space.HasOcclusion() ||
       current_occlusion_in_layer_space_.HasOcclusion()) {
     set_all_tiles_done(false);
   }
 
-  gfx::SizeF content_to_screen_scale(
-      ideal_contents_scale / raster_scales_.width(),
-      ideal_contents_scale / raster_scales_.height());
+  float content_to_screen_scale = ideal_contents_scale / contents_scale_;
 
   const gfx::Rect* input_rects[] = {
       &visible_rect_in_layer_space, &skewport_in_layer_space,
       &soon_border_rect_in_layer_space, &eventually_rect_in_layer_space};
   gfx::Rect output_rects[4];
   for (size_t i = 0; i < arraysize(input_rects); ++i) {
     output_rects[i] = gfx::ToEnclosingRect(
-        gfx::ScaleRect(gfx::RectF(*input_rects[i]), raster_scales_.width(),
-                       raster_scales_.height()));
+        gfx::ScaleRect(gfx::RectF(*input_rects[i]), contents_scale_));
   }
   // Make sure the eventually rect is aligned to tile bounds.
   output_rects[3] =
       tiling_data_.ExpandRectIgnoringBordersToTileBounds(output_rects[3]);
 
   SetTilePriorityRects(content_to_screen_scale, output_rects[0],
                        output_rects[1], output_rects[2], output_rects[3],
                        occlusion_in_layer_space);
   SetLiveTilesRect(output_rects[3]);
 }
 
 void PictureLayerTiling::SetTilePriorityRects(
-    const gfx::SizeF& content_to_screen_scale,
+    float content_to_screen_scale,
     const gfx::Rect& visible_rect_in_content_space,
     const gfx::Rect& skewport,
     const gfx::Rect& soon_border_rect,
     const gfx::Rect& eventually_rect,
     const Occlusion& occlusion_in_layer_space) {
   current_visible_rect_ = visible_rect_in_content_space;
   current_skewport_rect_ = skewport;
   current_soon_border_rect_ = soon_border_rect;
   current_eventually_rect_ = eventually_rect;
   current_occlusion_in_layer_space_ = occlusion_in_layer_space;
   current_content_to_screen_scale_ = content_to_screen_scale;
 
   gfx::Rect tiling_rect(tiling_size());
   has_visible_rect_tiles_ = tiling_rect.Intersects(current_visible_rect_);
   has_skewport_rect_tiles_ = tiling_rect.Intersects(current_skewport_rect_);
   has_soon_border_rect_tiles_ =
       tiling_rect.Intersects(current_soon_border_rect_);
   has_eventually_rect_tiles_ = tiling_rect.Intersects(current_eventually_rect_);
 
   // Note that we use the largest skewport extent from the viewport as the
   // "skewport extent". Also note that this math can't produce negative numbers,
   // since skewport.Contains(visible_rect) is always true.
-  max_skewport_extent_in_screen_space_ = std::max(
-      current_content_to_screen_scale_.width() *
-          std::max(
-              current_visible_rect_.x() - current_skewport_rect_.x(),
-              current_skewport_rect_.right() - current_visible_rect_.right()),
-      current_content_to_screen_scale_.height() *
-          std::max(current_visible_rect_.y() - current_skewport_rect_.y(),
-                   current_skewport_rect_.bottom() -
-                       current_visible_rect_.bottom()));
+  max_skewport_extent_in_screen_space_ =
+      current_content_to_screen_scale_ *
+      std::max(std::max(current_visible_rect_.x() - current_skewport_rect_.x(),
+                        current_skewport_rect_.right() -
+                            current_visible_rect_.right()),
+               std::max(current_visible_rect_.y() - current_skewport_rect_.y(),
+                        current_skewport_rect_.bottom() -
+                            current_visible_rect_.bottom()));
 }
 
 void PictureLayerTiling::SetLiveTilesRect(
     const gfx::Rect& new_live_tiles_rect) {
   DCHECK(new_live_tiles_rect.IsEmpty() ||
          gfx::Rect(tiling_size()).Contains(new_live_tiles_rect))
       << "tiling_size: " << tiling_size().ToString()
       << " new_live_tiles_rect: " << new_live_tiles_rect.ToString();
   if (live_tiles_rect_ == new_live_tiles_rect)
     return;
@@ skipping 80 matching lines @@
 bool PictureLayerTiling::IsTileOccludedOnCurrentTree(const Tile* tile) const {
   if (!current_occlusion_in_layer_space_.HasOcclusion())
     return false;
   gfx::Rect tile_query_rect =
       gfx::IntersectRects(tile->content_rect(), current_visible_rect_);
   // Explicitly check if the tile is outside the viewport. If so, we need to
   // return false, since occlusion for this tile is unknown.
   if (tile_query_rect.IsEmpty())
     return false;
 
-  if (raster_scales_ != gfx::SizeF(1.f, 1.f)) {
+  if (contents_scale_ != 1.f) {
     tile_query_rect =
-        gfx::ScaleToEnclosingRect(tile_query_rect, 1.f / raster_scales_.width(),
-                                  1.f / raster_scales_.height());
+        gfx::ScaleToEnclosingRect(tile_query_rect, 1.f / contents_scale_);
   }
   return current_occlusion_in_layer_space_.IsOccluded(tile_query_rect);
 }
 
 bool PictureLayerTiling::IsTileRequiredForActivation(const Tile* tile) const {
   if (tree_ == PENDING_TREE) {
     if (!can_require_tiles_for_activation_)
       return false;
 
     if (resolution_ != HIGH_RESOLUTION)
@@ skipping 61 matching lines @@
   DCHECK(tile);
   tile->set_required_for_activation(IsTileRequiredForActivation(tile));
   tile->set_required_for_draw(IsTileRequiredForDraw(tile));
 }
 
 PrioritizedTile PictureLayerTiling::MakePrioritizedTile(
     Tile* tile,
     PriorityRectType priority_rect_type) const {
   DCHECK(tile);
   DCHECK(raster_source()->CoversRect(tile->enclosing_layer_rect()))
-      << "Recording rect: "
-      << gfx::ScaleToEnclosingRect(tile->content_rect(),
-                                   1.f / tile->raster_scales().width(),
-                                   1.f / tile->raster_scales().height())
-             .ToString();
+      << "Tile layer rect: " << tile->enclosing_layer_rect().ToString();
 
   const auto& tile_priority = ComputePriorityForTile(tile, priority_rect_type);
   // Note that TileManager will consider this flag but may rasterize the tile
   // anyway (if tile is required for activation for example). We should process
   // the tile for images only if it's further than half of the skewport extent.
   bool process_for_images_only =
       tile_priority.distance_to_visible > min_preraster_distance_ &&
       (tile_priority.distance_to_visible > max_preraster_distance_ ||
        tile_priority.distance_to_visible >
            0.5f * max_skewport_extent_in_screen_space_);
@@ skipping 33 matching lines @@
       if (priority_bin < TilePriority::SOON)
         priority_bin = TilePriority::SOON;
       break;
     case EVENTUALLY_RECT:
       priority_bin = TilePriority::EVENTUALLY;
       break;
   }
 
   gfx::Rect tile_bounds =
       tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
-  DCHECK_GT(current_content_to_screen_scale_.width(), 0.f);
-  DCHECK_GT(current_content_to_screen_scale_.height(), 0.f);
-  float distance_to_visible = ComputeScaledManhattalInternalDistance(
-      current_visible_rect_, tile_bounds, current_content_to_screen_scale_);
+  DCHECK_GT(current_content_to_screen_scale_, 0.f);
+  float distance_to_visible =
+      current_content_to_screen_scale_ *
+      current_visible_rect_.ManhattanInternalDistance(tile_bounds);
 
   return TilePriority(resolution_, priority_bin, distance_to_visible);
 }
 
 PictureLayerTiling::PriorityRectType
 PictureLayerTiling::ComputePriorityRectTypeForTile(const Tile* tile) const {
   DCHECK_EQ(TileAt(tile->tiling_i_index(), tile->tiling_j_index()), tile);
   gfx::Rect tile_bounds =
       tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
 
@@ skipping 18 matching lines @@
   for (const auto& tile_pair : tiles_) {
     Tile* tile = tile_pair.second.get();
     prioritized_tiles->push_back(
         MakePrioritizedTile(tile, ComputePriorityRectTypeForTile(tile)));
   }
 }
 
 void PictureLayerTiling::AsValueInto(
     base::trace_event::TracedValue* state) const {
   state->SetInteger("num_tiles", base::saturated_cast<int>(tiles_.size()));
-  // TODO(vmpstr): Change frameviewer to use raster scales.
-  state->SetDouble("content_scale", contents_scale_key());
-
-  state->BeginArray("raster_scales");
-  state->AppendDouble(raster_scales_.width());
-  state->AppendDouble(raster_scales_.height());
-  state->EndArray();
+  state->SetDouble("content_scale", contents_scale());
 
   MathUtil::AddToTracedValue("visible_rect", current_visible_rect_, state);
   MathUtil::AddToTracedValue("skewport_rect", current_skewport_rect_, state);
   MathUtil::AddToTracedValue("soon_rect", current_soon_border_rect_, state);
   MathUtil::AddToTracedValue("eventually_rect", current_eventually_rect_,
                              state);
   MathUtil::AddToTracedValue("tiling_size", tiling_size(), state);
 }
 
 size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
   size_t amount = 0;
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     const Tile* tile = it->second.get();
     amount += tile->GPUMemoryUsageInBytes();
   }
   return amount;
 }
 
 }  // namespace cc