Delete usage and support for EGL_ANGLE_software_display extension.

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"
 
 #if defined(OS_ANDROID)
 #include <android/native_window_jni.h>
 #endif
 
@@ skipping 19 matching lines @@
 
 using ui::GetLastEGLErrorString;
 
 namespace gfx {
 
 namespace {
 
 EGLConfig g_config;
 EGLDisplay g_display;
 EGLNativeDisplayType g_native_display;
-EGLConfig g_software_config;
-EGLDisplay g_software_display;
-EGLNativeDisplayType g_software_native_display;
 
 const char* g_egl_extensions = NULL;
 bool g_egl_create_context_robustness_supported = false;
 bool g_egl_sync_control_supported = false;
 
 class EGLSyncControlVSyncProvider
     : public gfx::SyncControlVSyncProvider {
  public:
   explicit EGLSyncControlVSyncProvider(EGLSurface surface)
       : SyncControlVSyncProvider(),
@@ skipping 23 matching lines @@
   }
 
  private:
   EGLSurface surface_;
 
   DISALLOW_COPY_AND_ASSIGN(EGLSyncControlVSyncProvider);
 };
 
 }  // namespace
 
-GLSurfaceEGL::GLSurfaceEGL() : software_(false) {}
+GLSurfaceEGL::GLSurfaceEGL() {}
 
 bool GLSurfaceEGL::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
 #if defined (USE_OZONE)
   ui::SurfaceFactoryOzone::GetInstance()->InitializeHardware();
 #endif
 
@@ skipping 53 matching lines @@
   }
 
   g_egl_extensions = eglQueryString(g_display, EGL_EXTENSIONS);
   g_egl_create_context_robustness_supported =
       HasEGLExtension("EGL_EXT_create_context_robustness");
   g_egl_sync_control_supported =
       HasEGLExtension("EGL_CHROMIUM_sync_control");
 
   initialized = true;
 
-#if defined(USE_X11) || defined(OS_ANDROID) \
-    || defined(USE_OZONE)
-  return true;
-#else
-  g_software_native_display = EGL_SOFTWARE_DISPLAY_ANGLE;
-#endif
-  g_software_display = eglGetDisplay(g_software_native_display);
-  if (!g_software_display) {
-    return true;
-  }
-
-  if (!eglInitialize(g_software_display, NULL, NULL)) {
-    return true;
-  }
-
-  if (!eglChooseConfig(g_software_display,
-                       kConfigAttribs,
-                       NULL,
-                       0,
-                       &num_configs)) {
-    g_software_display = NULL;
-    return true;
-  }
-
-  if (num_configs == 0) {
-    g_software_display = NULL;
-    return true;
-  }
-
-  if (!eglChooseConfig(g_software_display,
-                       kConfigAttribs,
-                       &g_software_config,
-                       1,
-                       &num_configs)) {
-    g_software_display = NULL;
-    return false;
-  }
-
   return true;
 }
 
 EGLDisplay GLSurfaceEGL::GetDisplay() {
-  return software_ ? g_software_display : g_display;
+  return g_display;
 }
 
 EGLDisplay GLSurfaceEGL::GetHardwareDisplay() {
   return g_display;
 }
 
-EGLDisplay GLSurfaceEGL::GetSoftwareDisplay() {
-  return g_software_display;
-}
-
 EGLNativeDisplayType GLSurfaceEGL::GetNativeDisplay() {
   return g_native_display;
 }
 
 const char* GLSurfaceEGL::GetEGLExtensions() {
   return g_egl_extensions;
 }
 
 bool GLSurfaceEGL::HasEGLExtension(const char* name) {
   return ExtensionsContain(GetEGLExtensions(), name);
 }
 
 bool GLSurfaceEGL::IsCreateContextRobustnessSupported() {
   return g_egl_create_context_robustness_supported;
 }
 
 GLSurfaceEGL::~GLSurfaceEGL() {}
 
-NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(bool software,
-                                               gfx::AcceleratedWidget window)
+NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(gfx::AcceleratedWidget window)
     : window_(window),
       surface_(NULL),
       supports_post_sub_buffer_(false),
       config_(NULL) {
-  software_ = software;
 #if defined(OS_ANDROID)
   if (window)
     ANativeWindow_acquire(window);
 #endif
 }
 
 bool NativeViewGLSurfaceEGL::Initialize() {
   return Initialize(NULL);
 }
 
@@ skipping 50 matching lines @@
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
     surface_ = NULL;
   }
 }
 
 EGLConfig NativeViewGLSurfaceEGL::GetConfig() {
 #if !defined(USE_X11)
-  return software_ ? g_software_config : g_config;
+  return g_config;
 #else
   if (!config_) {
     // Get a config compatible with the window
     DCHECK(window_);
     XWindowAttributes win_attribs;
     if (!XGetWindowAttributes(GetNativeDisplay(), window_, &win_attribs)) {
       return NULL;
     }
 
     // Try matching the window depth with an alpha channel,
@@ skipping 154 matching lines @@
 #if defined(OS_ANDROID)
   if (window_)
     ANativeWindow_release(window_);
 #endif
 }
 
 void NativeViewGLSurfaceEGL::SetHandle(EGLSurface surface) {
   surface_ = surface;
 }
 
-PbufferGLSurfaceEGL::PbufferGLSurfaceEGL(bool software, const gfx::Size& size)
+PbufferGLSurfaceEGL::PbufferGLSurfaceEGL(const gfx::Size& size)
     : size_(size),
       surface_(NULL) {
-  software_ = software;
 }
 
 bool PbufferGLSurfaceEGL::Initialize() {
   EGLSurface old_surface = surface_;
 
   EGLDisplay display = GetDisplay();
   if (!display) {
     LOG(ERROR) << "Trying to create surface with invalid display.";
     return false;
   }
@@ skipping 34 matching lines @@
   if (surface_) {
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
     surface_ = NULL;
   }
 }
 
 EGLConfig PbufferGLSurfaceEGL::GetConfig() {
-  return software_ ? g_software_config : g_config;
+  return g_config;
 }
 
 bool PbufferGLSurfaceEGL::IsOffscreen() {
   return true;
 }
 
 bool PbufferGLSurfaceEGL::SwapBuffers() {
   NOTREACHED() << "Attempted to call SwapBuffers on a PbufferGLSurfaceEGL.";
   return false;
 }
@@ skipping 64 matching lines @@
 
   if (!GLSurfaceEGL::InitializeOneOff()) {
     LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
     return false;
   }
   return true;
 }
 
 // static
 scoped_refptr<GLSurface>
-GLSurface::CreateViewGLSurface(bool software, gfx::AcceleratedWidget window) {
-  if (software)
-    return NULL;
-
+GLSurface::CreateViewGLSurface(gfx::AcceleratedWidget window) {
   DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
   if (window) {
     scoped_refptr<NativeViewGLSurfaceEGL> surface;
     VSyncProvider* sync_provider = NULL;
 #if defined(USE_OZONE)
     window = ui::SurfaceFactoryOzone::GetInstance()->RealizeAcceleratedWidget(
         window);
     sync_provider =
         ui::SurfaceFactoryOzone::GetInstance()->GetVSyncProvider(window);
 #endif
-    surface = new NativeViewGLSurfaceEGL(false, window);
+    surface = new NativeViewGLSurfaceEGL(window);
     if(surface->Initialize(sync_provider))
       return surface;
   } else {
     scoped_refptr<GLSurface> surface = new GLSurfaceStub();
     if (surface->Initialize())
       return surface;
   }
   return NULL;
 }
 
 // static
 scoped_refptr<GLSurface>
-GLSurface::CreateOffscreenGLSurface(bool software, const gfx::Size& size) {
-  if (software)
-    return NULL;
-
+GLSurface::CreateOffscreenGLSurface(const gfx::Size& size) {
   switch (GetGLImplementation()) {
     case kGLImplementationEGLGLES2: {
       scoped_refptr<PbufferGLSurfaceEGL> surface(
-          new PbufferGLSurfaceEGL(false, size));
+          new PbufferGLSurfaceEGL(size));
       if (!surface->Initialize())
         return NULL;
       return surface;
     }
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 #endif
 
 }  // namespace gfx