ozone: Allow using swiftshader with --use-gl=swiftshader.

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>
 
@@ skipping 123 matching lines @@
   ~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;
+  bool LoadGLES2Bindings(gl::GLImplementation impl) override;
 
  private:
   WaylandConnection* connection_;
 
   DISALLOW_COPY_AND_ASSIGN(GLOzoneEGLWayland);
 };
 
 scoped_refptr<gl::GLSurface> GLOzoneEGLWayland::CreateViewGLSurface(
     gfx::AcceleratedWidget widget) {
   DCHECK(connection_);
@@ skipping 14 matching lines @@
     return gl::InitializeGLSurface(new gl::SurfacelessEGL(size));
   } else {
     return gl::InitializeGLSurface(new gl::PbufferGLSurfaceEGL(size));
   }
 }
 
 intptr_t GLOzoneEGLWayland::GetNativeDisplay() {
   return reinterpret_cast<intptr_t>(connection_->display());
 }
 
-bool GLOzoneEGLWayland::LoadGLES2Bindings() {
+bool GLOzoneEGLWayland::LoadGLES2Bindings(gl::GLImplementation impl) {
+  // TODO: It may not be necessary to set this environment variable when using
+  // swiftshader.
   setenv("EGL_PLATFORM", "wayland", 0);
-  return LoadDefaultEGLGLES2Bindings();
+  return LoadDefaultEGLGLES2Bindings(impl);
 }
 
 }  // namespace
 
 WaylandSurfaceFactory::WaylandSurfaceFactory(WaylandConnection* connection)
     : connection_(connection),
       osmesa_implementation_(base::MakeUnique<GLOzoneOSMesa>()) {
   if (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;
-  if (egl_implementation_)
+  if (egl_implementation_) {
     impls.push_back(gl::kGLImplementationEGLGLES2);
+    impls.push_back(gl::kGLImplementationSwiftShaderGL);
+  }
   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:
@@ skipping 16 matching lines @@
 WaylandSurfaceFactory::CreateNativePixmapFromHandle(
     gfx::AcceleratedWidget widget,
     gfx::Size size,
     gfx::BufferFormat format,
     const gfx::NativePixmapHandle& handle) {
   NOTIMPLEMENTED();
   return nullptr;
 }
 
 }  // namespace ui