cpplint.py pass on cc/(base|debug|quads|resources)/

cc/resources/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/resources/picture_layer_tiling.h"
 
+#include <algorithm>
 #include <cmath>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/safe_integer_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
@@ skipping 107 matching lines @@
     CreateTilesFromLayerRect(iter.rect());
   }
 }
 
 void PictureLayerTiling::Invalidate(const Region& layer_invalidation) {
   std::vector<TileMapKey> new_tiles;
 
   for (Region::Iterator region_iter(layer_invalidation);
        region_iter.has_rect();
        region_iter.next()) {
-
     gfx::Rect layer_invalidation = region_iter.rect();
     layer_invalidation.Intersect(gfx::Rect(layer_bounds_));
     gfx::Rect rect =
         gfx::ToEnclosingRect(ScaleRect(layer_invalidation, contents_scale_));
 
     for (PictureLayerTiling::Iterator tile_iter(this, contents_scale_, rect);
          tile_iter;
          ++tile_iter) {
       TileMapKey key(tile_iter.tile_i_, tile_iter.tile_j_);
       TileMap::iterator found = tiles_.find(key);
@@ skipping 243 matching lines @@
     tile->SetPriority(tree, priority);
   }
   last_prioritized_rect_ = prioritized_rect;
 
   gfx::Rect view_rect(device_viewport);
   float current_scale = current_layer_contents_scale / contents_scale_;
   float last_scale = last_layer_contents_scale / contents_scale_;
 
   // Fast path tile priority calculation when both transforms are translations.
   if (last_screen_transform.IsIdentityOrTranslation() &&
-      current_screen_transform.IsIdentityOrTranslation())
-  {
+      current_screen_transform.IsIdentityOrTranslation()) {
     gfx::Vector2dF current_offset(
         current_screen_transform.matrix().get(0, 3),
         current_screen_transform.matrix().get(1, 3));
     gfx::Vector2dF last_offset(
         last_screen_transform.matrix().get(0, 3),
         last_screen_transform.matrix().get(1, 3));
 
     for (TilingData::Iterator iter(&tiling_data_, prioritized_rect);
          iter; ++iter) {
       TileMap::iterator find = tiles_.find(iter.index());
@@ skipping 106 matching lines @@
   int* num_edges;
   int distance;
 };
 
 gfx::Rect PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
     gfx::Rect starting_rect,
     int64 target_area,
     gfx::Rect bounding_rect) {
   DCHECK(!starting_rect.IsEmpty());
   DCHECK(!bounding_rect.IsEmpty());
-  DCHECK(target_area > 0);
+  DCHECK_GT(target_area, 0);
 
   gfx::Rect rect = IntersectRects(starting_rect, bounding_rect);
   if (rect.IsEmpty())
     return rect;
 
   // These values will be updated by the loop and uses as the output.
   int origin_x = rect.x();
   int origin_y = rect.y();
   int width = rect.width();
   int height = rect.height();
@@ skipping 66 matching lines @@
 
     // If our delta is less then our event distance, we're done.
     if (delta < event.distance)
       break;
   }
 
   return gfx::Rect(origin_x, origin_y, width, height);
 }
 
 }  // namespace cc