gpu: Add ARB_occlusion_query support.

cc/output/gl_renderer.cc

 // Copyright 2010 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 "cc/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <memory>
+#include <numeric>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 373 matching lines @@
 
   const auto& context_caps =
       output_surface_->context_provider()->ContextCapabilities();
   DCHECK(!context_caps.iosurface || context_caps.texture_rectangle);
 
   use_discard_framebuffer_ = context_caps.discard_framebuffer;
   use_sync_query_ = context_caps.sync_query;
   use_blend_equation_advanced_ = context_caps.blend_equation_advanced;
   use_blend_equation_advanced_coherent_ =
       context_caps.blend_equation_advanced_coherent;
+  use_occlusion_query_ = context_caps.occlusion_query;
 
   InitializeSharedObjects();
 }
 
 GLRenderer::~GLRenderer() {
   CleanupSharedObjects();
 
   if (context_visibility_) {
     auto* context_provider = output_surface_->context_provider();
     auto* cache_controller = context_provider->CacheController();
@@ skipping 3135 matching lines @@
   // Occlusion queries can be expensive, so only collect trace data if we select
   // cc.debug.overdraw.
   bool tracing_enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), &tracing_enabled);
 
   // Trace only the root render pass.
   if (frame->current_render_pass != frame->root_render_pass)
     tracing_enabled = false;
 
+  // ARB_occlusion_query is required for tracing.
+  if (!use_occlusion_query_)
+    tracing_enabled = false;
+
+  // Use the current surface area as max result. The effect is that overdraw
+  // is reported as a percentage of the output surface size. ie. 2x overdraw
+  // for the whole screen is reported as 200.
+  int max_result = current_surface_size_.GetArea();
+  DCHECK_GT(max_result, 0);
+
   OverdrawFeedbackCallback overdraw_feedback_callback = base::Bind(
       &GLRenderer::ProcessOverdrawFeedback, weak_ptr_factory_.GetWeakPtr(),
-      base::Owned(new std::vector<int>), arraysize(stencil_tests));
+      base::Owned(new std::vector<int>), arraysize(stencil_tests), max_result);
 
   for (const auto& test : stencil_tests) {
     GLuint query = 0;
     if (tracing_enabled) {
       gl_->GenQueriesEXT(1, &query);
-      // TODO(reveman): Use SAMPLES_PASSED_ARB for exact amount of overdraw.
-      gl_->BeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, query);
+      gl_->BeginQueryEXT(GL_SAMPLES_PASSED_ARB, query);
     }
 
     gl_->StencilFunc(test.func, test.ref, 0xffffffff);
     // Transparent color unless color-coding of overdraw is enabled.
     Float4 color =
         PremultipliedColor(settings_->show_overdraw_feedback ? test.color : 0);
     gl_->Uniform4fv(program->color_location(), 1, color.data);
     gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 
     if (query) {
-      gl_->EndQueryEXT(GL_ANY_SAMPLES_PASSED_EXT);
+      gl_->EndQueryEXT(GL_SAMPLES_PASSED_ARB);
       context_support_->SignalQuery(
           query,
           base::Bind(overdraw_feedback_callback, query, test.multiplier));
     }
   }
 }
 
 void GLRenderer::ProcessOverdrawFeedback(std::vector<int>* overdraw,
                                          size_t num_expected_results,
+                                         int max_result,
                                          unsigned query,
                                          int multiplier) {
   unsigned result = 0;
   if (query) {
     gl_->GetQueryObjectuivEXT(query, GL_QUERY_RESULT_EXT, &result);
-    DCHECK_LE(result, 1u);
     gl_->DeleteQueriesEXT(1, &query);
   }
 
   // Apply multiplier to get the amount of overdraw.
   overdraw->push_back(result * multiplier);
 
   // Return early if we are expecting more results.
   if (overdraw->size() < num_expected_results)
     return;
 
-  // Report the maximum amount of overdraw.
-  TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
-                 *std::max_element(overdraw->begin(), overdraw->end()));
+  // Report GPU overdraw as a percentage of |max_result|.
+  TRACE_COUNTER1(
+      TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
+      (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
+          max_result);
 }
 
 }  // namespace cc