GPU: Reduce MakeCurrent calls to fix Orange San Diego

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 11 matching lines @@
 }
 
 gfx::Display* GLContextVirtual::display() {
   return display_;
 }
 
 bool GLContextVirtual::Initialize(
     gfx::GLSurface* compatible_surface, gfx::GpuPreference gpu_preference) {
   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);
   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())
     shared_context_->MakeVirtuallyCurrent(this, surface);
   else
     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();
 }
 
 gfx::GLStateRestorer* GLContextVirtual::GetGLStateRestorer() {
   return state_restorer_.get();
 }
 
@@ skipping 22 matching lines @@
 
 void GLContextVirtual::SetUnbindFboOnMakeCurrent() {
   shared_context_->SetUnbindFboOnMakeCurrent();
 }
 
 GLContextVirtual::~GLContextVirtual() {
   Destroy();
 }
 
 }  // namespace gpu