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) {
   setenv("EGL_PLATFORM", "wayland", 0);

[rjkroege, 2017/06/12 17:23:40]

I suspect that the setenv should be skipped if we're using swiftshader. This is
a subtlety that we ought to ask tonikitoo@ about.

[tonikitoo, 2017/06/12 18:32:17]

I believe the comment pasted below is relevant (source:
https://github.com/01org/ozone-wayland/blob/master/wayland/display.cc#L167)

  // The variable EGL_PLATFORM specifies native platform to be used by the
  // drivers (atleast on Mesa). When the variable is not set, Mesa uses the
  // first platform listed in --with-egl-platforms during compilation. Thus, we
  // ensure here that wayland is set as the native platform. However, we don't
  // override the EGL_PLATFORM value in case it has already been set.

It make makes sense to me to skip setting this env variable in the case of
swiftshader use. However, I am not sure it guarantees Wayland rendering will
work (it might depend on how mesa is configured/built?).

[sadrul, 2017/06/12 19:37:00]

Sounds like the safest option is to always set the env variable here for now,
until we can confirm it's not needed for swiftshader.

-  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