ozone: Add OzoneSurface object that is owned by compositor, GLSurface

ui/gl/gl_surface_ozone.cc

 // Copyright 2014 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 "ui/gl/gl_surface.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/ozone/surface_factory_ozone.h"
+#include "ui/gfx/ozone/surface_ozone.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_surface_osmesa.h"
 #include "ui/gl/gl_surface_stub.h"
 
 namespace gfx {
 
+namespace {
+
+// A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow
+class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL {

[rjkroege, 2014/03/26 19:59:02]

it bothers me that there is a whole class here whose only reason for existing is
to add a scoped pointer for an ozone_surface_ 

what is the overlap between the EGLSurface and the SurfaceOzone? Could they be
the same?

[spang, 2014/03/26 22:21:28]

The point of SurfaceOzone is that platforms implement it.

It's not possible for ozone-based platforms to override GLSurface currently.
That is, unless you want to make major changes to the dependency structure.

If they could override the GLSurface itself, we absolutely would not need to do
this.

There is a strict-ownership relationship between
GLSurfaceOzoneEGL/SoftwareOutputDeviceOzone (platform-independent) and
SurfaceOzone (platform-dependent). We need that in order to tear things down at
the right time.

+ public:
+  GLSurfaceOzoneEGL(scoped_ptr<SurfaceOzone> ozone_surface)
+      : NativeViewGLSurfaceEGL(ozone_surface->GetEGLNativeWindow()),
+        ozone_surface_(ozone_surface.Pass()) {}
+
+  virtual ~GLSurfaceOzoneEGL() {
+    Destroy();  // EGL surface must be destroyed before SurfaceOzone
+  }
+
+ private:
+  // The native surface. Deleting this is allowed to free the EGLNativeWindow.
+  scoped_ptr<SurfaceOzone> ozone_surface_;
+
+  DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneEGL);
+};
+
+}  // namespace
+
 // 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());
     if (!surface->Initialize())
       return NULL;
     return surface;
   }
   DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
   if (window != kNullAcceleratedWidget) {
-    EGLNativeWindowType egl_window =
-        gfx::SurfaceFactoryOzone::GetInstance()->RealizeAcceleratedWidget(
-            window);
-    scoped_ptr<VSyncProvider> sync_provider =
-        gfx::SurfaceFactoryOzone::GetInstance()->CreateVSyncProvider(
-            egl_window);
-    scoped_refptr<NativeViewGLSurfaceEGL> surface =
-        new NativeViewGLSurfaceEGL(egl_window);
-    if (surface->Initialize(sync_provider.Pass()))
-      return surface;
+    scoped_ptr<SurfaceOzone> surface_ozone =
+        SurfaceFactoryOzone::GetInstance()->CreateSurfaceForWidget(window);
+    if (!surface_ozone->InitializeEGL())
+      return NULL;
+    scoped_refptr<GLSurfaceOzoneEGL> surface =
+        new GLSurfaceOzoneEGL(surface_ozone.Pass());
+    if (!surface->Initialize(surface_ozone->CreateVSyncProvider()))
+      return NULL;
+    return surface;
   } else {
     scoped_refptr<GLSurface> surface = new GLSurfaceStub();
     if (surface->Initialize())
       return surface;
   }
   return NULL;
 }
 
 // static
 scoped_refptr<GLSurface> GLSurface::CreateOffscreenGLSurface(
@@ skipping 22 matching lines @@
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return SurfaceFactoryOzone::GetInstance()->GetNativeDisplay();
 }
 
 }  // namespace gfx