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

ui/gfx/ozone/surface_factory_ozone.h

Index: ui/gfx/ozone/surface_factory_ozone.h
diff --git a/ui/gfx/ozone/surface_factory_ozone.h b/ui/gfx/ozone/surface_factory_ozone.h
index fffdba6f8530e60666e4fc44098874a0629c0aa6..26cb7607706709e9ce3e8947d47a38cc0ff71f5f 100644
--- a/ui/gfx/ozone/surface_factory_ozone.h
+++ b/ui/gfx/ozone/surface_factory_ozone.h
@@ -20,6 +20,7 @@ class SkCanvas;
 namespace gfx {
 class VSyncProvider;
 class OverlayCandidatesOzone;
+class SurfaceOzone;
 typedef intptr_t NativeBufferOzone;
 
 // The Ozone interface allows external implementations to hook into Chromium to
@@ -109,11 +110,9 @@ class GFX_EXPORT SurfaceFactoryOzone {
   // before it can be used to create a GL surface.
   virtual gfx::AcceleratedWidget GetAcceleratedWidget() = 0;
 
-  // Realizes an AcceleratedWidget so that the returned AcceleratedWidget
-  // can be used to to create a GLSurface. This method may only be called in
-  // a process that has a valid GL context.
-  virtual gfx::AcceleratedWidget RealizeAcceleratedWidget(
-      gfx::AcceleratedWidget w) = 0;
+  // Create a surface for the specified gfx::AcceleratedWidget.

[rjkroege, 2014/03/24 16:07:04]

you removed the text about needing a valid graphics context. I think something
more nuanced is needed. In particular: can one usefully build a useful
SurfaceOzone outside of the GPU process if the implementation is EGL-based?

[spang, 2014/03/24 16:42:11]

The language was wrong. SoftwareOutputDeviceOzone uses this and has no GL
context.

We can put the language at SurfaceOzone::InitializeEGL(), and require that you
have GL bindings initialized before trying to create the EGL native window.

Is such a requirement useful? That is, can we think of platforms that need it?

The native window is a:

X11 - Window. Don't need GL bindings to create this.
Android - ANativeWindow. Don't need GL bindings to create this.
Windows - HWND. Don't need GL bindings to create this.

It doesn't seem to me like this actually matters. It seems that in general, you
do not need GL bindings initialized to create the EGLNativeWindow.

[rjkroege, 2014/03/24 20:23:15]

OK. The point that I wanted captured in the documentation is that the
SurfaceOzone you get back from this call might not be particularly useful for
rendering if created in the browser process.

Can SurfaceOzone pointers be passed usefully between processes? I would think
not. If so, it seems worth noting that the consumer must make its SurfaceOzone
in the process where it intends to use it.

[spang, 2014/03/24 21:58:28]

Yeah, can't be passed between processes. That's what gfx::AcceleratedWidget is
for.

Updated with a blurb about GPU sometimes being out-of-process.

+  virtual scoped_ptr<SurfaceOzone> CreateSurfaceForWidget(
+      gfx::AcceleratedWidget widget);
 
   // Sets up GL bindings for the native surface. Takes two callback parameters
   // that allow Ozone to register the GL bindings.
@@ -121,31 +120,6 @@ class GFX_EXPORT SurfaceFactoryOzone {
       AddGLLibraryCallback add_gl_library,
       SetGLGetProcAddressProcCallback set_gl_get_proc_address) = 0;
 
-  // If possible attempts to resize the given AcceleratedWidget instance and if
-  // a resize action was performed returns true, otherwise false (native
-  // hardware may only support a single fixed size).
-  virtual bool AttemptToResizeAcceleratedWidget(
-      gfx::AcceleratedWidget w,
-      const gfx::Rect& bounds) = 0;
-
-  // Called after the appropriate GL swap buffers command. Used if extra work
-  // is needed to perform the actual buffer swap.
-  virtual bool SchedulePageFlip(gfx::AcceleratedWidget w);
-
-  // Returns a SkCanvas for the backing buffers. Drawing to the canvas will draw
-  // to the native surface. The canvas is intended for use when no EGL
-  // acceleration is possible. Its implementation is optional when an EGL
-  // backend is provided for rendering.
-  virtual SkCanvas* GetCanvasForWidget(gfx::AcceleratedWidget w);
-
-  // Returns a gfx::VsyncProvider for the provided AcceleratedWidget. Note
-  // that this may be called after we have entered the sandbox so if there are
-  // operations (e.g. opening a file descriptor providing vsync events) that
-  // must be done outside of the sandbox, they must have been completed
-  // in InitializeHardware. Returns an empty scoped_ptr on error.
-  virtual scoped_ptr<gfx::VSyncProvider> CreateVSyncProvider(
-      gfx::AcceleratedWidget w) = 0;
-
   // Returns an array of EGL properties, which can be used in any EGL function
   // used to select a display configuration. Note that all properties should be
   // immediately followed by the corresponding desired value and array should be