cc: Do the math for a tile's content rect in layer space once.

cc/playback/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 <set>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/region.h"
@@ skipping 281 matching lines @@
   layer_rect.Intersect(gfx::Rect(tiling_.tiling_size()));
 
   skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
 
   RasterForAnalysis(&canvas, layer_rect, 1.0f);
 
   analysis->is_solid_color = canvas.GetColorIfSolid(&analysis->solid_color);
 }
 
 void PicturePileImpl::GatherPixelRefs(
-    const gfx::Rect& content_rect,
-    float contents_scale,
+    const gfx::Rect& layer_rect,
     std::vector<skia::PositionPixelRef>* pixel_refs) const {
   DCHECK_EQ(0u, pixel_refs->size());
-  for (PixelRefIterator iter(content_rect, contents_scale, this); iter;
-       ++iter) {
+  for (PixelRefIterator iter(layer_rect, this); iter; ++iter) {
     pixel_refs->push_back(*iter);
   }
 }
 
-bool PicturePileImpl::CoversRect(const gfx::Rect& content_rect,
-                                 float contents_scale) const {
+bool PicturePileImpl::CoversRect(const gfx::Rect& layer_rect) const {
   if (tiling_.tiling_size().IsEmpty())
     return false;
-  gfx::Rect layer_rect =
-      gfx::ScaleToEnclosingRect(content_rect, 1.f / contents_scale);
-  layer_rect.Intersect(gfx::Rect(tiling_.tiling_size()));
+  gfx::Rect bounded_rect = layer_rect;
+  bounded_rect.Intersect(gfx::Rect(tiling_.tiling_size()));
 
   // Common case inside of viewport to avoid the slower map lookups.
-  if (recorded_viewport_.Contains(layer_rect)) {
+  if (recorded_viewport_.Contains(bounded_rect)) {
     // Sanity check that there are no false positives in recorded_viewport_.
-    DCHECK(CanRasterSlowTileCheck(layer_rect));
+    DCHECK(CanRasterSlowTileCheck(bounded_rect));
     return true;
   }
 
-  return CanRasterSlowTileCheck(layer_rect);
+  return CanRasterSlowTileCheck(bounded_rect);
 }
 
 gfx::Size PicturePileImpl::GetSize() const {
   return tiling_.tiling_size();
 }
 
 bool PicturePileImpl::IsSolidColor() const {
   return is_solid_color_;
 }
 
@@ skipping 57 matching lines @@
 }
 
 scoped_refptr<RasterSource> PicturePileImpl::CreateCloneWithoutLCDText() const {
   DCHECK(CanUseLCDText());
   bool can_use_lcd_text = false;
   return scoped_refptr<RasterSource>(
       new PicturePileImpl(this, can_use_lcd_text));
 }
 
 PicturePileImpl::PixelRefIterator::PixelRefIterator(
-    const gfx::Rect& content_rect,
-    float contents_scale,
+    const gfx::Rect& layer_rect,
     const PicturePileImpl* picture_pile)
     : picture_pile_(picture_pile),
-      layer_rect_(
-          gfx::ScaleToEnclosingRect(content_rect, 1.f / contents_scale)),
+      layer_rect_(layer_rect),
       tile_iterator_(&picture_pile_->tiling_,
                      layer_rect_,
                      false /* include_borders */) {
   // Early out if there isn't a single tile.
   if (!tile_iterator_)
     return;
 
   AdvanceToTilePictureWithPixelRefs();
 }
 
@@ skipping 35 matching lines @@
   for (const auto& map_pair : picture_map_) {
     const Picture* picture = map_pair.second.get();
     if (processed_pictures.count(picture) == 0) {
       picture->EmitTraceSnapshot();
       processed_pictures.insert(picture);
     }
   }
 }
 
 }  // namespace cc