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() {
   share_group_->RemoveContext(this);
   if (GetCurrent() == this) {
-    SetCurrent(NULL, NULL);
+    SetCurrent(NULL);
   }
 }
 
 bool GLContext::GetTotalGpuMemory(size_t* bytes) {
   DCHECK(bytes);
   *bytes = 0;
   return false;
 }
 
 void GLContext::SetSafeToForceGpuSwitch() {
@@ skipping 37 matching lines @@
     default:
       NOTREACHED();
       return true;
   }
 }
 
 GLContext* GLContext::GetCurrent() {
   return current_context_.Pointer()->Get();
 }
 
-void GLContext::SetCurrent(GLContext* context, GLSurface* surface) {
-  current_context_.Pointer()->Set(context);
+GLContext* GLContext::GetRealCurrent() {
+  return current_real_context_.Pointer()->Get();
+}
+
+void GLContext::SetCurrent(GLSurface* surface) {
+  current_context_.Pointer()->Set(surface ? this : NULL);
   GLSurface::SetCurrent(surface);
 }
 
 GLStateRestorer* GLContext::GetGLStateRestorer() {
   return state_restorer_.get();
 }
 
 void GLContext::SetGLStateRestorer(GLStateRestorer* state_restorer) {
   state_restorer_ = make_scoped_ptr(state_restorer);
 }
@@ skipping 16 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) {
+    virtual_context->SetCurrent(surface);
+    surface->OnMakeCurrent(virtual_context);

[no sievers, 2013/06/04 23:47:20]

Wait, why add a call to surface->OnMakeCurrent() here?

[jonathan.backer, 2013/06/05 14:02:10]

Most (all?) of the implementations of GLSurface::OnMakeCurrent are caching the
context passed into the call for use later on. They don't do much else
(sometimes set swap interval, sometimes allocation some buffer backing an FBO).

What was happening on OSX was that we were caching the real context underlying
the virtual context. This caused a failing DCHECK(cached_context_ ==
GLContext::GetCurrent) later on once the virtual context was set current.

+  }
+  return result;
 }
 
 void GLContext::OnReleaseVirtuallyCurrent(GLContext* virtual_context) {
   if (virtual_gl_api_)
     virtual_gl_api_->OnReleaseVirtuallyCurrent(virtual_context);
 }
 
 void GLContext::SetRealGLApi() {
   SetGLToRealGLApi();
 }
 
+GLContextReal::GLContextReal(GLShareGroup* share_group)
+    : GLContext(share_group) {}
+
+GLContextReal::~GLContextReal() {}
+
+void GLContextReal::SetCurrent(GLSurface* surface) {
+  GLContext::SetCurrent(surface);
+  current_real_context_.Pointer()->Set(surface ? this : NULL);
+  GLSurface::SetRealCurrent(surface);
+}
+
 }  // namespace gfx