blob: 757f5490f78cfec53758693d71490b6aae39033e [file] [log] [blame]
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/ozone/platform/wayland/wayland_surface_factory.h"
#include <fcntl.h>
#include <sys/mman.h>
#include <wayland-client.h>
#include "base/memory/ptr_util.h"
#include "base/memory/shared_memory.h"
#include "third_party/skia/include/core/SkSurface.h"
#include "ui/gfx/vsync_provider.h"
#include "ui/ozone/common/egl_util.h"
#include "ui/ozone/common/gl_ozone_egl.h"
#include "ui/ozone/platform/wayland/wayland_connection.h"
#include "ui/ozone/platform/wayland/wayland_object.h"
#include "ui/ozone/platform/wayland/wayland_window.h"
#include "ui/ozone/public/surface_ozone_canvas.h"
#if defined(USE_WAYLAND_EGL)
#include "ui/ozone/platform/wayland/gl_surface_wayland.h"
#endif
namespace ui {
static void DeleteSharedMemory(void* pixels, void* context) {
delete static_cast<base::SharedMemory*>(context);
}
class WaylandCanvasSurface : public SurfaceOzoneCanvas {
public:
WaylandCanvasSurface(WaylandConnection* connection, WaylandWindow* window_);
~WaylandCanvasSurface() override;
// SurfaceOzoneCanvas
sk_sp<SkSurface> GetSurface() override;
void ResizeCanvas(const gfx::Size& viewport_size) override;
void PresentCanvas(const gfx::Rect& damage) override;
std::unique_ptr<gfx::VSyncProvider> CreateVSyncProvider() override;
private:
WaylandConnection* connection_;
WaylandWindow* window_;
gfx::Size size_;
sk_sp<SkSurface> sk_surface_;
wl::Object<wl_shm_pool> pool_;
wl::Object<wl_buffer> buffer_;
DISALLOW_COPY_AND_ASSIGN(WaylandCanvasSurface);
};
WaylandCanvasSurface::WaylandCanvasSurface(WaylandConnection* connection,
WaylandWindow* window)
: connection_(connection),
window_(window),
size_(window->GetBounds().size()) {}
WaylandCanvasSurface::~WaylandCanvasSurface() {}
sk_sp<SkSurface> WaylandCanvasSurface::GetSurface() {
if (sk_surface_)
return sk_surface_;
size_t length = size_.width() * size_.height() * 4;
auto shared_memory = base::WrapUnique(new base::SharedMemory);
if (!shared_memory->CreateAndMapAnonymous(length))
return nullptr;
wl::Object<wl_shm_pool> pool(wl_shm_create_pool(
connection_->shm(), shared_memory->handle().fd, length));
if (!pool)
return nullptr;
wl::Object<wl_buffer> buffer(
wl_shm_pool_create_buffer(pool.get(), 0, size_.width(), size_.height(),
size_.width() * 4, WL_SHM_FORMAT_ARGB8888));
if (!buffer)
return nullptr;
sk_surface_ = SkSurface::MakeRasterDirectReleaseProc(
SkImageInfo::MakeN32Premul(size_.width(), size_.height()),
shared_memory->memory(), size_.width() * 4, &DeleteSharedMemory,
shared_memory.get(), nullptr);
if (!sk_surface_)
return nullptr;
pool_ = std::move(pool);
buffer_ = std::move(buffer);
(void)shared_memory.release();
return sk_surface_;
}
void WaylandCanvasSurface::ResizeCanvas(const gfx::Size& viewport_size) {
if (size_ == viewport_size)
return;
// TODO(forney): We could implement more efficient resizes by allocating
// buffers rounded up to larger sizes, and then reusing them if the new size
// still fits (but still reallocate if the new size is much smaller than the
// old size).
if (sk_surface_) {
sk_surface_.reset();
buffer_.reset();
pool_.reset();
}
size_ = viewport_size;
}
void WaylandCanvasSurface::PresentCanvas(const gfx::Rect& damage) {
// TODO(forney): This is just a naive implementation that allows chromium to
// draw to the buffer at any time, even if it is being used by the Wayland
// compositor. Instead, we should track buffer releases and frame callbacks
// from Wayland to ensure perfect frames (while minimizing copies).
wl_surface* surface = window_->surface();
wl_surface_damage(surface, damage.x(), damage.y(), damage.width(),
damage.height());
wl_surface_attach(surface, buffer_.get(), 0, 0);
wl_surface_commit(surface);
connection_->ScheduleFlush();
}
std::unique_ptr<gfx::VSyncProvider>
WaylandCanvasSurface::CreateVSyncProvider() {
// TODO(forney): This can be implemented with information from frame
// callbacks, and possibly output refresh rate.
NOTIMPLEMENTED();
return nullptr;
}
namespace {
class GLOzoneEGLWayland : public GLOzoneEGL {
public:
GLOzoneEGLWayland(WaylandConnection* connection) : connection_(connection) {}
~GLOzoneEGLWayland() override {}
scoped_refptr<gl::GLSurface> CreateViewGLSurface(
gfx::AcceleratedWidget widget) override;
scoped_refptr<gl::GLSurface> CreateOffscreenGLSurface(
const gfx::Size& size) override;
protected:
intptr_t GetNativeDisplay() override;
bool LoadGLES2Bindings() override;
private:
WaylandConnection* connection_;
DISALLOW_COPY_AND_ASSIGN(GLOzoneEGLWayland);
};
scoped_refptr<gl::GLSurface> GLOzoneEGLWayland::CreateViewGLSurface(
gfx::AcceleratedWidget widget) {
#if defined(USE_WAYLAND_EGL)
DCHECK(connection_);
WaylandWindow* window = connection_->GetWindow(widget);
DCHECK(window);
// The wl_egl_window needs to be created before the GLSurface so it can be
// used in the GLSurface constructor.
auto egl_window = CreateWaylandEglWindow(window);
if (!egl_window)
return nullptr;
return gl::InitializeGLSurface(new GLSurfaceWayland(std::move(egl_window)));
#else
return nullptr;
#endif
}
scoped_refptr<gl::GLSurface> GLOzoneEGLWayland::CreateOffscreenGLSurface(
const gfx::Size& size) {
#if defined(USE_WAYLAND_EGL)
if (gl::GLSurfaceEGL::IsEGLSurfacelessContextSupported() &&
size.width() == 0 && size.height() == 0) {
return gl::InitializeGLSurface(new gl::SurfacelessEGL(size));
} else {
return gl::InitializeGLSurface(new gl::PbufferGLSurfaceEGL(size));
}
#else
return nullptr;
#endif
}
intptr_t GLOzoneEGLWayland::GetNativeDisplay() {
return reinterpret_cast<intptr_t>(connection_->display());
}
bool GLOzoneEGLWayland::LoadGLES2Bindings() {
#if defined(USE_WAYLAND_EGL)
setenv("EGL_PLATFORM", "wayland", 0);
return LoadDefaultEGLGLES2Bindings();
#else
return false;
#endif
}
} // namespace
WaylandSurfaceFactory::WaylandSurfaceFactory(WaylandConnection* connection)
: connection_(connection) {
if (connection_)
egl_implementation_.reset(new GLOzoneEGLWayland(connection_));
}
WaylandSurfaceFactory::~WaylandSurfaceFactory() {}
std::unique_ptr<SurfaceOzoneCanvas>
WaylandSurfaceFactory::CreateCanvasForWidget(gfx::AcceleratedWidget widget) {
if (!connection_)
return nullptr;
WaylandWindow* window = connection_->GetWindow(widget);
DCHECK(window);
return base::MakeUnique<WaylandCanvasSurface>(connection_, window);
}
std::vector<gl::GLImplementation>
WaylandSurfaceFactory::GetAllowedGLImplementations() {
std::vector<gl::GLImplementation> impls;
impls.push_back(gl::kGLImplementationEGLGLES2);
return impls;
}
GLOzone* WaylandSurfaceFactory::GetGLOzone(
gl::GLImplementation implementation) {
switch (implementation) {
case gl::kGLImplementationEGLGLES2:
return egl_implementation_.get();
default:
return nullptr;
}
}
scoped_refptr<NativePixmap> WaylandSurfaceFactory::CreateNativePixmap(
gfx::AcceleratedWidget widget,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage) {
NOTIMPLEMENTED();
return nullptr;
}
scoped_refptr<NativePixmap> WaylandSurfaceFactory::CreateNativePixmapFromHandle(
gfx::AcceleratedWidget widget,
gfx::Size size,
gfx::BufferFormat format,
const gfx::NativePixmapHandle& handle) {
NOTIMPLEMENTED();
return nullptr;
}
} // namespace ui