Convert Ozone GL OSMesa implementation.

ui/ozone/platform/wayland/wayland_surface_factory.cc

 // 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/common/gl_ozone_osmesa.h"
 #include "ui/ozone/platform/wayland/gl_surface_wayland.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"
 
 namespace ui {
 
 static void DeleteSharedMemory(void* pixels, void* context) {
   delete static_cast<base::SharedMemory*>(context);
@@ skipping 94 matching lines @@
   // 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) {}
+  explicit 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;
@@ skipping 33 matching lines @@
 }
 
 bool GLOzoneEGLWayland::LoadGLES2Bindings() {
   setenv("EGL_PLATFORM", "wayland", 0);
   return LoadDefaultEGLGLES2Bindings();
 }
 
 }  // namespace
 
 WaylandSurfaceFactory::WaylandSurfaceFactory(WaylandConnection* connection)
-    : connection_(connection) {
+    : connection_(connection),
+      osmesa_implementation_(base::MakeUnique<GLOzoneOSMesa>()) {
   if (connection_)
-    egl_implementation_.reset(new GLOzoneEGLWayland(connection_));
+    egl_implementation_ = base::MakeUnique<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);
+  if (egl_implementation_)
+    impls.push_back(gl::kGLImplementationEGLGLES2);
+  impls.push_back(gl::kGLImplementationOSMesaGL);
   return impls;
 }
 
 GLOzone* WaylandSurfaceFactory::GetGLOzone(
     gl::GLImplementation implementation) {
   switch (implementation) {
     case gl::kGLImplementationEGLGLES2:
       return egl_implementation_.get();
+    case gl::kGLImplementationOSMesaGL:
+      return osmesa_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