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) {
+  if (!context || !context->IsVirtualContext()) {

[no sievers, 2013/05/24 17:04:02]

Do we allow SetCurrent(NULL, !NULL)?
Or should we DCHECK_EQ(!surface, !context) as it might not make sense?

[jonathan.backer, 2013/05/24 20:36:40]

Yeah. I just looked at the OSX code (which might have been the exception --- see
NoOpSurfaceCGL) and I think that this is always true.

[jonathan.backer, 2013/05/27 16:37:36]

Done.

+    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);

[jonathan.backer, 2013/05/23 21:00:53]

Maybe SetCurrent(NULL, NULL) otherwise?

+  return result;
 }
 
 void GLContext::OnDestroyVirtualContext(GLContext* virtual_context) {
   if (virtual_gl_api_)
     virtual_gl_api_->OnDestroyVirtualContext(virtual_context);
 }
 
 void GLContext::SetRealGLApi() {
   SetGLToRealGLApi();
 }
 
+bool GLContext::IsVirtualContext() {
+  return false;
+}
+
 }  // namespace gfx