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"
@@ skipping 36 matching lines @@
 
 // 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);
+  void SetGLVersionString(const char* version_str);
 
  protected:
+  virtual std::string GetGLVersion() OVERRIDE;
+
   virtual ~GLContextStubWithExtensions() {}
 
  private:
   std::string extensions_;
+  std::string version_str_;
 
   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_;
 }
 
+void GLContextStubWithExtensions::SetGLVersionString(const char* version_str) {
+  version_str_ = std::string(version_str ? version_str : "");
+}
+
+std::string GLContextStubWithExtensions::GetGLVersion() {
+  return version_str_;
+}
+
 }  // anonymous
 
 namespace content {
 
 RenderingHelperParams::RenderingHelperParams() {}
 
 RenderingHelperParams::~RenderingHelperParams() {}
 
 static const gfx::GLImplementation kGLImplementation =
 #if defined(GL_VARIANT_GLX)
@@ skipping 38 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);
+  gfx::InitializeStaticGLBindings(kGLImplementation);
   scoped_refptr<GLContextStubWithExtensions> stub_context(
       new 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);
@@ skipping 15 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