Force time elapsed queries on certain drivers.

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"
 #include "ui/gl/gl_version_info.h"
 
 namespace gfx {
 
 class TimeElapsedTimerQuery;
 class TimerQuery;
 
 int64_t NanoToMicro(uint64_t nano_seconds) {
   const uint64_t up = nano_seconds + base::Time::kNanosecondsPerMicrosecond / 2;
   return static_cast<int64_t>(up / base::Time::kNanosecondsPerMicrosecond);
 }
 
 class GPUTimingImpl : public GPUTiming {
  public:
    GPUTimingImpl(GLContextReal* context);
   ~GPUTimingImpl() override;
 
   void ForceTimeElapsedQuery() { force_time_elapsed_query_ = true; }
   bool IsForceTimeElapsedQuery() { return force_time_elapsed_query_; }
+  bool ShouldForceTimeElapsedQuery();
 
   GPUTiming::TimerType GetTimerType() const { return timer_type_; }
 
   uint32_t GetDisjointCount();
   int64_t CalculateTimerOffset();
 
   scoped_refptr<QueryResult> BeginElapsedTimeQuery();
   void EndElapsedTimeQuery(scoped_refptr<QueryResult> result);
 
   scoped_refptr<QueryResult> DoTimeStampQuery();
@@ skipping 270 matching lines @@
   DCHECK(context);
   const GLVersionInfo* version_info = context->GetVersionInfo();
   DCHECK(version_info);
   if (version_info->is_es3 &&  // glGetInteger64v is supported under ES3.
     context->HasExtension("GL_EXT_disjoint_timer_query")) {
     timer_type_ = GPUTiming::kTimerTypeDisjoint;
   } else if (context->HasExtension("GL_ARB_timer_query")) {
     timer_type_ = GPUTiming::kTimerTypeARB;
   } else if (context->HasExtension("GL_EXT_timer_query")) {
     timer_type_ = GPUTiming::kTimerTypeEXT;
-    force_time_elapsed_query_ = true;
   }
+  force_time_elapsed_query_ = ShouldForceTimeElapsedQuery();
 }
 
 GPUTimingImpl::~GPUTimingImpl() {
 }
 
+bool GPUTimingImpl::ShouldForceTimeElapsedQuery() {
+  if (timer_type_ == GPUTiming::kTimerTypeInvalid) {
+    return false;
+  } else if (timer_type_ == GPUTiming::kTimerTypeEXT) {
+    // GL_EXT_timer_query does not support timestamps
+    return true;
+  } else {
+    // Certain drivers such as Mac drivers and ANGLE's D3D11 backend do not
+    // support timestamps even though queries for them are valid. This is
+    // indicated by returning 0 when for GL_TIMESTAMP in GL_QUERY_COUNTER_BITS
+    DCHECK(timer_type_ == GPUTiming::kTimerTypeARB ||
+           timer_type_ == GPUTiming::kTimerTypeDisjoint);
+    GLint timestamp_bits;

[David Yen, 2016/02/11 17:53:20]

Could we just make these 3 lines a static function outside of the class? Then
just call that function in after lines 316 and 318?

+    glGetQueryiv(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, &timestamp_bits);
+    return (timestamp_bits == 0);
+  }
+}
+
 uint32_t GPUTimingImpl::GetDisjointCount() {
   if (timer_type_ == GPUTiming::kTimerTypeDisjoint) {
     GLint disjoint_value = 0;
     glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint_value);
     if (disjoint_value) {
       offset_valid_ = false;
       disjoint_counter_++;
     }
   }
   return disjoint_counter_;
@@ skipping 298 matching lines @@
 
 void GPUTimingClient::ForceTimeElapsedQuery() {
   DCHECK(gpu_timing_);
   gpu_timing_->ForceTimeElapsedQuery();
 }
 
 GPUTimingClient::~GPUTimingClient() {
 }
 
 }  // namespace gfx