Make correct GL context current during gpu_tracer processing

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"
@@ skipping 51 matching lines @@
  private:
   virtual ~NoopTrace() {}
 
   DISALLOW_COPY_AND_ASSIGN(NoopTrace);
 };
 
 class GPUTracerImpl
     : public GPUTracer,
       public base::SupportsWeakPtr<GPUTracerImpl> {
  public:
-  GPUTracerImpl()
-      : gpu_category_enabled_(
-        TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("gpu")),
-        process_posted_(false) {
-  }
+  explicit GPUTracerImpl(gles2::GLES2Decoder* decoder)
+      : GPUTracer(decoder),
+        gpu_category_enabled_(
+            TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("gpu")),
+        process_posted_(false) {}
   virtual ~GPUTracerImpl() {}
 
   // Implementation of gpu::gles2::GPUTracer
   virtual bool Begin(const std::string& name) OVERRIDE;
   virtual bool End() OVERRIDE;
   virtual const std::string& CurrentName() const OVERRIDE;
 
   // Process any completed traces.
   virtual void Process();
 
  protected:
   // Create a new trace.
   virtual scoped_refptr<Trace> CreateTrace(const std::string& name);
 
   const unsigned char* gpu_category_enabled_;
 
  private:
   void IssueProcessTask();
 
   scoped_refptr<Trace> current_trace_;
   std::deque<scoped_refptr<Trace> > traces_;
 
   bool process_posted_;
 
   DISALLOW_COPY_AND_ASSIGN(GPUTracerImpl);
 };
 
 class GPUTracerARBTimerQuery : public GPUTracerImpl {
  public:
-  GPUTracerARBTimerQuery();
+  explicit GPUTracerARBTimerQuery(gles2::GLES2Decoder* decoder);
   virtual ~GPUTracerARBTimerQuery();
 
   // Implementation of GPUTracerImpl
   virtual void Process() OVERRIDE;
 
  private:
   // Implementation of GPUTracerImpl.
   virtual scoped_refptr<Trace> CreateTrace(const std::string& name) OVERRIDE;
 
   void CalculateTimerOffset();
@@ skipping 80 matching lines @@
     traces_.push_back(current_trace_);
   current_trace_ = NULL;
 
   IssueProcessTask();
   return true;
 }
 
 void GPUTracerImpl::Process() {
   process_posted_ = false;
 
+  // Make owning decoder's GL context current
+  if (!decoder_->MakeCurrent()) {
+    // Skip subsequent GL calls if MakeCurrent fails
+    traces_.clear();
+    return;
+  }
+
   while (!traces_.empty() && traces_.front()->IsAvailable()) {
     traces_.front()->Process();
     traces_.pop_front();
   }
 
   IssueProcessTask();
 }
 
 const std::string& GPUTracerImpl::CurrentName() const {
   if (!current_trace_.get())
     return base::EmptyString();
   return current_trace_->name();
 }
 
 scoped_refptr<Trace> GPUTracerImpl::CreateTrace(const std::string& name) {
   return new NoopTrace(name);
 }
 
 void GPUTracerImpl::IssueProcessTask() {
   if (traces_.empty() || process_posted_)
     return;
 
   process_posted_ = true;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&GPUTracerImpl::Process, base::AsWeakPtr(this)),
       base::TimeDelta::FromMilliseconds(kProcessInterval));
 }
 
-GPUTracerARBTimerQuery::GPUTracerARBTimerQuery()
-    : GPUTracerImpl(),
-      timer_offset_(0),
-      last_offset_check_(0) {
+GPUTracerARBTimerQuery::GPUTracerARBTimerQuery(gles2::GLES2Decoder* decoder)
+    : GPUTracerImpl(decoder), timer_offset_(0), last_offset_check_(0) {
   CalculateTimerOffset();
   outputter_ = TraceOutputter::Create("GL_ARB_timer_query");
 }
 
 GPUTracerARBTimerQuery::~GPUTracerARBTimerQuery() {
 }
 
 scoped_refptr<Trace> GPUTracerARBTimerQuery::CreateTrace(
     const std::string& name) {
   if (*gpu_category_enabled_)
@@ skipping 21 matching lines @@
   glGetQueryObjectui64v(query, GL_QUERY_RESULT, &gl_now);
   base::TimeTicks system_now = base::TimeTicks::NowFromSystemTraceTime();
 
   gl_now /= base::Time::kNanosecondsPerMicrosecond;
   timer_offset_ = system_now.ToInternalValue() - gl_now;
   glDeleteQueries(1, &query);
 
   last_offset_check_ = system_now.ToInternalValue();
 }
 
-scoped_ptr<GPUTracer> GPUTracer::Create() {
+GPUTracer::GPUTracer(gles2::GLES2Decoder* decoder) : decoder_(decoder) {}
+
+GPUTracer::~GPUTracer() {}
+
+scoped_ptr<GPUTracer> GPUTracer::Create(gles2::GLES2Decoder* decoder) {
   if (gfx::g_driver_gl.ext.b_GL_ARB_timer_query) {
-    return scoped_ptr<GPUTracer>(new GPUTracerARBTimerQuery());
+    return scoped_ptr<GPUTracer>(new GPUTracerARBTimerQuery(decoder));
   }
-  return scoped_ptr<GPUTracer>(new GPUTracerImpl());
+  return scoped_ptr<GPUTracer>(new GPUTracerImpl(decoder));
 }
 
 }  // namespace gles2
 }  // namespace gpu