Split EGLContext in GLContextEGL and GLSurfaceEGL.

ui/gfx/gl/gl_context_win.cc

 // Copyright (c) 2011 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.
 
 // This file implements the NativeViewGLContext and PbufferGLContext classes.
 
 #include "ui/gfx/gl/gl_context.h"
 
 #include <GL/osmesa.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_context_egl.h"
 #include "ui/gfx/gl/gl_context_osmesa.h"
 #include "ui/gfx/gl/gl_context_stub.h"
 #include "ui/gfx/gl/gl_implementation.h"
+#include "ui/gfx/gl/gl_surface_egl.h"
 
 namespace gfx {
 
 typedef HGLRC GLContextHandle;
 typedef HPBUFFERARB PbufferHandle;
 
 class BaseWinGLContext : public GLContext {
  public:
   virtual std::string GetExtensions();
 
@@ skipping 95 matching lines @@
   HDC device_context_;
   PbufferHandle pbuffer_;
 
   DISALLOW_COPY_AND_ASSIGN(PbufferGLContext);
 };
 
 static HWND g_window;
 static int g_regular_pixel_format = 0;
 static int g_multisampled_pixel_format = 0;
 
-// When using ANGLE we still need a window for D3D. This context creates the
-// D3D device.
-static BaseEGLContext* g_default_context;
-
 const PIXELFORMATDESCRIPTOR kPixelFormatDescriptor = {
   sizeof(kPixelFormatDescriptor),    // Size of structure.
   1,                       // Default version.
   PFD_DRAW_TO_WINDOW |     // Window drawing support.
   PFD_SUPPORT_OPENGL |     // OpenGL support.
   PFD_DOUBLEBUFFER,        // Double buffering support (not stereo).
   PFD_TYPE_RGBA,           // RGBA color mode (not indexed).
   24,                      // 24 bit color mode.
   0, 0, 0, 0, 0, 0,        // Don't set RGB bits & shifts.
   8, 0,                    // 8 bit alpha
@@ skipping 157 matching lines @@
       }
 
       wglMakeCurrent(intermediate_dc, NULL);
       wglDeleteContext(gl_context);
       ReleaseDC(g_window, intermediate_dc);
       UnregisterClass(reinterpret_cast<wchar_t*>(class_registration),
                       module_handle);
       break;
     }
     case kGLImplementationEGLGLES2:
-      if (!BaseEGLContext::InitializeOneOff()) {
-        LOG(ERROR) << "BaseEGLContext::InitializeOneOff failed.";
+      if (!GLSurfaceEGL::InitializeOneOff()) {
+        LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
         return false;
       }
       break;
   }
 
   initialized = true;
   return true;
 }
 
 
@@ skipping 216 matching lines @@
                                           bool multisampled) {
   switch (GetGLImplementation()) {
     case kGLImplementationOSMesaGL: {
       scoped_ptr<OSMesaViewGLContext> context(new OSMesaViewGLContext(window));
       if (!context->Initialize())
         return NULL;
 
       return context.release();
     }
     case kGLImplementationEGLGLES2: {
-      scoped_ptr<NativeViewEGLContext> context(
-          new NativeViewEGLContext(window));
-      if (!context->Initialize())
+      scoped_ptr<NativeViewGLSurfaceEGL> surface(new NativeViewGLSurfaceEGL(
+          window));
+      if (!surface->Initialize())
+        return NULL;
+
+      scoped_ptr<GLContextEGL> context(
+          new GLContextEGL(surface.release()));
+      if (!context->Initialize(NULL))
         return NULL;
 
       return context.release();
     }
     case kGLImplementationDesktopGL: {
       scoped_ptr<NativeViewGLContext> context(new NativeViewGLContext(window));
       if (!context->Initialize(multisampled))
         return NULL;
 
       return context.release();
@@ skipping 132 matching lines @@
 GLContext* GLContext::CreateOffscreenGLContext(GLContext* shared_context) {
   switch (GetGLImplementation()) {
     case kGLImplementationOSMesaGL: {
       scoped_ptr<OSMesaGLContext> context(new OSMesaGLContext);
       if (!context->Initialize(OSMESA_RGBA, shared_context))
         return NULL;
 
       return context.release();
     }
     case kGLImplementationEGLGLES2: {
-      if (!shared_context) {
-        if (!g_default_context) {
-          scoped_ptr<NativeViewEGLContext> default_context(
-              new NativeViewEGLContext(g_window));
-          if (!default_context->Initialize())
-            return NULL;
+      scoped_ptr<PbufferGLSurfaceEGL> surface(new PbufferGLSurfaceEGL(
+          gfx::Size(1, 1)));
+      if (!surface->Initialize())
+        return NULL;
 
-          g_default_context = default_context.release();
-        }
-        shared_context = g_default_context;
-      }
-
-      scoped_ptr<SecondaryEGLContext> context(
-          new SecondaryEGLContext());
+      scoped_ptr<GLContextEGL> context(new GLContextEGL(surface.release()));
       if (!context->Initialize(shared_context))
         return NULL;
 
       return context.release();
     }
     case kGLImplementationDesktopGL: {
       scoped_ptr<PbufferGLContext> context(new PbufferGLContext);
       if (!context->Initialize(shared_context))
         return NULL;
 
       return context.release();
     }
     case kGLImplementationMockGL:
       return new StubGLContext;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 }  // namespace gfx