[wip] ozonex: X11 backend for ozone.

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/overlay_transform.h"
 #include "ui/gfx/rect.h"
+#include "ui/platform_window/platform_window_delegate.h"
 
 class SkBitmap;
 class SkCanvas;
 
 namespace gfx {
 class VSyncProvider;
 class OverlayCandidatesOzone;
 class SurfaceOzoneCanvas;
 class SurfaceOzoneEGL;
 typedef intptr_t NativeBufferOzone;
@@ skipping 66 matching lines @@
   // This method must be safe to run inside of the sandbox.
   virtual void ShutdownHardware() = 0;
 
   // 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;
+  virtual intptr_t CreatePlatformWindow(ui::PlatformWindowDelegate*) = 0;
 
   // Create SurfaceOzoneEGL for the specified gfx::AcceleratedWidget.
   //
   // Note: When used from content, this is called in the GPU process. The
   // platform must support creation of SurfaceOzoneEGL from the GPU process
   // using only the handle contained in gfx::AcceleratedWidget.
   virtual scoped_ptr<SurfaceOzoneEGL> CreateEGLSurfaceForWidget(
-        gfx::AcceleratedWidget widget);
+      intptr_t widget);
 
   // Create SurfaceOzoneCanvas for the specified gfx::AcceleratedWidget.
   //
   // Note: The platform must support creation of SurfaceOzoneCanvas from the
   // Browser Process using only the handle contained in gfx::AcceleratedWidget.
-  virtual scoped_ptr<SurfaceOzoneCanvas> CreateCanvasForWidget(
-        gfx::AcceleratedWidget widget);
+  virtual scoped_ptr<SurfaceOzoneCanvas> CreateCanvasForWidget(intptr_t 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;
 
   // 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);
+  virtual gfx::OverlayCandidatesOzone* GetOverlayCandidates(intptr_t w);
 
   // Sets the overlay plane to switch to at the next page flip.
   // |plane_z_order| specifies the stacking order of the plane relative to the
   // main framebuffer located at index 0.
   // |plane_transform| specifies how the buffer is to be transformed during.
   // composition.
   // |buffer| to be presented by the overlay.
   // |display_bounds| specify where it is supposed to be on the screen.
   // |crop_rect| specifies the region within the buffer to be placed inside
   // |display_bounds|.
-  virtual void ScheduleOverlayPlane(gfx::AcceleratedWidget w,
+  virtual void ScheduleOverlayPlane(intptr_t w,
                                     int plane_z_order,
                                     gfx::OverlayTransform plane_transform,
                                     gfx::NativeBufferOzone buffer,
                                     const gfx::Rect& display_bounds,
                                     gfx::RectF crop_rect);
 
   // Cleate a single native buffer to be used for overlay planes.
   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_