Restore gl scissor state when switching FBO targets on Qualcomm

ui/gl/gl_gl_api_implementation.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_gl_api_implementation.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/string_util.h"
@@ skipping 94 matching lines @@
   // queries.
   it = std::find(ext.begin(), ext.end(), "GL_EXT_occlusion_query_boolean");
   if (it != ext.end())
     ext.erase(it);
 
   extensions_ = JoinString(ext, " ");
 }
 
 bool VirtualGLApi::MakeCurrent(GLContext* virtual_context, GLSurface* surface) {
   bool switched_contexts = g_current_gl_context != this;
-  GLSurface* current_surface = GLSurface::GetCurrent();
-  if (switched_contexts || surface != current_surface) {
-    if (!switched_contexts && current_surface &&
+  bool switched_surfaces = GLSurface::GetCurrent() != surface;

[brianderson, 2013/01/04 22:00:56]

Note:

This comparison is almost always false because I'm comparing the "real" surface
to the "virtual" surface, so this patch almost always restores the state on a
MakeCurrent.

That's a bit more often than I intended.

Other parts of the function compare these two surfaces though, which is where my
confusion came from.

Will need to figure out how to narrow down which case we need to restore the
state.  I'm not sure it's easy to detect FBO target changes from here.  Even if
we could detect it here, it'll probably be too late.

+  if (switched_contexts || switched_surfaces) {
+    if (!switched_contexts && GLSurface::GetCurrent() &&
         virtual_context->IsCurrent(surface)) {
       // MakeCurrent 'lite' path that avoids potentially expensive MakeCurrent()
       // calls if the GLSurface uses the same underlying surface or renders to
       // an FBO.
       if (!surface->OnMakeCurrent(real_context_)) {
         LOG(ERROR) << "Could not make GLSurface current.";
         return false;
       }
     } else if (!real_context_->MakeCurrent(surface)) {
       return false;
     }
   }
 
   DCHECK(GLSurface::GetCurrent());
   DCHECK(real_context_->IsCurrent(GLSurface::GetCurrent()));
   DCHECK(virtual_context->IsCurrent(surface));
 
-  if (switched_contexts || virtual_context != current_context_) {
+  // This work around restores gl state on virtual context switches
+  // where only the surface changes.
+  bool qualcomm_WAR_enabled = true;  // TODO: Set this only when needed.
+  bool use_qualcomm_WAR = qualcomm_WAR_enabled && switched_surfaces;
+
+  if (switched_contexts || virtual_context != current_context_ ||
+      use_qualcomm_WAR) {
     // There should be no errors from the previous context leaking into the
     // new context.
     DCHECK_EQ(glGetErrorFn(), static_cast<GLenum>(GL_NO_ERROR));
 
     current_context_ = virtual_context;
     // Set all state that is different from the real state
     // NOTE: !!! This is a temporary implementation that just restores all
     // state to let us test that it works.
     // TODO: ASAP, change this to something that only restores the state
     // needed for individual GL calls.
@@ skipping 14 matching lines @@
 const GLubyte* VirtualGLApi::glGetStringFn(GLenum name) {
   switch (name) {
     case GL_EXTENSIONS:
       return reinterpret_cast<const GLubyte*>(extensions_.c_str());
     default:
       return driver_->fn.glGetStringFn(name);
   }
 }
 
 }  // namespace gfx