1 files changed, 36 insertions, 13 deletions

diff --git a/chrome/test/perf/rendering/latency_tests.cc b/chrome/test/perf/rendering/latency_tests.cc
index 1dacbf0..323830e 100644
--- a/chrome/test/perf/rendering/latency_tests.cc
+++ b/chrome/test/perf/rendering/latency_tests.cc
@@ -468,7 +468,7 @@ double LatencyTest::CalculateLatency() {
   int swap_count = 0;
   size_t previous_blit_pos = 0;
   swap_count = 0;
-  std::vector<int> latencies;
+  std::vector<double> latencies;
   printf("Measured latency (in number of frames) for each frame:\n");
   for (size_t i = 0; i < events.size(); ++i) {
     if (query_end_swaps_.Evaluate(*events[i])) {
@@ -523,20 +523,40 @@ double LatencyTest::CalculateLatency() {
                                &input_pos));
 
         // Step 4: Find the nearest onscreen SwapBuffers to this input event.
-        size_t closest_swap_to_input = 0;
-        size_t second_closest_swap = 0;
-        EXPECT_TRUE(FindClosest(events, query_end_swaps_, input_pos,
-                                &closest_swap_to_input, &second_closest_swap));
+        size_t end_swap_left = 0;
+        size_t end_swap_right = 0;
+        EXPECT_TRUE(FindLastOf(events, query_end_swaps_, input_pos,
+                               &end_swap_left));
+        EXPECT_TRUE(FindFirstOf(events, query_end_swaps_, input_pos,
+                                &end_swap_right));
+
+        EXPECT_LT(end_swap_left, input_pos);
+        EXPECT_LT(end_swap_left, end_swap_right);
+        EXPECT_LT(input_pos, end_swap_right);
+
+        // Calculate the fraction of the first frame from the input event to the
+        // next end_swap event: (right_swap - left_swap) / (right_swap - input).
+        double frame_time = (events[end_swap_right]->timestamp -
+                             events[end_swap_left]->timestamp);
+        double input_time = (events[end_swap_right]->timestamp -
+                             events[input_pos]->timestamp);
+        double latency_frame_fraction = input_time / frame_time;
+
+        EXPECT_LE(latency_frame_fraction, 1.0);
 
         // Calculate latency by counting the number of swaps between the input
         // event and the corresponding on-screen end-of-swap.
-        int latency = CountMatches(events, query_end_swaps_,
-                                   closest_swap_to_input, end_swap_pos);
-        latencies.push_back(latency);
+        int latency_int = CountMatches(events, query_end_swaps_,
+                                       input_pos, end_swap_pos);
+
+        double latency_frames = static_cast<double>(latency_int) +
+                                latency_frame_fraction;
+        latencies.push_back(latency_frames);
         if (verbose_)
-          printf(" %03d: %d\n", swap_count, latency);
+          printf(" %03d: %0.1f (int %d, frac %f)\n", swap_count, latency_frames,
+                 latency_int, latency_frame_fraction);
         else
-          printf(" %d", latency);
+          printf(" %0.1f", latency_frames);
       }
     }
   }
@@ -553,13 +573,13 @@ double LatencyTest::CalculateLatency() {
   // Skip last few frames, because they may be unreliable.
   size_t num_consider = latencies.size() - ignoreEndFrames;
   for (size_t i = 0; i < num_consider; ++i)
-    mean_latency += static_cast<double>(latencies[i]);
+    mean_latency += latencies[i];
   mean_latency /= static_cast<double>(num_consider);
   printf("Mean latency = %f\n", mean_latency);
 
   double mean_error = 0.0;
   for (size_t i = 0; i < num_consider; ++i) {
-    double offset = fabs(mean_latency - static_cast<double>(latencies[i]));
+    double offset = fabs(mean_latency - latencies[i]);
     mean_error = (offset > mean_error) ? offset : mean_error;
   }
 
@@ -615,7 +635,10 @@ void LatencyTest::GetMeanFrameTimeMicros(int* frame_time) const {
   // Search for compositor swaps (or UpdateRects in the software path).
   analyzer_->FindEvents(query_end_swaps_, &events);
   RateStats stats;
-  ASSERT_TRUE(GetRateStats(events, &stats, NULL));
+  trace_analyzer::RateStatsOptions options;
+  options.trim_max = 3;
+  options.trim_min = 3;
+  ASSERT_TRUE(GetRateStats(events, &stats, &options));
 
   // Check that the number of swaps is close to kNumFrames.
   EXPECT_LT(num_frames_ - num_frames_ / 4, static_cast<int>(events.size()));