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