ui/ozone/public/surface_factory_ozone.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef UI_OZONE_PUBLIC_SURFACE_FACTORY_OZONE_H_
   6 #define UI_OZONE_PUBLIC_SURFACE_FACTORY_OZONE_H_
   7
   8 #include "base/callback.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/native_library.h"
  11 #include "ui/gfx/geometry/rect.h"
  12 #include "ui/gfx/native_widget_types.h"
  13 #include "ui/gfx/overlay_transform.h"
  14 #include "ui/ozone/ozone_base_export.h"
  15
  16 namespace ui {
  17
  18 class NativePixmap;
  19 class SurfaceOzoneCanvas;
  20 class SurfaceOzoneEGL;
  21
  22 // The Ozone interface allows external implementations to hook into Chromium to
  23 // provide a system specific implementation. The Ozone interface supports two
  24 // drawing modes: 1) accelerated drawing through EGL and 2) software drawing
  25 // through Skia.
  26 //
  27 // If you want to paint on a window with ozone, you need to create a
  28 // SurfaceOzoneEGL or SurfaceOzoneCanvas for that window. The platform can
  29 // support software, EGL, or both for painting on the window.
  30 // The following functionality is specific to the drawing mode and may not have
  31 // any meaningful implementation in the other mode. An implementation must
  32 // provide functionality for at least one mode.
  33 //
  34 // 1) Accelerated Drawing (EGL path):
  35 //
  36 // The following functions are specific to EGL:
  37 //  - GetNativeDisplay
  38 //  - LoadEGLGLES2Bindings
  39 //  - GetEGLSurfaceProperties (optional if the properties match the default
  40 //  Chromium ones).
  41 //  - CreateEGLSurfaceForWidget
  42 //
  43 // 2) Software Drawing (Skia):
  44 //
  45 // The following function is specific to the software path:
  46 //  - CreateCanvasForWidget
  47 //
  48 // The accelerated path can optionally provide support for the software drawing
  49 // path.
  50 //
  51 // The remaining functions are not covered since they are needed in both drawing
  52 // modes (See comments bellow for descriptions).
  53 class OZONE_BASE_EXPORT SurfaceFactoryOzone {
  54  public:
  55   // Describes overlay buffer format.
  56   // TODO: this is a placeholder for now and will be populated with more
  57   // formats once we know what sorts of content, video, etc. we can support.
  58   enum BufferFormat {
  59     UNKNOWN,
  60     BGRA_8888,
  61     RGBX_8888,
  62     BUFFER_FORMAT_LAST = RGBX_8888
  63   };
  64
  65   enum BufferUsage {
  66     MAP,
  67     PERSISTENT_MAP,
  68     SCANOUT,
  69   };
  70
  71   typedef void* (*GLGetProcAddressProc)(const char* name);
  72   typedef base::Callback<void(base::NativeLibrary)> AddGLLibraryCallback;
  73   typedef base::Callback<void(GLGetProcAddressProc)>
  74       SetGLGetProcAddressProcCallback;
  75
  76   // Returns native platform display handle. This is used to obtain the EGL
  77   // display connection for the native display.
  78   virtual intptr_t GetNativeDisplay();
  79
  80   // Create SurfaceOzoneEGL for the specified gfx::AcceleratedWidget.
  81   //
  82   // Note: When used from content, this is called in the GPU process. The
  83   // platform must support creation of SurfaceOzoneEGL from the GPU process
  84   // using only the handle contained in gfx::AcceleratedWidget.
  85   virtual scoped_ptr<SurfaceOzoneEGL> CreateEGLSurfaceForWidget(
  86       gfx::AcceleratedWidget widget);
  87
  88   // Create an EGL surface that isn't backed by any buffers, and is used
  89   // for overlay-only displays. This will return NULL if this mode is
  90   // not supported.
  91   virtual scoped_ptr<SurfaceOzoneEGL> CreateSurfacelessEGLSurfaceForWidget(
  92       gfx::AcceleratedWidget widget);
  93
  94   // Create SurfaceOzoneCanvas for the specified gfx::AcceleratedWidget.
  95   //
  96   // Note: The platform must support creation of SurfaceOzoneCanvas from the
  97   // Browser Process using only the handle contained in gfx::AcceleratedWidget.
  98   virtual scoped_ptr<SurfaceOzoneCanvas> CreateCanvasForWidget(
  99       gfx::AcceleratedWidget widget);
 100
 101   // Sets up GL bindings for the native surface. Takes two callback parameters
 102   // that allow Ozone to register the GL bindings.
 103   virtual bool LoadEGLGLES2Bindings(
 104       AddGLLibraryCallback add_gl_library,
 105       SetGLGetProcAddressProcCallback set_gl_get_proc_address) = 0;
 106
 107   // Returns an array of EGL properties, which can be used in any EGL function
 108   // used to select a display configuration. Note that all properties should be
 109   // immediately followed by the corresponding desired value and array should be
 110   // terminated with EGL_NONE. Ownership of the array is not transferred to
 111   // caller. desired_list contains list of desired EGL properties and values.
 112   virtual const int32* GetEGLSurfaceProperties(const int32* desired_list);
 113
 114   // Create a single native buffer to be used for overlay planes or zero copy
 115   // for |widget| representing a particular display controller or default
 116   // display controller for kNullAcceleratedWidget.
 117   // It can be called on any thread.
 118   virtual scoped_refptr<NativePixmap> CreateNativePixmap(
 119       gfx::AcceleratedWidget widget,
 120       gfx::Size size,
 121       BufferFormat format,
 122       BufferUsage usage);
 123
 124   // Sets the overlay plane to switch to at the next page flip.
 125   // |w| specifies the screen to display this overlay plane on.
 126   // |plane_z_order| specifies the stacking order of the plane relative to the
 127   // main framebuffer located at index 0.
 128   // |plane_transform| specifies how the buffer is to be transformed during.
 129   // composition.
 130   // |buffer| to be presented by the overlay.
 131   // |display_bounds| specify where it is supposed to be on the screen.
 132   // |crop_rect| specifies the region within the buffer to be placed
 133   // inside |display_bounds|. This is specified in texture coordinates, in the
 134   // range of [0,1].
 135   virtual bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
 136                                     int plane_z_order,
 137                                     gfx::OverlayTransform plane_transform,
 138                                     scoped_refptr<NativePixmap> buffer,
 139                                     const gfx::Rect& display_bounds,
 140                                     const gfx::RectF& crop_rect);
 141
 142   // Returns true if overlays can be shown at z-index 0, replacing the main
 143   // surface. Combined with surfaceless extensions, it allows for an
 144   // overlay-only mode.
 145   virtual bool CanShowPrimaryPlaneAsOverlay();
 146
 147   // Returns true if the platform is able to create buffers for a specific usage
 148   // such as MAP for zero copy or SCANOUT for display controller.
 149   virtual bool CanCreateNativePixmap(BufferUsage usage);
 150
 151  protected:
 152   SurfaceFactoryOzone();
 153   virtual ~SurfaceFactoryOzone();
 154
 155  private:
 156   DISALLOW_COPY_AND_ASSIGN(SurfaceFactoryOzone);
 157 };
 158
 159 }  // namespace ui
 160
 161 #endif  // UI_OZONE_PUBLIC_SURFACE_FACTORY_OZONE_H_