gl: Clean up gfx::AcceleratedWidget usage in gl_surface_egl

ui/gl/gl_surface_egl.cc

 // 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.
 
 // This include must be here so that the includes provided transitively
 // by gl_surface_egl.h don't make it impossible to compile this code.
 #include "third_party/mesa/src/include/GL/osmesa.h"
 
 #include "ui/gl/gl_surface_egl.h"
 
@@ skipping 312 matching lines @@
 bool GLSurfaceEGL::HasEGLExtension(const char* name) {
   return ExtensionsContain(GetEGLExtensions(), name);
 }
 
 bool GLSurfaceEGL::IsCreateContextRobustnessSupported() {
   return g_egl_create_context_robustness_supported;
 }
 
 GLSurfaceEGL::~GLSurfaceEGL() {}
 
-NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(gfx::AcceleratedWidget window)
+NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(EGLNativeWindowType window)
     : window_(window),
       surface_(NULL),
       supports_post_sub_buffer_(false),
       config_(NULL),
       size_(1, 1) {
 #if defined(OS_ANDROID)
   if (window)
     ANativeWindow_acquire(window);
 #endif
 }
 
 bool NativeViewGLSurfaceEGL::Initialize() {
   return Initialize(scoped_ptr<VSyncProvider>());
 }
 
 bool NativeViewGLSurfaceEGL::Initialize(
     scoped_ptr<VSyncProvider> sync_provider) {
   DCHECK(!surface_);
 
-  if (window_ == kNullAcceleratedWidget) {

[rjkroege, 2014/03/20 17:52:04]

why did you take this out?

[spang, 2014/03/20 19:06:44]

I don't believe there is a NULL value for EGLNativeWindowType in the spec.

So if we need this check, it has to happen a little bit earlier.

-    LOG(ERROR) << "Trying to create surface without window.";
-    return false;
-  }
-
   if (!GetDisplay()) {
     LOG(ERROR) << "Trying to create surface with invalid display.";
     return false;
   }
 
   std::vector<EGLint> egl_window_attributes;
 
   if (g_egl_window_fixed_size_supported) {
     egl_window_attributes.push_back(EGL_FIXED_SIZE_ANGLE);
     egl_window_attributes.push_back(EGL_TRUE);
@@ skipping 398 matching lines @@
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 #if defined(ANDROID) || defined(USE_OZONE)
 
 // A thin subclass of |GLSurfaceOSMesa| that can be used in place
 // of a native hardware-provided surface when a native surface
 // provider is not available.
 class GLSurfaceOSMesaHeadless : public GLSurfaceOSMesa {
  public:
-  explicit GLSurfaceOSMesaHeadless(gfx::AcceleratedWidget window);
+  explicit GLSurfaceOSMesaHeadless();

[rjkroege, 2014/03/20 17:52:04]

why not EGLNativeWindow?

[spang, 2014/03/20 19:06:44]

We could, but why pass a value that is not used?

 
   virtual bool IsOffscreen() OVERRIDE;
   virtual bool SwapBuffers() OVERRIDE;
 
  protected:
   virtual ~GLSurfaceOSMesaHeadless();
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOSMesaHeadless);
 };
 
 bool GLSurfaceOSMesaHeadless::IsOffscreen() { return false; }
 
 bool GLSurfaceOSMesaHeadless::SwapBuffers() { return true; }
 
-GLSurfaceOSMesaHeadless::GLSurfaceOSMesaHeadless(gfx::AcceleratedWidget window)
-    : GLSurfaceOSMesa(OSMESA_BGRA, gfx::Size(1, 1)) {
-  DCHECK(window);
-}
+GLSurfaceOSMesaHeadless::GLSurfaceOSMesaHeadless()
+    : GLSurfaceOSMesa(OSMESA_BGRA, gfx::Size(1, 1)) {}
 
 GLSurfaceOSMesaHeadless::~GLSurfaceOSMesaHeadless() { Destroy(); }
 
 // static
 bool GLSurface::InitializeOneOffInternal() {
   switch (GetGLImplementation()) {
     case kGLImplementationEGLGLES2:
       if (!GLSurfaceEGL::InitializeOneOff()) {
         LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
         return false;
       }
     default:
       break;
   }
   return true;
 }
 
 // static
 scoped_refptr<GLSurface>
 GLSurface::CreateViewGLSurface(gfx::AcceleratedWidget window) {
 
   if (GetGLImplementation() == kGLImplementationOSMesaGL) {
-    scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless(window));
+    scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless());
     if (!surface->Initialize())
       return NULL;
     return surface;
   }
   DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
-  if (window) {
+  if (window != kNullAcceleratedWidget) {
+    EGLNativeWindowType egl_window;
     scoped_refptr<NativeViewGLSurfaceEGL> surface;
     scoped_ptr<VSyncProvider> sync_provider;
 #if defined(USE_OZONE)
-    window = gfx::SurfaceFactoryOzone::GetInstance()->RealizeAcceleratedWidget(
-        window);
+    egl_window =
+        gfx::SurfaceFactoryOzone::GetInstance()->RealizeAcceleratedWidget(
+            window);
     sync_provider =
-        gfx::SurfaceFactoryOzone::GetInstance()->CreateVSyncProvider(window);
+        gfx::SurfaceFactoryOzone::GetInstance()->CreateVSyncProvider(
+            egl_window);
+#else
+    egl_window = window;
 #endif
-    surface = new NativeViewGLSurfaceEGL(window);
+    surface = new NativeViewGLSurfaceEGL(egl_window);
     if(surface->Initialize(sync_provider.Pass()))
       return surface;
   } else {
     scoped_refptr<GLSurface> surface = new GLSurfaceStub();
     if (surface->Initialize())
       return surface;
   }
   return NULL;
 }
 
@@ skipping 22 matching lines @@
     }
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 #endif
 
 }  // namespace gfx