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

ui/gfx/ozone/surface_factory_ozone.h

 // Copyright (c) 2013 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.
 
 #ifndef UI_GFX_OZONE_SURFACE_LNUX_FACTORY_OZONE_H_
 #define UI_GFX_OZONE_SURFACE_LNUX_FACTORY_OZONE_H_
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/native_library.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/gfx_export.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/rect.h"
 
 class SkBitmap;
 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
 // provide a system specific implementation. The Ozone interface supports two
 // drawing modes: 1) accelerated drawing through EGL and 2) software drawing
 // through Skia.
 //
 // The following functionality is specific to the drawing mode and may not have
 // any meaningful implementation in the other mode. An implementation must
 // provide functionality for at least one mode.
@@ skipping 69 matching lines @@
 
   // Returns native platform display handle. This is used to obtain the EGL
   // display connection for the native display.
   virtual intptr_t GetNativeDisplay();
 
   // Obtains an AcceleratedWidget backed by a native Linux framebuffer.
   // The  returned AcceleratedWidget is an opaque token that must realized
   // 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.
   virtual bool LoadEGLGLES2Bindings(
       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
   // terminated with EGL_NONE. Ownership of the array is not transferred to
   // caller. desired_list contains list of desired EGL properties and values.
   virtual const int32* GetEGLSurfaceProperties(const int32* desired_list);
 
   // Get the hal struct to check for overlay support.
   virtual gfx::OverlayCandidatesOzone* GetOverlayCandidates(
       gfx::AcceleratedWidget w);
@@ skipping 18 matching lines @@
   virtual gfx::NativeBufferOzone CreateNativeBuffer(gfx::Size size,
                                                     BufferFormat format);
 
  private:
   static SurfaceFactoryOzone* impl_; // not owned
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_OZONE_SURFACE_LNUX_FACTORY_OZONE_H_