Take GL version and extensions correctly into account when binding functions

ui/gl/gl_context.h

 // 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.
 
 #ifndef UI_GL_GL_CONTEXT_H_
 #define UI_GL_GL_CONTEXT_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_state_restorer.h"
 #include "ui/gl/gpu_preference.h"
 
 namespace gfx {
 
 class GLSurface;
 class VirtualGLApi;
+struct GLVersionInfo;
 
 // Encapsulates an OpenGL context, hiding platform specific management.
 class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
  public:
   explicit GLContext(GLShareGroup* share_group);
 
   // Initializes the GL context to be compatible with the given surface. The GL
   // context can be made with other surface's of the same type. The compatible
   // surface is only needed for certain platforms like WGL, OSMesa and GLX. It
   // should be specific for all platforms though.
@@ skipping 38 matching lines @@
   virtual void SetSafeToForceGpuSwitch();
 
   // Indicate that the real context switches should unbind the FBO first
   // (For an Android work-around only).
   virtual void SetUnbindFboOnMakeCurrent();
 
   // Returns whether the current context supports the named extension. The
   // context must be current.
   bool HasExtension(const char* name);
 
+  // Returns version info of the underlying GL context. The context must be
+  // current.
+  const GLVersionInfo* GetVersionInfo();
+
   GLShareGroup* share_group();
 
   // Create a GL context that is compatible with the given surface.
   // |share_group|, if non-NULL, is a group of contexts which the
   // internally created OpenGL context shares textures and other resources.
   static scoped_refptr<GLContext> CreateGLContext(
       GLShareGroup* share_group,
       GLSurface* compatible_surface,
       GpuPreference gpu_preference);
 
@@ skipping 14 matching lines @@
   // being released or destroyed.
   void OnReleaseVirtuallyCurrent(GLContext* virtual_context);
 
  protected:
   virtual ~GLContext();
 
   // Sets the GL api to the real hardware API (vs the VirtualAPI)
   static void SetRealGLApi();
   virtual void SetCurrent(GLSurface* surface);
 
-  // Initialize function pointers to extension functions in the GL
-  // implementation. Should be called immediately after this context is made
-  // current.
-  bool InitializeExtensionBindings();
+  // Initialize function pointers to functions where the bound version depends
+  // on GL version or supported extensions. Should be called immediately after
+  // this context is made current.
+  bool InitializeDynamicBindings();

[no sievers, 2013/12/05 20:51:57]

Is a call to this missing in GLContextNSView::MakeCurrent()?

[no sievers, 2013/12/05 21:07:17]

I also suggest that we initialize the dynamic bindings more explicitly since
doing it this way in GLContext is just flaky. In gpu_main.cc and
gpu_child_thread.cc we already make a context current for most cases (see
gpu_main.cc and CollectContextGraphicsInfo(), and for Windows we actually need
the context current already for binding core functions, it seems). We could
maybe also do it in GpuChildThread::OnInitialize().

It has nothing to do with your patch directly though and we can do it as a
follow-up.

[oetuaho, 2013/12/09 17:17:07]

Yeah, after seeing the gpu_main.cc code it looks like the context could just
always be initialized from there after minimal bindings needed for that are
done, so some of this complexity would be avoided.

You're right about the GLContextNSView, it looks like a call needs to be added.

 
   // Returns the last real (non-virtual) GLContext made current.
   static GLContext* GetRealCurrent();
 
+  // Returns the GL version string. The context must be current.
+  virtual std::string GetGLVersion();
+
  private:
   friend class base::RefCounted<GLContext>;
 
   // For GetRealCurrent.
   friend class VirtualGLApi;
 
   scoped_refptr<GLShareGroup> share_group_;
   scoped_ptr<VirtualGLApi> virtual_gl_api_;
   scoped_ptr<GLStateRestorer> state_restorer_;
+  scoped_ptr<GLVersionInfo> version_info_;
 
   DISALLOW_COPY_AND_ASSIGN(GLContext);
 };
 
 class GL_EXPORT GLContextReal : public GLContext {
  public:
   explicit GLContextReal(GLShareGroup* share_group);
 
  protected:
   virtual ~GLContextReal();
 
   virtual void SetCurrent(GLSurface* surface) OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GLContextReal);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GL_GL_CONTEXT_H_