Refactored GLContext to own GPUTiming which spawn GPUTimingClients.

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/strings/string_util.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_version_info.h"
+#include "ui/gl/gpu_timing.h"
 
 namespace gpu {
 namespace gles2 {
 
 static const unsigned int kProcessInterval = 16;
 static TraceOutputter* g_outputter_thread = NULL;
 
 TraceMarker::TraceMarker(const std::string& category, const std::string& name)
     : category_(category),
       name_(name),
@@ skipping 47 matching lines @@
                           name.c_str(), "gl_category", category.c_str());
 }
 
 void TraceOutputter::TraceServiceEnd(const std::string& category,
                                      const std::string& name) {
   TRACE_EVENT_COPY_END1(TRACE_DISABLED_BY_DEFAULT("gpu.service"),
                         name.c_str(), "gl_category", category.c_str());
 }
 
 GPUTrace::GPUTrace(scoped_refptr<Outputter> outputter,
-                   gpu::GPUTiming* gpu_timing,
+                   gfx::GPUTimingClient* gpu_timing_client,
                    const std::string& category,
                    const std::string& name,
                    const bool enabled)
     : category_(category),
       name_(name),
       outputter_(outputter),
       enabled_(enabled) {
-  if (gpu_timing->IsAvailable()) {
-    gpu_timer_.reset(new GPUTimer(gpu_timing));
+  if (gpu_timing_client->IsAvailable()) {
+    gpu_timer_ = gpu_timing_client->CreateGPUTimer();
   }
 }
 
 GPUTrace::~GPUTrace() {
 }
 
 void GPUTrace::Start(bool trace_service) {
   if (trace_service) {
     outputter_->TraceServiceBegin(category_, name_);
   }
@@ skipping 25 matching lines @@
     outputter_->TraceDevice(category_, name_, start, end);
   }
 }
 
 GPUTracer::GPUTracer(gles2::GLES2Decoder* decoder)
     : gpu_trace_srv_category(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
           TRACE_DISABLED_BY_DEFAULT("gpu.service"))),
       gpu_trace_dev_category(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
           TRACE_DISABLED_BY_DEFAULT("gpu.device"))),
       decoder_(decoder),
-      gpu_timing_(),
       gpu_executing_(false),
       process_posted_(false) {
+  DCHECK(decoder_);
+  gfx::GLContext* context = decoder_->GetGLContext();
+  if (context) {
+    gpu_timing_client_ = context->CreateGPUTimingClient();
+  } else {
+    gpu_timing_client_ = new gfx::GPUTimingClient();
+  }
 }
 
 GPUTracer::~GPUTracer() {
 }
 
 bool GPUTracer::BeginDecoding() {
   if (gpu_executing_)
     return false;
 
-  if (outputter_ == NULL) {
-    outputter_ = CreateOutputter(gpu_timing_.GetTimerTypeName());
-    gpu_timing_.Initialize(decoder_->GetGLContext());
+  if (!outputter_) {
+    outputter_ = CreateOutputter(gpu_timing_client_->GetTimerTypeName());
   }
 
   if (*gpu_trace_dev_category == '\0') {
     // If GPU device category is off, invalidate timing sync.
-    gpu_timing_.InvalidateTimerOffset();
+    gpu_timing_client_->InvalidateTimerOffset();
   }
 
   gpu_executing_ = true;
   if (IsTracing()) {
-    gpu_timing_.CheckAndResetTimerErrors();
+    gpu_timing_client_->CheckAndResetTimerErrors();
     // Begin a Trace for all active markers
     for (int n = 0; n < NUM_TRACER_SOURCES; n++) {
       for (size_t i = 0; i < markers_[n].size(); i++) {
         TraceMarker& trace_marker = markers_[n][i];
         trace_marker.trace_ =
-            new GPUTrace(outputter_, &gpu_timing_, trace_marker.category_,
-                         trace_marker.name_, *gpu_trace_dev_category != 0);
+            new GPUTrace(outputter_, gpu_timing_client_.get(),
+                         trace_marker.category_, trace_marker.name_,
+                         *gpu_trace_dev_category != 0);
         trace_marker.trace_->Start(*gpu_trace_srv_category != 0);
       }
     }
   }
   return true;
 }
 
 bool GPUTracer::EndDecoding() {
   if (!gpu_executing_)
     return false;
@@ skipping 28 matching lines @@
     return false;
 
   DCHECK(source >= 0 && source < NUM_TRACER_SOURCES);
 
   // Push new marker from given 'source'
   markers_[source].push_back(TraceMarker(category, name));
 
   // Create trace
   if (IsTracing()) {
     scoped_refptr<GPUTrace> trace = new GPUTrace(
-        outputter_, &gpu_timing_, category, name, *gpu_trace_dev_category != 0);
+        outputter_, gpu_timing_client_.get(), category, name,
+        *gpu_trace_dev_category != 0);
     trace->Start(*gpu_trace_srv_category != 0);
     markers_[source].back().trace_ = trace;
   }
 
   return true;
 }
 
 bool GPUTracer::End(GpuTracerSource source) {
   if (!gpu_executing_)
     return false;
@@ skipping 51 matching lines @@
       base::TimeDelta::FromMilliseconds(kProcessInterval));
 }
 
 void GPUTracer::Process() {
   process_posted_ = false;
   ProcessTraces();
   IssueProcessTask();
 }
 
 void GPUTracer::ProcessTraces() {
-  if (!gpu_timing_.IsAvailable()) {
+  if (!gpu_timing_client_->IsAvailable()) {
     traces_.clear();
     return;
   }
 
   TRACE_EVENT0("gpu", "GPUTracer::ProcessTraces");
 
   // Make owning decoder's GL context current
   if (!decoder_->MakeCurrent()) {
     // Skip subsequent GL calls if MakeCurrent fails
     traces_.clear();
     return;
   }
 
   // Check if timers are still valid (e.g: a disjoint operation
   // might have occurred.)
-  if (gpu_timing_.CheckAndResetTimerErrors())
+  if (gpu_timing_client_->CheckAndResetTimerErrors())
     traces_.clear();
 
   while (!traces_.empty() && traces_.front()->IsAvailable()) {
     traces_.front()->Process();
     traces_.pop_front();
   }
 
   // Clear pending traces if there were are any errors
   GLenum err = glGetError();
   if (err != GL_NO_ERROR)
     traces_.clear();
 }
 
 void GPUTracer::IssueProcessTask() {
   if (traces_.empty() || process_posted_)
     return;
 
   process_posted_ = true;
   PostTask();
 }
 
 }  // namespace gles2
 }  // namespace gpu