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()) {

[epenner, 2013/05/28 21:33:53]

One drive-by comment:

If we keep keep track of the real context, I think we need to always set it here
(for example by grabbing the real context from the virtual context). For example
if there is several real contexts, each backing several virtual contexts, we
still want to change the real context if it has changed.

I believe Gregg mentioned pepper as a use-case where we would use one real
context for each plugin type, with virtual for each plugin instance.

[jonathan.backer, 2013/05/31 17:21:40]

By only changing current_real_context_ when the real context is made current,
current_real_context_ reflects a GL call that was made. I think it's easier to
reason if that invariant is maintained.

AFAICT, as part of the making the virtual context current, the real context will
be made current. We've got a DCHECK in VirtualGLApi::MakeCurrent to this affect.
Sorry. I may be mistaken (I often am), but I don't see how this precludes that.
There may need to be some changes at the gl_gl_api_implementation level.

+    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::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