gpu: Bind dummy GL API when no context is current

ui/gl/gl_context_egl.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_egl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
@@ skipping 97 matching lines @@
                       context_)) {
     DVLOG(1) << "eglMakeCurrent failed with error "
              << GetLastEGLErrorString();
     return false;
   }
 
   // Set this as soon as the context is current, since we might call into GL.
   SetRealGLApi();
 
   SetCurrent(surface);
+  ScopedReleaseCurrent release_current(this, surface);
+
   if (!InitializeDynamicBindings()) {
-    ReleaseCurrent(surface);
     return false;
   }
 
   if (!surface->OnMakeCurrent(this)) {

[no sievers, 2014/04/01 22:51:32]

I guess you could argue whether we should really ReleaseCurrent() here. wdyt?

[piman, 2014/04/01 23:00:02]

yes.

[no sievers, 2014/04/01 23:39:37]

Or should this be stronger and release any context that was previously current?
With my current patch we will take the early-out in ReleaseCurrent() below if
either |this| is not current, or |this| is not current with |surface|.

wglMakeCurrent() and eglMakeCurrent() seem to say that a previously current GL
context is released even if MakeCurrent() fails.

Unfortunately, glxMakeCurrent() says "If False is returned, the previously
current rendering context and drawable (if any) remain unchanged."

However we could make the behavior compatible here.

[no sievers, 2014/04/01 23:47:23]

Actually, I just realized that this comment doesn't make sense.
However, I think I can still make the release logic simpler/static.

[piman, 2014/04/01 23:50:58]

I think it's best if we can have consistent semantics. If GLContext::MakeCurrent
fails, then the semantics is that no context is current (I think that's the only
semantics we can guarantee).

[no sievers, 2014/04/01 23:51:56]

So what I'll do is make this consistent. Essentially making sure that even the
failure paths like line 111 above guarantee SetCurrent(NULL) (plus releasing the
current context where necessary).

Sound good?

One caveat: I noticed a while ago that GLContextOSMesa::ReleaseCurrent() is
actually broken because OSMesaMakeCurrent(NULL, NULL..) does not work.

You can only make current a valid context. We'd have to create a dummy one, or
fix mesa. It definitely makes things flaky because it keeps it referenced on the
thread.

     LOG(ERROR) << "Could not make current.";
     return false;
   }
 
+  release_current.Release();
   return true;
 }
 
 void GLContextEGL::SetUnbindFboOnMakeCurrent() {
   unbind_fbo_on_makecurrent_ = true;
 }
 
 void GLContextEGL::ReleaseCurrent(GLSurface* surface) {
   if (!IsCurrent(surface))
     return;
@@ skipping 60 matching lines @@
 
 #if !defined(OS_ANDROID)
 bool GLContextEGL::GetTotalGpuMemory(size_t* bytes) {
   DCHECK(bytes);
   *bytes = 0;
   return false;
 }
 #endif
 
 }  // namespace gfx