Refactored GLContext to own GPUTiming which spawn GPUTimingClients.

gpu/perftests/texture_upload_perftest.cc

 // Copyright 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 <algorithm>
 #include <vector>
 
 #include "base/containers/small_map.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
-#include "gpu/command_buffer/service/gpu_timing.h"
 #include "gpu/perftests/measurements.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface.h"
+#include "ui/gl/gpu_timing.h"
 #include "ui/gl/scoped_make_current.h"
 
 namespace gpu {
 namespace {
 
 const int kUploadPerfWarmupRuns = 10;
 const int kUploadPerfTestRuns = 100;
 
 #define SHADER(Src) #Src
 
@@ skipping 86 matching lines @@
 
     glGenFramebuffersEXT(1, &framebuffer_object_);
     glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer_object_);
 
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                               GL_TEXTURE_2D, color_texture_, 0);
     DCHECK_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
               glCheckFramebufferStatusEXT(GL_FRAMEBUFFER));
 
     glViewport(0, 0, fbo_size_.width(), fbo_size_.height());
+    gpu_timing_client_ = gl_context_->CreateGPUTimingClient();
 
-    if (gpu_timing_.Initialize(gl_context_.get())) {
+    if (gpu_timing_client_->IsAvailable()) {
       LOG(INFO) << "Gpu timing initialized with timer type: "
-                << gpu_timing_.GetTimerTypeName();
-      gpu_timing_.CheckAndResetTimerErrors();
-      gpu_timing_.InvalidateTimerOffset();
+                << gpu_timing_client_->GetTimerTypeName();
+      gpu_timing_client_->InvalidateTimerOffset();
     } else {
       LOG(WARNING) << "Can't initialize gpu timing";
     }
     // Prepare a simple program and a vertex buffer that will be
     // used to draw a quad on the offscreen surface.
     vertex_shader_ = LoadShader(GL_VERTEX_SHADER, kVertexShader);
     fragment_shader_ = LoadShader(GL_FRAGMENT_SHADER, kFragmentShader);
     program_object_ = glCreateProgram();
     CHECK_NE(0u, program_object_);
 
@@ skipping 55 matching lines @@
   }
 
  protected:
   // Upload and draw on the offscren surface.
   // Return a list of pair. Each pair describe a gl operation and the wall
   // time elapsed in milliseconds.
   std::vector<Measurement> UploadAndDraw(const gfx::Size& size,
                                          const std::vector<uint8>& pixels,
                                          const GLenum format,
                                          const GLenum type) {
-    MeasurementTimers total_timers(&gpu_timing_);
+    MeasurementTimers total_timers(gpu_timing_client_.get());
     GLuint texture_id = 0;
 
-    MeasurementTimers tex_timers(&gpu_timing_);
+    MeasurementTimers tex_timers(gpu_timing_client_.get());
     glActiveTexture(GL_TEXTURE0);
     glGenTextures(1, &texture_id);
     glBindTexture(GL_TEXTURE_2D, texture_id);
 
     glTexImage2D(GL_TEXTURE_2D, 0, format, size.width(), size.height(), 0,
                  format, type, &pixels[0]);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     CheckNoGlError();
     tex_timers.Record();
 
-    MeasurementTimers draw_timers(&gpu_timing_);
+    MeasurementTimers draw_timers(gpu_timing_client_.get());
     glUseProgram(program_object_);
     glUniform1i(sampler_location_, 0);
 
     DCHECK_NE(0u, vertex_buffer_);
     glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
     glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4, 0);
     glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4,
                           reinterpret_cast<void*>(sizeof(GLfloat) * 2));
     glEnableVertexAttribArray(0);
     glEnableVertexAttribArray(1);
 
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
     draw_timers.Record();
 
-    MeasurementTimers finish_timers(&gpu_timing_);
+    MeasurementTimers finish_timers(gpu_timing_client_.get());
     glFinish();
     CheckNoGlError();
     finish_timers.Record();
     total_timers.Record();
 
     glDeleteTextures(1, &texture_id);
 
     std::vector<uint8> pixels_rendered(size.GetArea() * 4);
     glReadPixels(0, 0, size.width(), size.height(), GL_RGBA, type,
                  &pixels_rendered[0]);
     CheckNoGlError();
 
     // TODO(dcastagna): don't assume the format of the texture and do
     // the appropriate format conversion.
     EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
     EXPECT_EQ(pixels, pixels_rendered);
 
     std::vector<Measurement> measurements;
     bool gpu_timer_errors =
-        gpu_timing_.IsAvailable() && gpu_timing_.CheckAndResetTimerErrors();
+        gpu_timing_client_->IsAvailable() &&
+        gpu_timing_client_->CheckAndResetTimerErrors();
     if (!gpu_timer_errors) {
       measurements.push_back(total_timers.GetAsMeasurement("total"));
       measurements.push_back(tex_timers.GetAsMeasurement("teximage2d"));
       measurements.push_back(draw_timers.GetAsMeasurement("drawarrays"));
       measurements.push_back(finish_timers.GetAsMeasurement("finish"));
     }
     return measurements;
   }
 
   void RunUploadAndDrawMultipleTimes(const gfx::Size& size) {
@@ skipping 20 matching lines @@
         m.PrintResult(base::StringPrintf("_%d", size.width()));
       }
     }
     perf_test::PrintResult("sample_runs", "", "",
                            static_cast<size_t>(successful_runs), "laps", true);
   }
 
   const gfx::Size fbo_size_;  // for the fbo
   scoped_refptr<gfx::GLContext> gl_context_;
   scoped_refptr<gfx::GLSurface> surface_;
-  GPUTiming gpu_timing_;
+  scoped_refptr<gfx::GPUTimingClient> gpu_timing_client_;
 
   GLuint color_texture_ = 0;
   GLuint framebuffer_object_ = 0;
   GLuint vertex_shader_ = 0;
   GLuint fragment_shader_ = 0;
   GLuint program_object_ = 0;
   GLint sampler_location_ = -1;
   GLuint vertex_buffer_ = 0;
 };
 
@@ skipping 11 matching lines @@
 
     DCHECK_NE(0u, framebuffer_object_);
     glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer_object_);
 
     RunUploadAndDrawMultipleTimes(size);
   }
 }
 
 }  // namespace
 }  // namespace gpu