Use LapTimer in rasterize_and_record micro benchmark.

cc/debug/rasterize_and_record_benchmark.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.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
+#include "cc/debug/lap_timer.h"
 #include "cc/debug/rasterize_and_record_benchmark_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "ui/gfx/rect.h"
 
 namespace cc {
 
 namespace {
 
 const int kDefaultRecordRepeatCount = 100;
 
+// Parameters for LapTimer.
+const int kTimeLimitMillis = 1;
+const int kWarmupRuns = 0;
+const int kTimeCheckInterval = 1;
+
 const char* kModeSuffixes[Picture::RECORDING_MODE_COUNT] = {
     "", "_sk_null_canvas", "_painting_disabled", "_skrecord"};
 
-base::TimeTicks Now() {
-  return base::TimeTicks::IsThreadNowSupported()
-             ? base::TimeTicks::ThreadNow()
-             : base::TimeTicks::HighResNow();
-}
-
 }  // namespace
 
 RasterizeAndRecordBenchmark::RasterizeAndRecordBenchmark(
     scoped_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback)
     : MicroBenchmark(callback),
       record_repeat_count_(kDefaultRecordRepeatCount),
       settings_(value.Pass()),
       main_thread_benchmark_done_(false),
       host_(NULL),
@@ skipping 68 matching lines @@
   gfx::Rect visible_content_rect = gfx::ScaleToEnclosingRect(
       layer->visible_content_rect(), 1.f / layer->contents_scale_x());
   if (visible_content_rect.IsEmpty())
     return;
 
   for (int mode_index = 0; mode_index < Picture::RECORDING_MODE_COUNT;
        mode_index++) {
     Picture::RecordingMode mode =
         static_cast<Picture::RecordingMode>(mode_index);
     base::TimeDelta min_time = base::TimeDelta::Max();
+    LapTimer timer(kWarmupRuns,

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

Can you move the LapTimer constant declarations down here? 

+                   base::TimeDelta::FromMilliseconds(kTimeLimitMillis),

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

And this could go inside the for loop?

+                   kTimeCheckInterval);
     for (int i = 0; i < record_repeat_count_; ++i) {
-      base::TimeTicks start = Now();
-      scoped_refptr<Picture> picture = Picture::Create(
-          visible_content_rect, painter, tile_grid_info, false, 0, mode);
-      base::TimeTicks end = Now();
-      base::TimeDelta duration = end - start;
+      // Run for a minimum amount of time to avoid problems with timer
+      // quantization when the layer is very small.
+      timer.Reset();
+      do {
+        scoped_refptr<Picture> picture = Picture::Create(
+            visible_content_rect, painter, tile_grid_info, false, 0, mode);
+        timer.NextLap();
+      } while (!timer.HasTimeLimitExpired());
+      base::TimeDelta duration =
+          base::TimeDelta::FromMillisecondsD(timer.MsPerLap());
       if (duration < min_time)
         min_time = duration;
     }
 
     if (mode == Picture::RECORD_NORMALLY) {
       record_results_.pixels_recorded +=
           visible_content_rect.width() * visible_content_rect.height();
     }
     record_results_.total_best_time[mode_index] += min_time;
   }
 }
 
 RasterizeAndRecordBenchmark::RecordResults::RecordResults()
     : pixels_recorded(0) {}
 
 RasterizeAndRecordBenchmark::RecordResults::~RecordResults() {}
 
 }  // namespace cc