Fix GPUTiming offset so it is stable within significant digits.

ui/gl/gpu_timing.cc

 // Copyright (c) 2015 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 "ui/gl/gpu_timing.h"
 
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
@@ skipping 323 matching lines @@
     }
   }
   return disjoint_counter_;
 }
 
 int64_t GPUTimingImpl::CalculateTimerOffset() {
   if (!offset_valid_) {
     if (timer_type_ == GPUTiming::kTimerTypeDisjoint ||
         timer_type_ == GPUTiming::kTimerTypeARB) {
       GLint64 gl_now = 0;
       glGetInteger64v(GL_TIMESTAMP, &gl_now);

[Ken Russell (switch to Gerrit), 2016/01/29 22:54:31]

I've recently learned that this query returns 0 on Mac OS X. Can you confirm?
How does that affect the correctness of this code?

[David Yen, 2016/01/30 02:14:11]

So this would only apply to the core profile (compatibility profile doesn't
support ARB_timer_query, only EXT_timer_query). We would have to put in a work
around for this if that is the case, or simply disable ARB_timer_query. The only
advantage ARB_timer_query gives us over EXT_timer_query is timestamps so if this
gives us 0 there is really no point in using it.

-      int64_t micro_now = NanoToMicro(gl_now);
-      offset_ = GetCurrentCPUTime() - micro_now;
-      offset_valid_ = (timer_type_ == GPUTiming::kTimerTypeARB);
+      const int64_t cpu_time = GetCurrentCPUTime();
+
+      const int64_t micro_offset = cpu_time - NanoToMicro(gl_now);
+
+      // We cannot expect these instructions to run with the accuracy
+      // within 1 microsecond, round down to nearest milliseconds instead and
+      // only update if the difference is larger than 1 millisecond.
+      const int64_t rounded_offset =
+          (micro_offset / base::Time::kMicrosecondsPerMillisecond) *
+          base::Time::kMicrosecondsPerMillisecond;

[Ken Russell (switch to Gerrit), 2016/01/29 22:54:31]

Is there any way to use base::Time to do this rounding and these delta
computations instead of essentially duplicating the code?

[David Yen, 2016/01/30 02:14:11]

Done. This is much better now thank you.

+
+      const int64_t diff = rounded_offset - offset_;
+      const int64_t abs_diff = (diff < 0) ? -diff : diff;
+
+      if (abs_diff > 1) {
+        offset_ = rounded_offset;
+        offset_valid_ = (timer_type_ == GPUTiming::kTimerTypeARB);
+      }
     } else {
       offset_ = 0;
       offset_valid_ = true;
     }
   }
   return offset_;
 }
 
 scoped_refptr<QueryResult> GPUTimingImpl::BeginElapsedTimeQuery() {
   DCHECK(timer_type_ != GPUTiming::kTimerTypeInvalid);
@@ skipping 267 matching lines @@
 
 void GPUTimingClient::ForceTimeElapsedQuery() {
   DCHECK(gpu_timing_);
   gpu_timing_->ForceTimeElapsedQuery();
 }
 
 GPUTimingClient::~GPUTimingClient() {
 }
 
 }  // namespace gfx