Use LapTimer in rasterize_and_record micro benchmark.

cc/debug/rasterize_and_record_benchmark_impl.cc

 // Copyright 2013 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/debug/rasterize_and_record_benchmark_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/values.h"
+#include "cc/debug/lap_timer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "ui/gfx/rect.h"
 
 namespace cc {
 
 namespace {
 
 const int kDefaultRasterizeRepeatCount = 100;
 
-base::TimeTicks Now() {
-  return base::TimeTicks::IsThreadNowSupported()
-             ? base::TimeTicks::ThreadNow()
-             : base::TimeTicks::HighResNow();
-}
+// Parameters for LapTimer.
+const int kTimeLimitMillis = 1;
+const int kWarmupRuns = 0;
+const int kTimeCheckInterval = 1;
 
 class BenchmarkRasterTask : public Task {
  public:
   BenchmarkRasterTask(PicturePileImpl* picture_pile,
                       const gfx::Rect& content_rect,
                       float contents_scale,
                       size_t repeat_count)
       : picture_pile_(picture_pile),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         repeat_count_(repeat_count),
         is_solid_color_(false),
         best_time_(base::TimeDelta::Max()) {}
 
   // Overridden from Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     PicturePileImpl* picture_pile = picture_pile_->GetCloneForDrawingOnThread(
         RasterWorkerPool::GetPictureCloneIndexForCurrentThread());
 

[danakj, 2014/05/12 17:16:41]

Can you move the LapTimer constant declarations down here?

+    LapTimer timer(kWarmupRuns,

[danakj, 2014/05/12 17:16:41]

This could go inside he for loop?

+                   base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
+                   kTimeCheckInterval);
     for (size_t i = 0; i < repeat_count_; ++i) {
-      SkBitmap bitmap;
-      bitmap.allocPixels(SkImageInfo::MakeN32Premul(content_rect_.width(),
-                                                    content_rect_.height()));
-      SkCanvas canvas(bitmap);
-      PicturePileImpl::Analysis analysis;
+      // Run for a minimum amount of time to avoid problems with timer
+      // quantization when the layer is very small.
+      timer.Reset();
+      do {
+        SkBitmap bitmap;
+        bitmap.allocPixels(SkImageInfo::MakeN32Premul(content_rect_.width(),
+                                                      content_rect_.height()));
+        SkCanvas canvas(bitmap);
+        PicturePileImpl::Analysis analysis;
 
-      base::TimeTicks start = Now();
-      picture_pile->AnalyzeInRect(
-          content_rect_, contents_scale_, &analysis, NULL);
-      picture_pile->RasterToBitmap(
-          &canvas, content_rect_, contents_scale_, NULL);
-      base::TimeTicks end = Now();
-      base::TimeDelta duration = end - start;
+        picture_pile->AnalyzeInRect(
+            content_rect_, contents_scale_, &analysis, NULL);
+        picture_pile->RasterToBitmap(
+            &canvas, content_rect_, contents_scale_, NULL);
+
+        is_solid_color_ = analysis.is_solid_color;
+
+        timer.NextLap();
+      } while (!timer.HasTimeLimitExpired());
+      base::TimeDelta duration =
+          base::TimeDelta::FromMillisecondsD(timer.MsPerLap());
       if (duration < best_time_)
         best_time_ = duration;
 
-      is_solid_color_ = analysis.is_solid_color;
     }
   }
 
   bool IsSolidColor() const { return is_solid_color_; }
   base::TimeDelta GetBestTime() const { return best_time_; }
 
  private:
   virtual ~BenchmarkRasterTask() {}
 
   PicturePileImpl* picture_pile_;
@@ skipping 127 matching lines @@
       pixels_rasterized_with_non_solid_color(0),
       pixels_rasterized_as_opaque(0),
       total_layers(0),
       total_picture_layers(0),
       total_picture_layers_with_no_content(0),
       total_picture_layers_off_screen(0) {}
 
 RasterizeAndRecordBenchmarkImpl::RasterizeResults::~RasterizeResults() {}
 
 }  // namespace cc