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   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