Chromium roll (https://codereview.chromium.org/976353002)

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/time/time.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_version_info.h"
@@ skipping 12 matching lines @@
   }
 }
 
 GPUTiming::~GPUTiming() {
 }
 
 scoped_refptr<GPUTimingClient> GPUTiming::CreateGPUTimingClient() {
   return new GPUTimingClient(this);
 }
 
+uint32_t GPUTiming::GetDisjointCount() {
+  if (timer_type_ == kTimerTypeDisjoint) {
+    GLint disjoint_value = 0;
+    glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint_value);
+    if (disjoint_value) {
+      disjoint_counter_++;
+    }
+  }
+  return disjoint_counter_;
+}
+
 GPUTimer::~GPUTimer() {
   glDeleteQueriesARB(2, queries_);
 }
 
 void GPUTimer::Start() {
   // GL_TIMESTAMP and GL_TIMESTAMP_EXT both have the same value.
   glQueryCounter(queries_[0], GL_TIMESTAMP);
 }
 
 void GPUTimer::End() {
@@ skipping 37 matching lines @@
     : gpu_timing_client_(gpu_timing_client) {
   DCHECK(gpu_timing_client_);
   memset(queries_, 0, sizeof(queries_));
   glGenQueriesARB(2, queries_);
 }
 
 GPUTimingClient::GPUTimingClient(GPUTiming* gpu_timing)
     : gpu_timing_(gpu_timing) {
   if (gpu_timing) {
     timer_type_ = gpu_timing->GetTimerType();
+    disjoint_counter_ = gpu_timing_->GetDisjointCount();
   }
 }
 
 scoped_ptr<GPUTimer> GPUTimingClient::CreateGPUTimer() {
   return make_scoped_ptr(new GPUTimer(this));
 }
 
 bool GPUTimingClient::IsAvailable() {
   return timer_type_ != GPUTiming::kTimerTypeInvalid;
 }
 
 const char* GPUTimingClient::GetTimerTypeName() const {
   switch (timer_type_) {
     case GPUTiming::kTimerTypeDisjoint:
       return "GL_EXT_disjoint_timer_query";
     case GPUTiming::kTimerTypeARB:
       return "GL_ARB_timer_query";
     default:
       return "Unknown";
   }
 }
 
 bool GPUTimingClient::CheckAndResetTimerErrors() {
   if (timer_type_ == GPUTiming::kTimerTypeDisjoint) {
-    GLint disjoint_value = 0;
-    glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint_value);
-    return disjoint_value != 0;
-  } else {
-    return false;
+    DCHECK(gpu_timing_ != nullptr);
+    const uint32_t total_disjoint_count = gpu_timing_->GetDisjointCount();
+    const bool disjoint_triggered = total_disjoint_count != disjoint_counter_;
+    disjoint_counter_ = total_disjoint_count;
+    return disjoint_triggered;
   }
+  return false;
 }
 
 int64 GPUTimingClient::CalculateTimerOffset() {
   if (!offset_valid_) {
     GLint64 gl_now = 0;
     glGetInteger64v(GL_TIMESTAMP, &gl_now);
     int64 now =
         cpu_time_for_testing_.is_null()
             ? base::TimeTicks::NowFromSystemTraceTime().ToInternalValue()
             : cpu_time_for_testing_.Run();
     offset_ = now - gl_now / base::Time::kNanosecondsPerMicrosecond;
     offset_valid_ = timer_type_ == GPUTiming::kTimerTypeARB;
   }
   return offset_;
 }
 
 void GPUTimingClient::InvalidateTimerOffset() {
   offset_valid_ = false;
 }
 
 void GPUTimingClient::SetCpuTimeForTesting(
     const base::Callback<int64(void)>& cpu_time) {
   cpu_time_for_testing_ = cpu_time;
 }
 
 GPUTimingClient::~GPUTimingClient() {
 }
 
 }  // namespace gfx