Take GL version and extensions correctly into account when binding functions

content/common/gpu/media/rendering_helper.cc

 // Copyright 2013 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 "content/common/gpu/media/rendering_helper.h"
 
 #include "base/bind.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringize_macros.h"
 #include "base/synchronization/waitable_event.h"
 #include "ui/gl/gl_context.h"
-#include "ui/gl/gl_context_stub.h"
+#include "ui/gl/gl_context_stub_with_extensions.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 #ifdef GL_VARIANT_GLX
 typedef GLXWindow NativeWindowType;
 struct ScopedPtrXFree {
   void operator()(void* x) const { ::XFree(x); }
 };
 #else  // EGL
 typedef EGLNativeWindowType NativeWindowType;
@@ skipping 12 matching lines @@
   if (!result) {
     char log[4096];
     glGetShaderInfoLog(shader, arraysize(log), NULL, log);
     LOG(FATAL) << log;
   }
   glAttachShader(program, shader);
   glDeleteShader(shader);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 }
 
-namespace {
-
-// Lightweight GLContext stub implementation that returns a constructed
-// extensions string.  We use this to create a context that we can use to
-// initialize GL extensions with, without actually creating a platform context.
-class GLContextStubWithExtensions : public gfx::GLContextStub {
- public:
-  GLContextStubWithExtensions() {}
-  virtual std::string GetExtensions() OVERRIDE;
-
-  void AddExtensionsString(const char* extensions);
-
- protected:
-  virtual ~GLContextStubWithExtensions() {}
-
- private:
-  std::string extensions_;
-
-  DISALLOW_COPY_AND_ASSIGN(GLContextStubWithExtensions);
-};
-
-void GLContextStubWithExtensions::AddExtensionsString(const char* extensions) {
-  if (extensions == NULL)
-    return;
-
-  if (extensions_.size() != 0)
-    extensions_ += ' ';
-  extensions_ += extensions;
-}
-
-std::string GLContextStubWithExtensions::GetExtensions() {
-  return extensions_;
-}
-
-}  // anonymous
-
 namespace content {
 
 RenderingHelperParams::RenderingHelperParams() {}
 
 RenderingHelperParams::~RenderingHelperParams() {}
 
 static const gfx::GLImplementation kGLImplementation =
 #if defined(GL_VARIANT_GLX)
     gfx::kGLImplementationDesktopGL;
 #elif defined(GL_VARIANT_EGL)
@@ skipping 36 matching lines @@
 void RenderingHelper::Initialize(const RenderingHelperParams& params,
                                  base::WaitableEvent* done) {
   // Use window_dimensions_.size() != 0 as a proxy for the class having already
   // been Initialize()'d, and UnInitialize() before continuing.
   if (window_dimensions_.size()) {
     base::WaitableEvent done(false, false);
     UnInitialize(&done);
     done.Wait();
   }
 
-  gfx::InitializeGLBindings(kGLImplementation);
-  scoped_refptr<GLContextStubWithExtensions> stub_context(
-      new GLContextStubWithExtensions());
+  gfx::InitializeStaticGLBindings(kGLImplementation);
+  scoped_refptr<gfx::GLContextStubWithExtensions> stub_context(
+      new gfx::GLContextStubWithExtensions());
 
   CHECK_GT(params.window_dimensions.size(), 0U);
   CHECK_EQ(params.frame_dimensions.size(), params.window_dimensions.size());
   window_dimensions_ = params.window_dimensions;
   frame_dimensions_ = params.frame_dimensions;
   render_as_thumbnails_ = params.render_as_thumbnails;
   message_loop_ = base::MessageLoop::current();
   CHECK_GT(params.num_windows, 0);
 
 #if GL_VARIANT_GLX
@@ skipping 13 matching lines @@
       glXChooseFBConfig(x_display_, DefaultScreen(x_display_), fbconfig_attr,
                         &num_fbconfigs));
   CHECK(glx_fb_configs.get());
   CHECK_GT(num_fbconfigs, 0);
   x_visual_ = glXGetVisualFromFBConfig(x_display_, glx_fb_configs.get()[0]);
   CHECK(x_visual_);
   gl_context_ = glXCreateContext(x_display_, x_visual_, 0, true);
   CHECK(gl_context_);
   stub_context->AddExtensionsString(
       reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)));
+  stub_context->SetGLVersionString(
+      reinterpret_cast<const char*>(glGetString(GL_VERSION)));
 
 #else // EGL
   EGLNativeDisplayType native_display;
 
 #if defined(OS_WIN)
   native_display = EGL_DEFAULT_DISPLAY;
 #else
   x_display_ = base::MessagePumpForUI::GetDefaultXDisplay();
   CHECK(x_display_);
   native_display = x_display_;
@@ skipping 17 matching lines @@
       << eglGetError();
   CHECK_GE(num_configs, 1);
   static EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
   gl_context_ = eglCreateContext(
       gl_display_, egl_config, EGL_NO_CONTEXT, context_attribs);
   CHECK_NE(gl_context_, EGL_NO_CONTEXT) << eglGetError();
   stub_context->AddExtensionsString(
       reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)));
   stub_context->AddExtensionsString(
       eglQueryString(gl_display_, EGL_EXTENSIONS));
+  stub_context->SetGLVersionString(
+      reinterpret_cast<const char*>(glGetString(GL_VERSION)));
 #endif
 
   // Per-window/surface X11 & EGL initialization.
   for (int i = 0; i < params.num_windows; ++i) {
     // Arrange X windows whimsically, with some padding.
     int j = i % window_dimensions_.size();
     int width = window_dimensions_[j].width();
     int height = window_dimensions_[j].height();
     CHECK_GT(width, 0);
     CHECK_GT(height, 0);
@@ skipping 35 matching lines @@
 #if GL_VARIANT_EGL
     EGLSurface egl_surface =
         eglCreateWindowSurface(gl_display_, egl_config, window, NULL);
     gl_surfaces_.push_back(egl_surface);
     CHECK_NE(egl_surface, EGL_NO_SURFACE);
 #endif
     MakeCurrent(i);
   }
 
   // Must be done after a context is made current.
-  gfx::InitializeGLExtensionBindings(kGLImplementation, stub_context.get());
+  gfx::InitializeDynamicGLBindings(kGLImplementation, stub_context.get());
 
   if (render_as_thumbnails_) {
     CHECK_EQ(window_dimensions_.size(), 1U);
 
     GLint max_texture_size;
     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
     CHECK_GE(max_texture_size, params.thumbnails_page_size.width());
     CHECK_GE(max_texture_size, params.thumbnails_page_size.height());
 
     thumbnails_fbo_size_ = params.thumbnails_page_size;
@@ skipping 314 matching lines @@
     *rgb_ptr++ = *rgba_ptr++;
     solid = solid && (*rgba_ptr == 0xff);
     rgba_ptr++;
   }
   *alpha_solid = solid;
 
   done->Signal();
 }
 
 }  // namespace content