| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 #include "ui/gl/gl_surface.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "base/memory/ref_counted.h" | |
| 9 #include "ui/gfx/native_widget_types.h" | |
| 10 #include "ui/gl/gl_context.h" | |
| 11 #include "ui/gl/gl_image.h" | |
| 12 #include "ui/gl/gl_implementation.h" | |
| 13 #include "ui/gl/gl_surface_egl.h" | |
| 14 #include "ui/gl/gl_surface_osmesa.h" | |
| 15 #include "ui/gl/gl_surface_stub.h" | |
| 16 #include "ui/gl/scoped_make_current.h" | |
| 17 #include "ui/ozone/public/surface_factory_ozone.h" | |
| 18 #include "ui/ozone/public/surface_ozone_egl.h" | |
| 19 | |
| 20 namespace gfx { | |
| 21 | |
| 22 namespace { | |
| 23 | |
| 24 // A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow | |
| 25 class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL { | |
| 26 public: | |
| 27 GLSurfaceOzoneEGL(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface, | |
| 28 AcceleratedWidget widget) | |
| 29 : NativeViewGLSurfaceEGL(ozone_surface->GetNativeWindow()), | |
| 30 ozone_surface_(ozone_surface.Pass()), | |
| 31 widget_(widget) {} | |
| 32 | |
| 33 bool Initialize() override { | |
| 34 return Initialize(ozone_surface_->CreateVSyncProvider()); | |
| 35 } | |
| 36 bool Resize(const gfx::Size& size) override { | |
| 37 if (!ozone_surface_->ResizeNativeWindow(size)) { | |
| 38 if (!ReinitializeNativeSurface() || | |
| 39 !ozone_surface_->ResizeNativeWindow(size)) | |
| 40 return false; | |
| 41 } | |
| 42 | |
| 43 return NativeViewGLSurfaceEGL::Resize(size); | |
| 44 } | |
| 45 bool SwapBuffers() override { | |
| 46 if (!NativeViewGLSurfaceEGL::SwapBuffers()) | |
| 47 return false; | |
| 48 | |
| 49 return ozone_surface_->OnSwapBuffers(); | |
| 50 } | |
| 51 bool ScheduleOverlayPlane(int z_order, | |
| 52 OverlayTransform transform, | |
| 53 GLImage* image, | |
| 54 const Rect& bounds_rect, | |
| 55 const RectF& crop_rect) override { | |
| 56 return image->ScheduleOverlayPlane( | |
| 57 widget_, z_order, transform, bounds_rect, crop_rect); | |
| 58 } | |
| 59 | |
| 60 private: | |
| 61 using NativeViewGLSurfaceEGL::Initialize; | |
| 62 | |
| 63 ~GLSurfaceOzoneEGL() override { | |
| 64 Destroy(); // EGL surface must be destroyed before SurfaceOzone | |
| 65 } | |
| 66 | |
| 67 bool ReinitializeNativeSurface() { | |
| 68 scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current; | |
| 69 GLContext* current_context = GLContext::GetCurrent(); | |
| 70 bool was_current = | |
| 71 current_context && current_context->IsCurrent(this); | |
| 72 if (was_current) { | |
| 73 scoped_make_current.reset( | |
| 74 new ui::ScopedMakeCurrent(current_context, this)); | |
| 75 } | |
| 76 | |
| 77 Destroy(); | |
| 78 ozone_surface_ = | |
| 79 ui::SurfaceFactoryOzone::GetInstance()->CreateEGLSurfaceForWidget( | |
| 80 widget_).Pass(); | |
| 81 if (!ozone_surface_) { | |
| 82 LOG(ERROR) << "Failed to create native surface."; | |
| 83 return false; | |
| 84 } | |
| 85 | |
| 86 window_ = ozone_surface_->GetNativeWindow(); | |
| 87 if (!Initialize()) { | |
| 88 LOG(ERROR) << "Failed to initialize."; | |
| 89 return false; | |
| 90 } | |
| 91 | |
| 92 return true; | |
| 93 } | |
| 94 | |
| 95 // The native surface. Deleting this is allowed to free the EGLNativeWindow. | |
| 96 scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_; | |
| 97 AcceleratedWidget widget_; | |
| 98 | |
| 99 DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneEGL); | |
| 100 }; | |
| 101 | |
| 102 class GL_EXPORT GLSurfaceOzoneSurfaceless : public SurfacelessEGL { | |
| 103 public: | |
| 104 GLSurfaceOzoneSurfaceless(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface, | |
| 105 AcceleratedWidget widget) | |
| 106 : SurfacelessEGL(gfx::Size()), | |
| 107 ozone_surface_(ozone_surface.Pass()), | |
| 108 widget_(widget) {} | |
| 109 | |
| 110 bool Initialize() override { | |
| 111 if (!SurfacelessEGL::Initialize()) | |
| 112 return false; | |
| 113 vsync_provider_ = ozone_surface_->CreateVSyncProvider(); | |
| 114 if (!vsync_provider_) | |
| 115 return false; | |
| 116 return true; | |
| 117 } | |
| 118 bool Resize(const gfx::Size& size) override { | |
| 119 if (!ozone_surface_->ResizeNativeWindow(size)) | |
| 120 return false; | |
| 121 | |
| 122 return SurfacelessEGL::Resize(size); | |
| 123 } | |
| 124 bool SwapBuffers() override { | |
| 125 // TODO: this should be replaced by a fence when supported by the driver. | |
| 126 glFlush(); | |
| 127 return ozone_surface_->OnSwapBuffers(); | |
| 128 } | |
| 129 bool ScheduleOverlayPlane(int z_order, | |
| 130 OverlayTransform transform, | |
| 131 GLImage* image, | |
| 132 const Rect& bounds_rect, | |
| 133 const RectF& crop_rect) override { | |
| 134 return image->ScheduleOverlayPlane( | |
| 135 widget_, z_order, transform, bounds_rect, crop_rect); | |
| 136 } | |
| 137 bool IsOffscreen() override { return false; } | |
| 138 VSyncProvider* GetVSyncProvider() override { return vsync_provider_.get(); } | |
| 139 bool SupportsPostSubBuffer() override { return true; } | |
| 140 bool PostSubBuffer(int x, int y, int width, int height) override { | |
| 141 // The actual sub buffer handling is handled at higher layers. | |
| 142 SwapBuffers(); | |
| 143 return true; | |
| 144 } | |
| 145 bool SwapBuffersAsync(const SwapCompletionCallback& callback) override { | |
| 146 // TODO: this should be replaced by a fence when supported by the driver. | |
| 147 glFlush(); | |
| 148 return ozone_surface_->OnSwapBuffersAsync(callback); | |
| 149 } | |
| 150 bool PostSubBufferAsync(int x, | |
| 151 int y, | |
| 152 int width, | |
| 153 int height, | |
| 154 const SwapCompletionCallback& callback) override { | |
| 155 return SwapBuffersAsync(callback); | |
| 156 } | |
| 157 | |
| 158 private: | |
| 159 ~GLSurfaceOzoneSurfaceless() override { | |
| 160 Destroy(); // EGL surface must be destroyed before SurfaceOzone | |
| 161 } | |
| 162 | |
| 163 // The native surface. Deleting this is allowed to free the EGLNativeWindow. | |
| 164 scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_; | |
| 165 AcceleratedWidget widget_; | |
| 166 scoped_ptr<VSyncProvider> vsync_provider_; | |
| 167 | |
| 168 DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless); | |
| 169 }; | |
| 170 | |
| 171 } // namespace | |
| 172 | |
| 173 // static | |
| 174 bool GLSurface::InitializeOneOffInternal() { | |
| 175 switch (GetGLImplementation()) { | |
| 176 case kGLImplementationEGLGLES2: | |
| 177 if (!GLSurfaceEGL::InitializeOneOff()) { | |
| 178 LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed."; | |
| 179 return false; | |
| 180 } | |
| 181 | |
| 182 return true; | |
| 183 case kGLImplementationOSMesaGL: | |
| 184 case kGLImplementationMockGL: | |
| 185 return true; | |
| 186 default: | |
| 187 return false; | |
| 188 } | |
| 189 } | |
| 190 | |
| 191 // static | |
| 192 scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface( | |
| 193 gfx::AcceleratedWidget window) { | |
| 194 if (GetGLImplementation() == kGLImplementationOSMesaGL) { | |
| 195 scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless()); | |
| 196 if (!surface->Initialize()) | |
| 197 return NULL; | |
| 198 return surface; | |
| 199 } | |
| 200 DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2); | |
| 201 if (window != kNullAcceleratedWidget) { | |
| 202 scoped_refptr<GLSurface> surface; | |
| 203 if (GLSurfaceEGL::IsEGLSurfacelessContextSupported() && | |
| 204 ui::SurfaceFactoryOzone::GetInstance() | |
| 205 ->CanShowPrimaryPlaneAsOverlay()) { | |
| 206 scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone = | |
| 207 ui::SurfaceFactoryOzone::GetInstance() | |
| 208 ->CreateSurfacelessEGLSurfaceForWidget(window); | |
| 209 if (!surface_ozone) | |
| 210 return NULL; | |
| 211 surface = new GLSurfaceOzoneSurfaceless(surface_ozone.Pass(), window); | |
| 212 } else { | |
| 213 scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone = | |
| 214 ui::SurfaceFactoryOzone::GetInstance()->CreateEGLSurfaceForWidget( | |
| 215 window); | |
| 216 if (!surface_ozone) | |
| 217 return NULL; | |
| 218 | |
| 219 surface = new GLSurfaceOzoneEGL(surface_ozone.Pass(), window); | |
| 220 } | |
| 221 if (!surface->Initialize()) | |
| 222 return NULL; | |
| 223 return surface; | |
| 224 } else { | |
| 225 scoped_refptr<GLSurface> surface = new GLSurfaceStub(); | |
| 226 if (surface->Initialize()) | |
| 227 return surface; | |
| 228 } | |
| 229 return NULL; | |
| 230 } | |
| 231 | |
| 232 // static | |
| 233 scoped_refptr<GLSurface> GLSurface::CreateOffscreenGLSurface( | |
| 234 const gfx::Size& size) { | |
| 235 switch (GetGLImplementation()) { | |
| 236 case kGLImplementationOSMesaGL: { | |
| 237 scoped_refptr<GLSurface> surface( | |
| 238 new GLSurfaceOSMesa(OSMesaSurfaceFormatBGRA, size)); | |
| 239 if (!surface->Initialize()) | |
| 240 return NULL; | |
| 241 | |
| 242 return surface; | |
| 243 } | |
| 244 case kGLImplementationEGLGLES2: { | |
| 245 scoped_refptr<GLSurface> surface; | |
| 246 if (GLSurfaceEGL::IsEGLSurfacelessContextSupported() && | |
| 247 (size.width() == 0 && size.height() == 0)) { | |
| 248 surface = new SurfacelessEGL(size); | |
| 249 } else | |
| 250 surface = new PbufferGLSurfaceEGL(size); | |
| 251 | |
| 252 if (!surface->Initialize()) | |
| 253 return NULL; | |
| 254 return surface; | |
| 255 } | |
| 256 default: | |
| 257 NOTREACHED(); | |
| 258 return NULL; | |
| 259 } | |
| 260 } | |
| 261 | |
| 262 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() { | |
| 263 return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay(); | |
| 264 } | |
| 265 | |
| 266 } // namespace gfx | |
| OLD | NEW |
|---|
Chromium Code Reviews
