Refactoring for merging ManagedTileState into Tile.

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 237 matching lines @@
     for (PictureLayerTilingSet::CoverageIterator iter(
              tilings_.get(),
              max_contents_scale,
              scaled_visible_content_rect,
              ideal_contents_scale_);
          iter;
          ++iter) {
       SkColor color;
       float width;
       if (*iter && iter->IsReadyToDraw()) {
-        ManagedTileState::DrawInfo::Mode mode = iter->draw_info().mode();
-        if (mode == ManagedTileState::DrawInfo::SOLID_COLOR_MODE) {
+        TileDrawInfo::Mode mode = iter->draw_info().mode();
+        if (mode == TileDrawInfo::SOLID_COLOR_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
-        } else if (mode == ManagedTileState::DrawInfo::PICTURE_PILE_MODE) {
+        } else if (mode == TileDrawInfo::PICTURE_PILE_MODE) {
           color = DebugColors::PictureTileBorderColor();
           width = DebugColors::PictureTileBorderWidth(layer_tree_impl());
         } else if (iter.resolution() == HIGH_RESOLUTION) {
           color = DebugColors::HighResTileBorderColor();
           width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
         } else if (iter.resolution() == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
           width = DebugColors::LowResTileBorderWidth(layer_tree_impl());
         } else if (iter->contents_scale() > max_contents_scale) {
           color = DebugColors::ExtraHighResTileBorderColor();
@@ skipping 43 matching lines @@
     gfx::Rect visible_geometry_rect =
         scaled_occlusion.GetUnoccludedContentRect(geometry_rect);
     if (visible_geometry_rect.IsEmpty())
       continue;
 
     append_quads_data->visible_content_area +=
         visible_geometry_rect.width() * visible_geometry_rect.height();
 
     bool has_draw_quad = false;
     if (*iter && iter->IsReadyToDraw()) {
-      const ManagedTileState::DrawInfo& draw_info = iter->draw_info();
+      const TileDrawInfo& draw_info = iter->draw_info();
       switch (draw_info.mode()) {
-        case ManagedTileState::DrawInfo::RESOURCE_MODE: {
+        case TileDrawInfo::RESOURCE_MODE: {
           gfx::RectF texture_rect = iter.texture_rect();
 
           // The raster_contents_scale_ is the best scale that the layer is
           // trying to produce, even though it may not be ideal. Since that's
           // the best the layer can promise in the future, consider those as
           // complete. But if a tile is ideal scale, we don't want to consider
           // it incomplete and trying to replace it with a tile at a worse
           // scale.
           if (iter->contents_scale() != raster_contents_scale_ &&
               iter->contents_scale() != ideal_contents_scale_ &&
               geometry_rect.Intersects(scaled_viewport_for_tile_priority)) {
             append_quads_data->num_incomplete_tiles++;
           }
 
           TileDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
           quad->SetNew(shared_quad_state,
                        geometry_rect,
                        opaque_rect,
                        visible_geometry_rect,
                        draw_info.get_resource_id(),
                        texture_rect,
                        iter.texture_size(),
                        draw_info.contents_swizzled(),
                        nearest_neighbor_);
           has_draw_quad = true;
           break;
         }
-        case ManagedTileState::DrawInfo::PICTURE_PILE_MODE: {
+        case TileDrawInfo::PICTURE_PILE_MODE: {
           if (!layer_tree_impl()
                    ->GetRendererCapabilities()
                    .allow_rasterize_on_demand) {
             ++on_demand_missing_tile_count;
             break;
           }
 
           gfx::RectF texture_rect = iter.texture_rect();
 
           ResourceProvider* resource_provider =
               layer_tree_impl()->resource_provider();
           ResourceFormat format =
               resource_provider->memory_efficient_texture_format();
           PictureDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
           quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
                        visible_geometry_rect, texture_rect, iter.texture_size(),
                        nearest_neighbor_, format, iter->content_rect(),
                        iter->contents_scale(), raster_source_);
           has_draw_quad = true;
           break;
         }
-        case ManagedTileState::DrawInfo::SOLID_COLOR_MODE: {
+        case TileDrawInfo::SOLID_COLOR_MODE: {
           SolidColorDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
           quad->SetNew(shared_quad_state,
                        geometry_rect,
                        visible_geometry_rect,
                        draw_info.get_solid_color(),
                        false);
           has_draw_quad = true;
           break;
         }
@@ skipping 392 matching lines @@
   if (!iter || !*iter) {
     *resource_id = 0;
     return;
   }
 
   // Masks only supported if they fit on exactly one tile.
   DCHECK(iter.geometry_rect() == content_rect)
       << "iter rect " << iter.geometry_rect().ToString() << " content rect "
       << content_rect.ToString();
 
-  const ManagedTileState::DrawInfo& draw_info = iter->draw_info();
+  const TileDrawInfo& draw_info = iter->draw_info();
   if (!draw_info.IsReadyToDraw() ||
-      draw_info.mode() != ManagedTileState::DrawInfo::RESOURCE_MODE) {
+      draw_info.mode() != TileDrawInfo::RESOURCE_MODE) {
     *resource_id = 0;
     return;
   }
 
   *resource_id = draw_info.get_resource_id();
   *resource_size = iter.texture_size();
 }
 
 void PictureLayerImpl::SetNearestNeighbor(bool nearest_neighbor) {
   if (nearest_neighbor_ == nearest_neighbor)
@@ skipping 519 matching lines @@
 
 bool PictureLayerImpl::AllTilesRequiredForDrawAreReadyToDraw() const {
   if (!layer_tree_impl()->IsActiveTree())
     return true;
 
   return AllTilesRequiredAreReadyToDraw(
       &PictureLayerTiling::IsTileRequiredForDrawIfVisible);
 }
 
 }  // namespace cc