Remove VirtualGLApi

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 "ui/gl/gl_context.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
@@ skipping 28 matching lines @@
     GetCurrent()->ReleaseCurrent(nullptr);
   }
 }
 
 void GLContext::ScopedReleaseCurrent::Cancel() {
   canceled_ = true;
 }
 
 GLContext::GLContext(GLShareGroup* share_group)
     : share_group_(share_group),
+      current_virtual_context_(nullptr),
       state_dirtied_externally_(false),
       swap_interval_(1),
       force_swap_interval_zero_(false) {
   if (!share_group_.get())
     share_group_ = new GLShareGroup;
 
   share_group_->AddContext(this);
 }
 
 GLContext::~GLContext() {
@@ skipping 120 matching lines @@
 }
 
 bool GLContext::InitializeDynamicBindings() {
   DCHECK(IsCurrent(nullptr));
   bool initialized = InitializeDynamicGLBindings(GetGLImplementation(), this);
   if (!initialized)
     LOG(ERROR) << "Could not initialize dynamic bindings.";
   return initialized;
 }
 
-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_);
   if (!ForceGpuSwitchIfNeeded())
     return false;
-  return virtual_gl_api_->MakeCurrent(virtual_context, surface);
+  bool switched_real_contexts = GLContext::GetRealCurrent() != this;
+  GLSurface* current_surface = GLSurface::GetCurrent();
+  if (switched_real_contexts || surface != current_surface) {
+    // MakeCurrent 'lite' path that avoids potentially expensive MakeCurrent()
+    // calls if the GLSurface uses the same underlying surface or renders to
+    // an FBO.
+    if (switched_real_contexts || !current_surface ||
+        !virtual_context->IsCurrent(surface)) {
+      if (!MakeCurrent(surface)) {
+        return false;
+      }
+    }
+  }
+
+  DCHECK_EQ(this, GLContext::GetRealCurrent());
+  DCHECK(IsCurrent(NULL));
+  DCHECK(virtual_context->IsCurrent(surface));
+
+  if (switched_real_contexts || virtual_context != current_virtual_context_) {
+#if DCHECK_IS_ON()
+    GLenum error = glGetError();
+    // Accepting a context loss error here enables using debug mode to work on
+    // context loss handling in virtual context mode.
+    // There should be no other errors from the previous context leaking into
+    // the new context.
+    DCHECK(error == GL_NO_ERROR || error == GL_CONTEXT_LOST_KHR) <<
+        "GL error was: " << error;
+#endif
+
+    // Set all state that is different from the real state
+    if (virtual_context->GetGLStateRestorer()->IsInitialized()) {
+      GLStateRestorer* virtual_state = virtual_context->GetGLStateRestorer();
+      GLStateRestorer* current_state =
+          current_virtual_context_
+              ? current_virtual_context_->GetGLStateRestorer()
+              : nullptr;
+      if (current_state)
+        current_state->PauseQueries();
+      virtual_state->ResumeQueries();
+
+      virtual_state->RestoreState(
+          (current_state && !switched_real_contexts) ? current_state : NULL);
+    }
+    current_virtual_context_ = virtual_context;
+  }
+
+  virtual_context->SetCurrent(surface);
+  if (!surface->OnMakeCurrent(virtual_context)) {
+    LOG(ERROR) << "Could not make GLSurface current.";
+    return false;
+  }
+  return true;
 }
 
 void GLContext::OnReleaseVirtuallyCurrent(GLContext* virtual_context) {
-  if (virtual_gl_api_)
-    virtual_gl_api_->OnReleaseVirtuallyCurrent(virtual_context);
+  if (current_virtual_context_ == virtual_context)
+    current_virtual_context_ = nullptr;
 }
 
 void GLContext::SetRealGLApi() {
   SetGLToRealGLApi();
 }
 
 GLContextReal::GLContextReal(GLShareGroup* share_group)
     : GLContext(share_group) {}
 
 scoped_refptr<GPUTimingClient> GLContextReal::CreateGPUTimingClient() {
@@ skipping 15 matching lines @@
 
 scoped_refptr<GLContext> InitializeGLContext(scoped_refptr<GLContext> context,
                                              GLSurface* compatible_surface,
                                              GpuPreference gpu_preference) {
   if (!context->Initialize(compatible_surface, gpu_preference))
     return nullptr;
   return context;
 }
 
 }  // namespace gl