Refactor GL bindings so there is no global GLApi or DriverGL.

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 <memory>
 #include <string>
 #include <vector>
@@ skipping 10 matching lines @@
 namespace gl {
 class YUVToRGBConverter;
 }  // namespace gl
 
 namespace gpu {
 class GLContextVirtual;
 }  // namespace gpu
 
 namespace gl {
 
+struct CurrentGL;
+class DebugGLApi;
+struct DriverGL;
+class GLApi;
 class GLSurface;
 class GPUTiming;
 class GPUTimingClient;
 struct GLVersionInfo;
+class RealGLApi;
+class TraceGLApi;
 
 struct GLContextAttribs {
   GpuPreference gpu_preference = PreferIntegratedGpu;
   bool bind_generates_resource = true;
   bool webgl_compatibility_context = false;
 };
 
 // Encapsulates an OpenGL context, hiding platform specific management.
 class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
  public:
@@ skipping 85 matching lines @@
 
   // Returns the GL version string. The context must be current.
   virtual std::string GetGLVersion();
 
   // Returns the GL renderer string. The context must be current.
   virtual std::string GetGLRenderer();
 
   // Returns a helper structure to convert YUV textures to RGB textures.
   virtual YUVToRGBConverter* GetYUVToRGBConverter();
 
+  // Get the CurrentGL object for this context containing the driver, version
+  // and API.
+  CurrentGL* GetCurrentGL();
+
  protected:
   virtual ~GLContext();
 
+  // Create the GLApi for this context using the provided driver. Creates a
+  // RealGLApi by default.
+  virtual GLApi* CreateGLApi(DriverGL* driver);
+
   // Will release the current context when going out of scope, unless canceled.
   class ScopedReleaseCurrent {
    public:
     ScopedReleaseCurrent();
     ~ScopedReleaseCurrent();
 
     void Cancel();
 
    private:
     bool canceled_;
   };
 
   // Sets the GL api to the real hardware API (vs the VirtualAPI)
-  static void SetRealGLApi();
+  void BindGLApi();
   virtual void SetCurrent(GLSurface* surface);
 
   // 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.
   void InitializeDynamicBindings();
 
   // Returns the last real (non-virtual) GLContext made current.
   static GLContext* GetRealCurrent();
 
   virtual void OnSetSwapInterval(int interval) = 0;
 
  private:
   friend class base::RefCounted<GLContext>;
 
   // For GetRealCurrent.
   friend class gpu::GLContextVirtual;
 
+  std::unique_ptr<GLVersionInfo> GenerateGLVersionInfo();
+
+  bool static_bindings_initialized_;
+  bool dynamic_bindings_initialized_;
+  std::unique_ptr<DriverGL> driver_gl_;
+  std::unique_ptr<GLApi> gl_api_;
+  std::unique_ptr<TraceGLApi> trace_gl_api_;
+  std::unique_ptr<DebugGLApi> debug_gl_api_;
+  std::unique_ptr<CurrentGL> current_gl_;
+
+  // Copy of the real API (if one was created) for dynamic initialization
+  RealGLApi* real_gl_api_ = nullptr;
+
   scoped_refptr<GLShareGroup> share_group_;
   GLContext* current_virtual_context_;
   bool state_dirtied_externally_;
   std::unique_ptr<GLStateRestorer> state_restorer_;
   std::unique_ptr<GLVersionInfo> version_info_;
 
   int swap_interval_;
   bool force_swap_interval_zero_;
 
   DISALLOW_COPY_AND_ASSIGN(GLContext);
@@ skipping 18 matching lines @@
 // scoped_refptr containing the initialized GLContext or nullptr if
 // initialization fails.
 GL_EXPORT scoped_refptr<GLContext> InitializeGLContext(
     scoped_refptr<GLContext> context,
     GLSurface* compatible_surface,
     const GLContextAttribs& attribs);
 
 }  // namespace gl
 
 #endif  // UI_GL_GL_CONTEXT_H_