Split EGLContext in GLContextEGL and GLSurfaceEGL.

ui/gfx/gl/gl_context_linux.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 ViewGLContext and PbufferGLContext classes.
 
 #include "ui/gfx/gl/gl_context.h"
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 
 #include <GL/osmesa.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/x/x11_util.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 {
 
 Display* GetXDisplayHelper() {
   static Display* display = NULL;
 
   if (!display) {
     display = XOpenDisplay(NULL);
     CHECK(display);
   }
@@ skipping 176 matching lines @@
         return false;
       }
 
       if (major == 1 && minor < 3) {
         LOG(WARNING) << "GLX 1.3 or later is recommended.";
       }
 
       break;
     }
     case kGLImplementationEGLGLES2:
-      if (!BaseEGLContext::InitializeOneOff()) {
-        LOG(ERROR) << "BaseEGLContext::InitializeOneOff failed.";
+      if (!GLSurfaceEGL::InitializeOneOff()) {
+        LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
         return false;
       }
       break;
     default:
       break;
   }
 
   initialized = true;
   return true;
 }
@@ skipping 276 matching lines @@
   switch (GetGLImplementation()) {
     case kGLImplementationDesktopGL: {
       scoped_ptr<ViewGLContext> context(new ViewGLContext(window));
 
       if (!context->Initialize(multisampled))
         return NULL;
 
       return context.release();
     }
     case kGLImplementationEGLGLES2: {
-      scoped_ptr<NativeViewEGLContext> context(
-          new NativeViewEGLContext(reinterpret_cast<void *>(window)));
-      if (!context->Initialize())
+      scoped_ptr<NativeViewGLSurfaceEGL> surface(new NativeViewGLSurfaceEGL(
+          reinterpret_cast<void*>(window)));
+      if (!surface->Initialize())
+        return NULL;
+
+      scoped_ptr<GLContextEGL> context(
+          new GLContextEGL(surface.release()));
+      if (!context->Initialize(NULL))
         return NULL;
 
       return context.release();
     }
     case kGLImplementationOSMesaGL: {
       scoped_ptr<OSMesaViewGLContext> context(new OSMesaViewGLContext(window));
 
       if (!context->Initialize())
         return NULL;
 
@@ skipping 267 matching lines @@
       if (context->Initialize(shared_context))
         return context.release();
 
       scoped_ptr<PixmapGLContext> context_pixmap(new PixmapGLContext);
       if (context_pixmap->Initialize(shared_context))
         return context_pixmap.release();
 
       return NULL;
     }
     case kGLImplementationEGLGLES2: {
-      scoped_ptr<SecondaryEGLContext> context(
-          new SecondaryEGLContext());
+      scoped_ptr<PbufferGLSurfaceEGL> surface(new PbufferGLSurfaceEGL(
+          gfx::Size(1, 1)));
+      if (!surface->Initialize())
+        return NULL;
+
+      scoped_ptr<GLContextEGL> context(new GLContextEGL(surface.release()));
       if (!context->Initialize(shared_context))
         return NULL;
 
       return context.release();
     }
     case kGLImplementationOSMesaGL: {
       scoped_ptr<OSMesaGLContext> context(new OSMesaGLContext);
       if (!context->Initialize(OSMESA_RGBA, shared_context))
         return NULL;
 
       return context.release();
     }
     case kGLImplementationMockGL:
       return new StubGLContext;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 }  // namespace gfx