GPU: Keep track of the last real context and real surface made current.

ui/gl/gl_context.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 <string>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/thread_local.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
 
 namespace gfx {
 
 namespace {
 base::LazyInstance<base::ThreadLocalPointer<GLContext> >::Leaky
     current_context_ = LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<base::ThreadLocalPointer<GLContext> >::Leaky
+    current_real_context_ = LAZY_INSTANCE_INITIALIZER;
 }  // namespace
 
 GLContext::GLContext(GLShareGroup* share_group) : share_group_(share_group) {
   if (!share_group_.get())
     share_group_ = new GLShareGroup;
 
   share_group_->AddContext(this);
 }
 
 GLContext::~GLContext() {
@@ skipping 50 matching lines @@
     default:
       NOTREACHED();
       return true;
   }
 }
 
 GLContext* GLContext::GetCurrent() {
   return current_context_.Pointer()->Get();
 }
 
+GLContext* GLContext::GetRealCurrent() {
+  return current_real_context_.Pointer()->Get();
+}
+
 void GLContext::SetCurrent(GLContext* context, GLSurface* surface) {
+  DCHECK_EQ(!context, !surface);
+  if (!context || !context->IsVirtualContext()) {

[greggman, 2013/05/31 21:13:38]

I feel like the suggestion of GLRealContext vs GLVirtualContext vs GLContext
(the abstract class) would solve this without the need for IsVirtualContext

GLVirtualContext would call SetCurrent which would only set current_context_. 

It would also call shared_context_->SetAsRealContext()

GLRealContext would call SetCurrent and call

   GLContext::SetRealContext(this);

I don't know if I'm making any sense but you shouldn't have to know if this is
virtual. The virtual should delegate to its parent which might be real or
virtual. If virtual it would delegate to it's parent. etc.. Eventually you reach
a real context which would set current_real_context_

No need for "IsVirtualContext". No one should need to know that.

thoughts?

[jonathan.backer, 2013/06/03 14:57:23]

Done with some slight modifications. Mostly used GLContextReal (vs
GLRealContext) to follow the naming GLContextVirtual.

+    current_real_context_.Pointer()->Set(context);
+    GLSurface::SetRealCurrent(surface);
+  }
   current_context_.Pointer()->Set(context);
   GLSurface::SetCurrent(surface);
 }
 
 GLStateRestorer* GLContext::GetGLStateRestorer() {
   return state_restorer_.get();
 }
 
 void GLContext::SetGLStateRestorer(GLStateRestorer* state_restorer) {
   state_restorer_ = make_scoped_ptr(state_restorer);
@@ skipping 17 matching lines @@
 void GLContext::SetupForVirtualization() {
   if (!virtual_gl_api_) {
     virtual_gl_api_.reset(new VirtualGLApi());
     virtual_gl_api_->Initialize(&g_driver_gl, this);
   }
 }
 
 bool GLContext::MakeVirtuallyCurrent(
     GLContext* virtual_context, GLSurface* surface) {
   DCHECK(virtual_gl_api_);
-  return virtual_gl_api_->MakeCurrent(virtual_context, surface);
+  bool result = virtual_gl_api_->MakeCurrent(virtual_context, surface);
+  if (result)
+    SetCurrent(virtual_context, surface);
+  return result;
 }
 
 void GLContext::OnReleaseVirtuallyCurrent(GLContext* virtual_context) {
   if (virtual_gl_api_)
     virtual_gl_api_->OnReleaseVirtuallyCurrent(virtual_context);
 }
 
 void GLContext::SetRealGLApi() {
   SetGLToRealGLApi();
 }
 
+bool GLContext::IsVirtualContext() {
+  return false;
+}
+
 }  // namespace gfx