Expose Null ANGLE backend

ui/gl/gl_surface_egl.cc

 // Copyright (c) 2012 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/gl/gl_surface_egl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 59 matching lines @@
 #define EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE 0x320B
 #define EGL_PLATFORM_ANGLE_DEVICE_TYPE_REFERENCE_ANGLE 0x320C
 #endif /* EGL_ANGLE_platform_angle_d3d */
 
 #ifndef EGL_ANGLE_platform_angle_opengl
 #define EGL_ANGLE_platform_angle_opengl 1
 #define EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE 0x320D
 #define EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE 0x320E
 #endif /* EGL_ANGLE_platform_angle_opengl */
 
+#ifndef EGL_ANGLE_platform_angle_null
+#define EGL_ANGLE_platform_angle_null 1
+#define EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE 0x33AE
+#endif /* EGL_ANGLE_platform_angle_null */
+
 #ifndef EGL_ANGLE_x11_visual
 #define EGL_ANGLE_x11_visual 1
 #define EGL_X11_VISUAL_ID_ANGLE 0x33A3
 #endif /* EGL_ANGLE_x11_visual */
 
 #ifndef EGL_ANGLE_surface_orientation
 #define EGL_ANGLE_surface_orientation
 #define EGL_OPTIMAL_SURFACE_ORIENTATION_ANGLE 0x33A7
 #define EGL_SURFACE_ORIENTATION_ANGLE 0x33A8
 #define EGL_SURFACE_ORIENTATION_INVERT_X_ANGLE 0x0001
@@ skipping 76 matching lines @@
                                      EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE, false);
     case ANGLE_D3D11:
       return GetPlatformANGLEDisplay(
           native_display, EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE, false);
     case ANGLE_OPENGL:
       return GetPlatformANGLEDisplay(
           native_display, EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE, false);
     case ANGLE_OPENGLES:
       return GetPlatformANGLEDisplay(
           native_display, EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE, false);
+    case ANGLE_NULL:
+      return GetPlatformANGLEDisplay(native_display,
+                                     EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE, false);
     default:
       NOTREACHED();
       return EGL_NO_DISPLAY;
   }
 }
 
 const char* DisplayTypeString(DisplayType display_type) {
   switch (display_type) {
     case DEFAULT:
       return "Default";
     case SWIFT_SHADER:
       return "SwiftShader";
     case ANGLE_D3D9:
       return "D3D9";
     case ANGLE_D3D11:
       return "D3D11";
     case ANGLE_OPENGL:
       return "OpenGL";
     case ANGLE_OPENGLES:
       return "OpenGLES";
+    case ANGLE_NULL:
+      return "Null";
     default:
       NOTREACHED();
       return "Err";
   }
 }
 
 bool ValidateEglConfig(EGLDisplay display,
                        const EGLint* config_attribs,
                        EGLint* num_configs) {
   if (!eglChooseConfig(display,
@@ skipping 134 matching lines @@
   }
 
   LOG(ERROR) << "No suitable EGL configs found.";
   return nullptr;
 }
 
 }  // namespace
 
 void GetEGLInitDisplays(bool supports_angle_d3d,
                         bool supports_angle_opengl,
+                        bool supports_angle_null,
                         const base::CommandLine* command_line,
                         std::vector<DisplayType>* init_displays) {
   // SwiftShader does not use the platform extensions
   if (command_line->GetSwitchValueASCII(switches::kUseGL) ==
       kGLImplementationSwiftShaderName) {
     init_displays->push_back(SWIFT_SHADER);
     return;
   }
 
   std::string requested_renderer =
       command_line->GetSwitchValueASCII(switches::kUseANGLE);
 
   bool use_angle_default =
       !command_line->HasSwitch(switches::kUseANGLE) ||
       requested_renderer == kANGLEImplementationDefaultName;
 
+  if (supports_angle_null &&
+      requested_renderer == kANGLEImplementationNullName) {
+    init_displays->push_back(ANGLE_NULL);
+    return;
+  }
+
   if (supports_angle_d3d) {
     if (use_angle_default) {
       // Default mode for ANGLE - try D3D11, else try D3D9
       if (!command_line->HasSwitch(switches::kDisableD3D11)) {
         init_displays->push_back(ANGLE_D3D11);
       }
       init_displays->push_back(ANGLE_D3D9);
     } else {
       if (requested_renderer == kANGLEImplementationD3D11Name) {
         init_displays->push_back(ANGLE_D3D11);
@@ skipping 198 matching lines @@
 
   g_native_display = native_display;
 
   // If EGL_EXT_client_extensions not supported this call to eglQueryString
   // will return NULL.
   const char* client_extensions =
       eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
 
   bool supports_angle_d3d = false;
   bool supports_angle_opengl = false;
+  bool supports_angle_null = false;
   // Check for availability of ANGLE extensions.
   if (client_extensions &&
       ExtensionsContain(client_extensions, "EGL_ANGLE_platform_angle")) {
     supports_angle_d3d =
         ExtensionsContain(client_extensions, "EGL_ANGLE_platform_angle_d3d");
     supports_angle_opengl =
         ExtensionsContain(client_extensions, "EGL_ANGLE_platform_angle_opengl");
+    supports_angle_null =
+        ExtensionsContain(client_extensions, "EGL_ANGLE_platform_angle_null");
   }
 
   std::vector<DisplayType> init_displays;
   GetEGLInitDisplays(supports_angle_d3d, supports_angle_opengl,
+                     supports_angle_null,
                      base::CommandLine::ForCurrentProcess(), &init_displays);
 
   for (size_t disp_index = 0; disp_index < init_displays.size(); ++disp_index) {
     DisplayType display_type = init_displays[disp_index];
     EGLDisplay display =
         GetDisplayFromType(display_type, g_native_display);
     if (display == EGL_NO_DISPLAY) {
       LOG(ERROR) << "EGL display query failed with error "
                  << GetLastEGLErrorString();
     }
@@ skipping 574 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gl