gpu: Fix corrupted state due to virtual MakeCurrent race.

gpu/command_buffer/service/gl_context_virtual.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/gl_context_virtual.h"
 
 #include "gpu/command_buffer/service/gl_state_restorer_impl.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "ui/gl/gl_surface.h"
 
@@ skipping 12 matching lines @@
 gfx::Display* GLContextVirtual::display() {
   return display_;
 }
 
 bool GLContextVirtual::Initialize(
     gfx::GLSurface* compatible_surface, gfx::GpuPreference gpu_preference) {
   SetGLStateRestorer(new GLStateRestorerImpl(decoder_));
 
   display_ = static_cast<gfx::Display*>(compatible_surface->GetDisplay());
 
-  if (!shared_context_->MakeCurrent(compatible_surface))
-    return false;
+  // Virtual contexts obviously can't make a context that is compatible
+  // with the surface (the context already exists), but we do need to
+  // make a context current for SetupForVirtualization() below.
+  if (!IsCurrent(compatible_surface)) {
+    if (!shared_context_->MakeCurrent(compatible_surface)) {
+      // This is likely an error. The real context should be made as
+      // compatible with all required surfaces when it was created.
+      LOG(ERROR) << "Failed MakeCurrent(compatible_surface)";
+      return false;
+    }
+  }
 
   shared_context_->SetupForVirtualization();
-
-  shared_context_->ReleaseCurrent(compatible_surface);
+  shared_context_->MakeVirtuallyCurrent(this, compatible_surface);
   return true;
 }
 
 void GLContextVirtual::Destroy() {
   shared_context_->OnDestroyVirtualContext(this);
   shared_context_ = NULL;
   display_ = NULL;
 }
 
 bool GLContextVirtual::MakeCurrent(gfx::GLSurface* surface) {
-  if (decoder_.get() && decoder_->initialized())
+  // TODO(epenner): We should avoid bypassing MakeVirtuallyCurrent() below
+  // (return false or DCHECK when !decoder). To do this we must reorder
+  // tear-down in GpuCommandBufferStub::Destroy().
+  if (decoder_.get())
     shared_context_->MakeVirtuallyCurrent(this, surface);
-  else
+  else if (!IsCurrent(surface))
     shared_context_->MakeCurrent(surface);
   return true;
 }
 
 void GLContextVirtual::ReleaseCurrent(gfx::GLSurface* surface) {
   if (IsCurrent(surface))
     shared_context_->ReleaseCurrent(surface);
 }
 
 bool GLContextVirtual::IsCurrent(gfx::GLSurface* surface) {
-  bool context_current = shared_context_->IsCurrent(NULL);
-  if (!context_current)
-    return false;
+  // If it's a real surface it needs to be current.
+  if (surface &&
+      !surface->GetBackingFrameBufferObject() &&
+      !surface->IsOffscreen())
+    return shared_context_->IsCurrent(surface);
 
-  if (!surface)
-    return true;
-
-  gfx::GLSurface* current_surface = gfx::GLSurface::GetCurrent();
-  return surface->GetBackingFrameBufferObject() ||
-      surface->IsOffscreen() ||
-      (current_surface &&
-       current_surface->GetHandle() == surface->GetHandle());
+  // Otherwise, only insure the context itself is current.
+  return shared_context_->IsCurrent(NULL);
 }
 
 void* GLContextVirtual::GetHandle() {
   return shared_context_->GetHandle();
 }
 
 void GLContextVirtual::SetSwapInterval(int interval) {
   shared_context_->SetSwapInterval(interval);
 }
 
@@ skipping 18 matching lines @@
 
 void GLContextVirtual::SetUnbindFboOnMakeCurrent() {
   shared_context_->SetUnbindFboOnMakeCurrent();
 }
 
 GLContextVirtual::~GLContextVirtual() {
   Destroy();
 }
 
 }  // namespace gpu