Convert Ozone GL OSMesa implementation.

ui/ozone/platform/cast/surface_factory_cast.cc

 // Copyright 2015 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/cast/surface_factory_cast.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "chromecast/public/cast_egl_platform.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/native_pixmap.h"
 #include "ui/gfx/vsync_provider.h"
+#include "ui/ozone/common/gl_ozone_osmesa.h"
 #include "ui/ozone/public/surface_ozone_canvas.h"
 
 namespace ui {
 
 namespace {
 
 class DummySurface : public SurfaceOzoneCanvas {
  public:
   DummySurface() {}
   ~DummySurface() override {}
@@ skipping 54 matching lines @@
  private:
   ~CastPixmap() override {}
 
   GLOzoneEglCast* parent_;
 
   DISALLOW_COPY_AND_ASSIGN(CastPixmap);
 };
 
 }  // namespace
 
-SurfaceFactoryCast::SurfaceFactoryCast() {}
+SurfaceFactoryCast::SurfaceFactoryCast() : SurfaceFactoryCast(nullptr) {}
 
 SurfaceFactoryCast::SurfaceFactoryCast(
     std::unique_ptr<chromecast::CastEglPlatform> egl_platform)
-    : egl_implementation_(
-          base::MakeUnique<GLOzoneEglCast>(std::move(egl_platform))) {}
+    : osmesa_implementation_(base::MakeUnique<GLOzoneOSMesa>()) {
+  if (egl_platform) {
+    egl_implementation_ =
+        base::MakeUnique<GLOzoneEglCast>(std::move(egl_platform));
+  }
+}
 
 SurfaceFactoryCast::~SurfaceFactoryCast() {}
 
 std::vector<gl::GLImplementation>
 SurfaceFactoryCast::GetAllowedGLImplementations() {
   std::vector<gl::GLImplementation> impls;
   if (egl_implementation_)
     impls.push_back(gl::kGLImplementationEGLGLES2);
   impls.push_back(gl::kGLImplementationOSMesaGL);
   return impls;
 }
 
 GLOzone* SurfaceFactoryCast::GetGLOzone(gl::GLImplementation implementation) {
   switch (implementation) {
     case gl::kGLImplementationEGLGLES2:
       return egl_implementation_.get();
+    case gl::kGLImplementationOSMesaGL:
+      return osmesa_implementation_.get();
     default:
       return nullptr;
   }
 }
 
 std::unique_ptr<SurfaceOzoneCanvas> SurfaceFactoryCast::CreateCanvasForWidget(
     gfx::AcceleratedWidget widget) {
   // Software canvas support only in headless mode
   if (egl_implementation_)
     return nullptr;
   return base::WrapUnique<SurfaceOzoneCanvas>(new DummySurface());
 }
 
 scoped_refptr<NativePixmap> SurfaceFactoryCast::CreateNativePixmap(
     gfx::AcceleratedWidget widget,
     gfx::Size size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage) {
   return make_scoped_refptr(new CastPixmap(egl_implementation_.get()));
 }
 
 }  // namespace ui