[6/6] git cl format

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 363 matching lines @@
   return tiling_data_.max_texture_size() ==
          twin->tiling_data_.max_texture_size();
 }
 
 PictureLayerTiling::CoverageIterator::CoverageIterator() = default;
 
 PictureLayerTiling::CoverageIterator::CoverageIterator(
     const PictureLayerTiling* tiling,
     float coverage_scale,
     const gfx::Rect& coverage_rect)
-    : tiling_(tiling)
-    , coverage_rect_(coverage_rect)
-    , coverage_to_content_(ScaleTranslate2d::PreScale(tiling->raster_transform(), 1.f / coverage_scale)) {
+    : tiling_(tiling),
+      coverage_rect_(coverage_rect),
+      coverage_to_content_(
+          ScaleTranslate2d::PreScale(tiling->raster_transform(),
+                                     1.f / coverage_scale)) {
   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_transform_.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;
 
   // 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:
   // coverage_scale : content_scale = 1.23 : 1
   // coverage_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 = coverage_to_content_.TransformRect(gfx::RectF(coverage_rect_));
+  gfx::RectF content_rect =
+      coverage_to_content_.TransformRect(gfx::RectF(coverage_rect_));
   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 509 matching lines @@
   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;
 }
 
 gfx::Rect PictureLayerTiling::EnclosingContentsRectFromLayerRect(
     const gfx::Rect& layer_rect) const {
-  return ToEnclosingRect(raster_transform_.TransformRect(gfx::RectF(layer_rect)));
+  return ToEnclosingRect(
+      raster_transform_.TransformRect(gfx::RectF(layer_rect)));
 }
 
 gfx::Rect PictureLayerTiling::EnclosingLayerRectFromContentsRect(
     const gfx::Rect& contents_rect) const {
   return ToEnclosingRect(
       raster_transform_.TransformRectReverse(gfx::RectF(contents_rect)));
 }
 
 }  // namespace cc