cc: Give TilingData back a Size instead of a Rect.

cc/resources/picture_pile_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 <algorithm>
 #include <limits>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/region.h"
 #include "cc/debug/debug_colors.h"
@@ skipping 95 matching lines @@
 
   // If this picture has opaque contents, it is guaranteeing that it will
   // draw an opaque rect the size of the layer.  If it is not, then we must
   // clear this canvas ourselves.
   if (contents_opaque_ || contents_fill_bounds_completely_) {
     // Even if completely covered, for rasterizations that touch the edge of the
     // layer, we also need to raster the background color underneath the last
     // texel (since the recording won't cover it) and outside the last texel
     // (due to linear filtering when using this texture).
     gfx::Rect content_tiling_rect = gfx::ToEnclosingRect(
-        gfx::ScaleRect(tiling_.tiling_rect(), contents_scale));
+        gfx::ScaleRect(gfx::Rect(tiling_.tiling_size()), contents_scale));
 
     // The final texel of content may only be partially covered by a
     // rasterization; this rect represents the content rect that is fully
     // covered by content.
     gfx::Rect deflated_content_tiling_rect = content_tiling_rect;
     deflated_content_tiling_rect.Inset(0, 0, 1, 1);
     if (!deflated_content_tiling_rect.Contains(canvas_rect)) {
       if (clear_canvas_with_debug_color_) {
         // Any non-painted areas outside of the content bounds are left in
         // this color.  If this is seen then it means that cc neglected to
@@ skipping 135 matching lines @@
     SkCanvas* canvas,
     SkDrawPictureCallback* callback,
     const gfx::Rect& canvas_rect,
     float contents_scale,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     bool is_analysis) {
   DCHECK(contents_scale >= min_contents_scale_);
 
   canvas->translate(-canvas_rect.x(), -canvas_rect.y());
   gfx::Rect content_tiling_rect = gfx::ToEnclosingRect(
-      gfx::ScaleRect(tiling_.tiling_rect(), contents_scale));
+      gfx::ScaleRect(gfx::Rect(tiling_.tiling_size()), contents_scale));
   content_tiling_rect.Intersect(canvas_rect);
 
   canvas->clipRect(gfx::RectToSkRect(content_tiling_rect),
                    SkRegion::kIntersect_Op);
 
   PictureRegionMap picture_region_map;
   CoalesceRasters(
       canvas_rect, content_tiling_rect, contents_scale, &picture_region_map);
 
 #ifndef NDEBUG
@@ skipping 55 matching lines @@
     canvas->clipRect(gfx::RectToSkRect(it.rect()), SkRegion::kDifference_Op);
   paint.setColor(DebugColors::MissingPictureFillColor());
   paint.setXfermodeMode(SkXfermode::kSrc_Mode);
   canvas->drawPaint(paint);
 #endif  // NDEBUG
 }
 
 skia::RefPtr<SkPicture> PicturePileImpl::GetFlattenedPicture() {
   TRACE_EVENT0("cc", "PicturePileImpl::GetFlattenedPicture");
 
-  gfx::Rect tiling_rect(tiling_.tiling_rect());
+  gfx::Rect tiling_rect(tiling_.tiling_size());
   SkPictureRecorder recorder;
   SkCanvas* canvas =
       recorder.beginRecording(tiling_rect.width(), tiling_rect.height());
   if (!tiling_rect.IsEmpty())
     RasterToBitmap(canvas, tiling_rect, 1.0, NULL);
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
 
   return picture;
 }
 
 void PicturePileImpl::AnalyzeInRect(
     const gfx::Rect& content_rect,
     float contents_scale,
     PicturePileImpl::Analysis* analysis) {
   AnalyzeInRect(content_rect, contents_scale, analysis, NULL);
 }
 
 void PicturePileImpl::AnalyzeInRect(
     const gfx::Rect& content_rect,
     float contents_scale,
     PicturePileImpl::Analysis* analysis,
     RenderingStatsInstrumentation* stats_instrumentation) {
   DCHECK(analysis);
   TRACE_EVENT0("cc", "PicturePileImpl::AnalyzeInRect");
 
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
       content_rect, 1.0f / contents_scale);
 
-  layer_rect.Intersect(tiling_.tiling_rect());
+  layer_rect.Intersect(gfx::Rect(tiling_.tiling_size()));
 
   skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
 
   RasterForAnalysis(&canvas, layer_rect, 1.0f, stats_instrumentation);
 
   analysis->is_solid_color = canvas.GetColorIfSolid(&analysis->solid_color);
 }
 
 // Since there are situations when we can skip analysis, the variables have to
 // be set to their safest values. That is, we have to assume that the tile is
@@ skipping 62 matching lines @@
        ++it) {
     Picture* picture = it->second.GetPicture();
     if (picture && (processed_pictures.count(picture) == 0)) {
       picture->EmitTraceSnapshot();
       processed_pictures.insert(picture);
     }
   }
 }
 
 }  // namespace cc