cc: Refactor in picture_pile.cc

cc/resources/picture_pile.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_pile.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "cc/base/region.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "cc/resources/tile_priority.h"
 
+namespace cc {

[enne (OOO), 2014/07/09 17:38:34]

No need for this.  These are all local to this file.

[hyunki, 2014/07/09 17:47:26]

Done.

+
 namespace {
 // Layout pixel buffer around the visible layer rect to record.  Any base
 // picture that intersects the visible layer rect expanded by this distance
 // will be recorded.
 const int kPixelDistanceToRecord = 8000;
 
 // TODO(humper): The density threshold here is somewhat arbitrary; need a
 // way to set // this from the command line so we can write a benchmark
 // script and find a sweet spot.
 const float kDensityThreshold = 0.5f;
 
-bool rect_sort_y(const gfx::Rect &r1, const gfx::Rect &r2) {

[enne (OOO), 2014/07/09 17:38:34]

This name is also correct.  No need to rename it.

[hyunki, 2014/07/09 17:47:26]

Done.

+bool SortRectY(const gfx::Rect& r1, const gfx::Rect& r2) {
   return r1.y() < r2.y() || (r1.y() == r2.y() && r1.x() < r2.x());
 }
 
-bool rect_sort_x(const gfx::Rect &r1, const gfx::Rect &r2) {
+bool SortRectX(const gfx::Rect& r1, const gfx::Rect& r2) {
   return r1.x() < r2.x() || (r1.x() == r2.x() && r1.y() < r2.y());
 }
 
-float do_clustering(const std::vector<gfx::Rect>& tiles,
-                    std::vector<gfx::Rect>* clustered_rects) {
+float PerformClustering(const std::vector<gfx::Rect>& tiles,
+                        std::vector<gfx::Rect>* clustered_rects) {
   // These variables track the record area and invalid area
   // for the entire clustering
   int total_record_area = 0;
   int total_invalid_area = 0;
 
   // These variables track the record area and invalid area
   // for the current cluster being constructed.
   gfx::Rect cur_record_rect;
   int cluster_record_area = 0, cluster_invalid_area = 0;
 
@@ skipping 34 matching lines @@
   }
 
   DCHECK(!cur_record_rect.IsEmpty());
   clustered_rects->push_back(cur_record_rect);
   total_record_area += cluster_record_area;;
 
   DCHECK_NE(total_record_area, 0);
 
   return static_cast<float>(total_invalid_area) /
          static_cast<float>(total_record_area);
-  }
+}
 
 float ClusterTiles(const std::vector<gfx::Rect>& invalid_tiles,
                    std::vector<gfx::Rect>* record_rects) {
   TRACE_EVENT1("cc", "ClusterTiles",
                "count",
                invalid_tiles.size());
 
   if (invalid_tiles.size() <= 1) {
     // Quickly handle the special case for common
     // single-invalidation update, and also the less common
     // case of no tiles passed in.
     *record_rects = invalid_tiles;
     return 1;
   }
 
   // Sort the invalid tiles by y coordinate.
   std::vector<gfx::Rect> invalid_tiles_vertical = invalid_tiles;
   std::sort(invalid_tiles_vertical.begin(),
             invalid_tiles_vertical.end(),
-            rect_sort_y);
+            SortRectY);
 
   float vertical_density;
   std::vector<gfx::Rect> vertical_clustering;
-  vertical_density = do_clustering(invalid_tiles_vertical,
-                                   &vertical_clustering);
+  vertical_density = PerformClustering(invalid_tiles_vertical,
+                                       &vertical_clustering);
 
   // Now try again with a horizontal sort, see which one is best
   // TODO(humper): Heuristics for skipping this step?
   std::vector<gfx::Rect> invalid_tiles_horizontal = invalid_tiles;
   std::sort(invalid_tiles_vertical.begin(),
             invalid_tiles_vertical.end(),
-            rect_sort_x);
+            SortRectX);
 
   float horizontal_density;
   std::vector<gfx::Rect> horizontal_clustering;
-  horizontal_density = do_clustering(invalid_tiles_vertical,
-                                     &horizontal_clustering);
+  horizontal_density = PerformClustering(invalid_tiles_vertical,
+                                         &horizontal_clustering);
 
   if (vertical_density < horizontal_density) {
     *record_rects = horizontal_clustering;
     return horizontal_density;
   }
 
   *record_rects = vertical_clustering;
   return vertical_density;
 }
 
 }  // namespace
 
-namespace cc {
-
 PicturePile::PicturePile() : is_suitable_for_gpu_rasterization_(true) {}
 
 PicturePile::~PicturePile() {
 }
 
 bool PicturePile::UpdateAndExpandInvalidation(
     ContentLayerClient* painter,
     Region* invalidation,
     SkColor background_color,
     bool contents_opaque,
@@ skipping 150 matching lines @@
     }
     DCHECK(found_tile_for_recorded_picture);
   }
 
   has_any_recordings_ = true;
   DCHECK(CanRasterSlowTileCheck(recorded_viewport_));
   return true;
 }
 
 }  // namespace cc