ui/gl/gl_surface_ozone.cc

   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   virtual bool Initialize() override {
  34     return Initialize(ozone_surface_->CreateVSyncProvider());
  35   }
  36   virtual 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   virtual bool SwapBuffers() override {
  46     if (!NativeViewGLSurfaceEGL::SwapBuffers())
  47       return false;
  48
  49     return ozone_surface_->OnSwapBuffers();
  50   }
  51   virtual 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   virtual ~GLSurfaceOzoneEGL() {
  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   virtual 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   virtual bool Resize(const gfx::Size& size) override {
 119     if (!ozone_surface_->ResizeNativeWindow(size))
 120       return false;
 121
 122     return SurfacelessEGL::Resize(size);
 123   }
 124   virtual 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   virtual 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   virtual bool IsOffscreen() override { return false; }
 138   virtual VSyncProvider* GetVSyncProvider() override {
 139     return vsync_provider_.get();
 140   }
 141   virtual bool SupportsPostSubBuffer() override { return true; }
 142   virtual bool PostSubBuffer(int x, int y, int width, int height) override {
 143     // The actual sub buffer handling is handled at higher layers.
 144     SwapBuffers();
 145     return true;
 146   }
 147
 148  private:
 149   virtual ~GLSurfaceOzoneSurfaceless() {
 150     Destroy();  // EGL surface must be destroyed before SurfaceOzone
 151   }
 152
 153   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
 154   scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
 155   AcceleratedWidget widget_;
 156   scoped_ptr<VSyncProvider> vsync_provider_;
 157
 158   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless);
 159 };
 160
 161 }  // namespace
 162
 163 // static
 164 bool GLSurface::InitializeOneOffInternal() {
 165   switch (GetGLImplementation()) {
 166     case kGLImplementationEGLGLES2:
 167       if (!GLSurfaceEGL::InitializeOneOff()) {
 168         LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
 169         return false;
 170       }
 171
 172       return true;
 173     case kGLImplementationOSMesaGL:
 174     case kGLImplementationMockGL:
 175       return true;
 176     default:
 177       return false;
 178   }
 179 }
 180
 181 // static
 182 scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface(
 183     gfx::AcceleratedWidget window) {
 184   if (GetGLImplementation() == kGLImplementationOSMesaGL) {
 185     scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless());
 186     if (!surface->Initialize())
 187       return NULL;
 188     return surface;
 189   }
 190   DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
 191   if (window != kNullAcceleratedWidget) {
 192     scoped_refptr<GLSurface> surface;
 193     if (GLSurfaceEGL::IsEGLSurfacelessContextSupported() &&
 194         ui::SurfaceFactoryOzone::GetInstance()
 195             ->CanShowPrimaryPlaneAsOverlay()) {
 196       scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
 197           ui::SurfaceFactoryOzone::GetInstance()
 198               ->CreateSurfacelessEGLSurfaceForWidget(window);
 199       if (!surface_ozone)
 200         return NULL;
 201       surface = new GLSurfaceOzoneSurfaceless(surface_ozone.Pass(), window);
 202     } else {
 203       scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
 204           ui::SurfaceFactoryOzone::GetInstance()->CreateEGLSurfaceForWidget(
 205               window);
 206       if (!surface_ozone)
 207         return NULL;
 208
 209       surface = new GLSurfaceOzoneEGL(surface_ozone.Pass(), window);
 210     }
 211     if (!surface->Initialize())
 212       return NULL;
 213     return surface;
 214   } else {
 215     scoped_refptr<GLSurface> surface = new GLSurfaceStub();
 216     if (surface->Initialize())
 217       return surface;
 218   }
 219   return NULL;
 220 }
 221
 222 // static
 223 scoped_refptr<GLSurface> GLSurface::CreateOffscreenGLSurface(
 224     const gfx::Size& size) {
 225   switch (GetGLImplementation()) {
 226     case kGLImplementationOSMesaGL: {
 227       scoped_refptr<GLSurface> surface(
 228           new GLSurfaceOSMesa(OSMesaSurfaceFormatBGRA, size));
 229       if (!surface->Initialize())
 230         return NULL;
 231
 232       return surface;
 233     }
 234     case kGLImplementationEGLGLES2: {
 235       scoped_refptr<GLSurface> surface;
 236       if (GLSurfaceEGL::IsEGLSurfacelessContextSupported() &&
 237           (size.width() == 0 && size.height() == 0)) {
 238         surface = new SurfacelessEGL(size);
 239       } else
 240         surface = new PbufferGLSurfaceEGL(size);
 241
 242       if (!surface->Initialize())
 243         return NULL;
 244       return surface;
 245     }
 246     default:
 247       NOTREACHED();
 248       return NULL;
 249   }
 250 }
 251
 252 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
 253   return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay();
 254 }
 255
 256 }  // namespace gfx