Roll Chrome into Mojo.

gpu/command_buffer/service/gpu_tracer.cc

 // Copyright (c) 2012 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 "gpu/command_buffer/service/gpu_tracer.h"
 
 #include <deque>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
+#include "gpu/command_buffer/service/context_group.h"
+#include "ui/gl/gl_version_info.h"
 
 namespace gpu {
 namespace gles2 {
 
 static const unsigned int kProcessInterval = 16;
 static TraceOutputter* g_outputter_thread = NULL;
 
 CPUTime::CPUTime() {
 }
 
@@ skipping 106 matching lines @@
   if (trace_service) {
     outputter_->TraceServiceBegin(category_, name_);
   }
 
   switch (tracer_type_) {
     case kTracerTypeInvalid:
       break;
 
     case kTracerTypeDisjointTimer:
       // For the disjoint timer, GPU idle time does not seem to increment the
-      // internal counter. We must calculate the offset before any query. The
-      // good news is any device that supports disjoint timer will also support
-      // glGetInteger64v, so we can query it directly unlike the ARBTimer case.
-      // The "offset_" variable will always be 0 during normal use cases, only
-      // under the unit tests will it be set to specific test values.
-      if (offset_ == 0) {
+      // internal counter. We must calculate the offset before any query.
+      // glGetInteger64v is supported under ES3 which we check for before using
+      // the kTracerTypeDisjointTimer.
+      {
         GLint64 gl_now = 0;
         glGetInteger64v(GL_TIMESTAMP, &gl_now);
         offset_ = cpu_time_->GetCurrentTime() -
                   gl_now / base::Time::kNanosecondsPerMicrosecond;
       }
       // Intentionally fall through to kTracerTypeARBTimer case.xs
     case kTracerTypeARBTimer:
       // GL_TIMESTAMP and GL_TIMESTAMP_EXT both have the same value.
       glQueryCounter(queries_[0], GL_TIMESTAMP);
       break;
@@ skipping 17 matching lines @@
     outputter_->TraceServiceEnd(category_, name_);
   }
 }
 
 bool GPUTrace::IsAvailable() {
   if (tracer_type_ != kTracerTypeInvalid) {
     if (!end_requested_)
       return false;
 
     GLint done = 0;
-    glGetQueryObjectiv(queries_[1], GL_QUERY_RESULT_AVAILABLE, &done);
+    glGetQueryObjectivARB(queries_[1], GL_QUERY_RESULT_AVAILABLE, &done);
     return !!done;
   }
 
   return true;
 }
 
 void GPUTrace::Process() {
   if (tracer_type_ == kTracerTypeInvalid)
     return;
 
@@ skipping 184 matching lines @@
 
 scoped_refptr<Outputter> GPUTracer::CreateOutputter(const std::string& name) {
   return TraceOutputter::Create(name);
 }
 
 scoped_refptr<CPUTime> GPUTracer::CreateCPUTime() {
   return new CPUTime();
 }
 
 GpuTracerType GPUTracer::DetermineTracerType() {
-  if (gfx::g_driver_gl.ext.b_GL_EXT_disjoint_timer_query) {
+  ContextGroup* context_group = decoder_->GetContextGroup();
+  const gpu::gles2::FeatureInfo* feature_info = context_group->feature_info();
+  const gfx::GLVersionInfo& version_info = feature_info->gl_version_info();
+
+  if (version_info.is_es3 &&
+      gfx::g_driver_gl.ext.b_GL_EXT_disjoint_timer_query) {
     return kTracerTypeDisjointTimer;
   } else if (gfx::g_driver_gl.ext.b_GL_ARB_timer_query) {
     return kTracerTypeARBTimer;
   }
 
   return kTracerTypeInvalid;
 }
 
 void GPUTracer::PostTask() {
   base::MessageLoop::current()->PostDelayedTask(
@@ skipping 40 matching lines @@
   GLenum err = glGetError();
   if (err != GL_NO_ERROR)
     traces_.clear();
 }
 
 void GPUTracer::CalculateTimerOffset() {
   if (tracer_type_ != kTracerTypeInvalid) {
     if (*gpu_trace_dev_category == '\0') {
       // If GPU device category is off, invalidate timing sync.
       gpu_timing_synced_ = false;
-      return;
-    } else if (tracer_type_ == kTracerTypeDisjointTimer) {
-      // Disjoint timers offsets should be calculated before every query.
+    } else if (!gpu_timing_synced_ && tracer_type_ == kTracerTypeARBTimer) {
+      TRACE_EVENT0("gpu", "GPUTracer::CalculateTimerOffset");
+
+      // ARB Timer is written for OpenGL 3.2 which contains glGetInteger64v().
+      GLint64 gl_now = 0;
+      glGetInteger64v(GL_TIMESTAMP, &gl_now);
+      timer_offset_ = cpu_time_->GetCurrentTime() -
+                      gl_now / base::Time::kNanosecondsPerMicrosecond;
       gpu_timing_synced_ = true;
-      timer_offset_ = 0;
     }
-
-    if (gpu_timing_synced_)
-      return;
-
-    TRACE_EVENT0("gpu", "GPUTracer::CalculateTimerOffset");
-
-    // NOTE(vmiura): It would be better to use glGetInteger64v, however
-    // it's not available everywhere.
-    GLuint64 gl_now = 0;
-    GLuint query;
-
-    glGenQueriesARB(1, &query);
-
-    glFinish();
-    glQueryCounter(query, GL_TIMESTAMP);
-    glFinish();
-
-    glGetQueryObjectui64v(query, GL_QUERY_RESULT, &gl_now);
-    glDeleteQueriesARB(1, &query);
-
-    gl_now /= base::Time::kNanosecondsPerMicrosecond;
-    timer_offset_ = cpu_time_->GetCurrentTime() - gl_now;
-    gpu_timing_synced_ = true;
   }
 }
 
 void GPUTracer::IssueProcessTask() {
   if (traces_.empty() || process_posted_)
     return;
 
   process_posted_ = true;
   PostTask();
 }
 
 }  // namespace gles2
 }  // namespace gpu