Add DisplayGL::getDriverVersion and implementation on Linux NVIDIA

BUILD.gn

@@ -254,6 +254,13 @@ static_library("libANGLE") {
   libs = []
   defines = [ "LIBANGLE_IMPLEMENTATION" ]
 
+  deps = [
+    ":angle_common",
+    ":commit_id",
+    ":includes",
+    ":translator_static",
+  ]
+
   # Shared D3D sources.
   if (angle_enable_d3d9 || angle_enable_d3d11) {
     sources += rebase_path(gles_gypi.libangle_d3d_shared_sources, ".", "src")
@@ -281,7 +288,14 @@ static_library("libANGLE") {
     }
     if (use_x11) {
       sources += rebase_path(gles_gypi.libangle_gl_glx_sources, ".", "src")
-      libs += [ "X11" ]
+      deps += [
+        "src/third_party/libXNVCtrl:libXNVCtrl"
+      ]
+      libs += [
+        "X11",
+        "Xi",
+        "Xext",
+      ]
     }
   }
 
@@ -298,13 +312,6 @@ static_library("libANGLE") {
     "//build/config/compiler:no_chromium_code",
   ]
 
-  deps = [
-    ":angle_common",
-    ":commit_id",
-    ":includes",
-    ":translator_static",
-  ]
-
   if (is_win) {
     deps += [ ":copy_compiler_dll" ]
   }

src/libANGLE/renderer/gl/DisplayGL.h

@@ -36,6 +36,8 @@ class DisplayGL : public DisplayImpl
 
     egl::Error makeCurrent(egl::Surface *drawSurface, egl::Surface *readSurface, gl::Context *context) override;
 
+    virtual egl::Error getDriverVersion(std::string *version) const = 0;
+
   protected:
     RendererGL *getRenderer() const { return mRenderer; };
     const gl::Version &getMaxSupportedESVersion() const;

src/libANGLE/renderer/gl/cgl/DisplayCGL.h

@@ -55,6 +55,8 @@ class DisplayCGL : public DisplayGL
                           egl::Surface *drawSurface,
                           egl::Surface *readSurface) const override;
 
+    egl::Error getDriverVersion(std::string *version) const override;
+
   private:
     const FunctionsGL *getFunctionsGL() const override;
 

src/libANGLE/renderer/gl/cgl/DisplayCGL.mm

@@ -269,4 +269,10 @@ egl::Error DisplayCGL::waitNative(EGLint engine,
     // TODO(cwallez) UNIMPLEMENTED()
     return egl::Error(EGL_SUCCESS);
 }
+
+egl::Error DisplayCGL::getDriverVersion(std::string *version) const
+{
+    *version = "";
+    return egl::Error(EGL_SUCCESS);
+}
 }

src/libANGLE/renderer/gl/glx/DisplayGLX.cpp

@@ -18,6 +18,8 @@
 #include "libANGLE/renderer/gl/glx/PbufferSurfaceGLX.h"
 #include "libANGLE/renderer/gl/glx/WindowSurfaceGLX.h"
 #include "libANGLE/renderer/gl/renderergl_utils.h"
+#include "third_party/libXNVCtrl/NVCtrl.h"
+#include "third_party/libXNVCtrl/NVCtrlLib.h"
 
 namespace rx
 {
@@ -70,6 +72,7 @@ DisplayGLX::DisplayGLX()
       mMinSwapInterval(0),
       mMaxSwapInterval(0),
       mCurrentSwapInterval(-1),
+      mXDisplay(nullptr),
       mEGLDisplay(nullptr)
 {
 }
@@ -81,24 +84,24 @@ DisplayGLX::~DisplayGLX()
 egl::Error DisplayGLX::initialize(egl::Display *display)
 {
     mEGLDisplay = display;
-    Display *xDisplay = display->getNativeDisplayId();
+    mXDisplay             = display->getNativeDisplayId();
     const auto &attribMap = display->getAttributeMap();
 
     // ANGLE_platform_angle allows the creation of a default display
     // using EGL_DEFAULT_DISPLAY (= nullptr). In this case just open
     // the display specified by the DISPLAY environment variable.
-    if (xDisplay == EGL_DEFAULT_DISPLAY)
+    if (mXDisplay == EGL_DEFAULT_DISPLAY)
     {
         mUsesNewXDisplay = true;
-        xDisplay = XOpenDisplay(NULL);
-        if (!xDisplay)
+        mXDisplay = XOpenDisplay(NULL);
+        if (!mXDisplay)
         {
             return egl::Error(EGL_NOT_INITIALIZED, "Could not open the default X display.");
         }
     }
 
     std::string glxInitError;
-    if (!mGLX.initialize(xDisplay, DefaultScreen(xDisplay), &glxInitError))
+    if (!mGLX.initialize(mXDisplay, DefaultScreen(mXDisplay), &glxInitError))
     {
         return egl::Error(EGL_NOT_INITIALIZED, glxInitError.c_str());
     }
@@ -235,7 +238,8 @@ egl::Error DisplayGLX::initialize(egl::Display *display)
         visualTemplate.visualid = getGLXFBConfigAttrib(mContextConfig, GLX_VISUAL_ID);
 
         int numVisuals       = 0;
-        XVisualInfo *visuals = XGetVisualInfo(xDisplay, VisualIDMask, &visualTemplate, &numVisuals);
+        XVisualInfo *visuals =
+            XGetVisualInfo(mXDisplay, VisualIDMask, &visualTemplate, &numVisuals);
         if (numVisuals <= 0)
         {
             return egl::Error(EGL_NOT_INITIALIZED,
@@ -301,6 +305,9 @@ egl::Error DisplayGLX::initialize(egl::Display *display)
         reinterpret_cast<const char*>(mFunctionsGL->getString(GL_RENDERER));
     mIsMesa = rendererString.find("Mesa") != std::string::npos;
 
+    std::string version;
+    getDriverVersion(&version);
+
     return DisplayGL::initialize(display);
 }
 
@@ -711,6 +718,20 @@ egl::Error DisplayGLX::waitClient() const
     return egl::Error(EGL_SUCCESS);
 }
 
+egl::Error DisplayGLX::getDriverVersion(std::string *version) const
+{
+    VendorID vendor = GetVendorID(mFunctionsGL);
+
+    switch (vendor)
+    {
+        case VENDOR_ID_NVIDIA:
+            return getNVIDIADriverVersion(version);
+        default:
+            *version = "";
+            return egl::Error(EGL_SUCCESS);
+    }
+}
+
 egl::Error DisplayGLX::waitNative(EGLint engine,
                                   egl::Surface *drawSurface,
                                   egl::Surface *readSurface) const
@@ -859,4 +880,29 @@ egl::Error DisplayGLX::createContextAttribs(glx::FBConfig,
     }
     return egl::Error(EGL_SUCCESS);
 }
+
+egl::Error DisplayGLX::getNVIDIADriverVersion(std::string *version) const
+{
+    *version = "";
+
+    int eventBase = 0;
+    int errorBase = 0;
+    if (XNVCTRLQueryExtension(mXDisplay, &eventBase, &errorBase))
+    {
+        int screenCount = ScreenCount(mXDisplay);
+        for (int screen = 0; screen < screenCount; ++screen)
+        {
+            char *buffer = nullptr;
+            if (XNVCTRLIsNvScreen(mXDisplay, screen) &&
+                XNVCTRLQueryStringAttribute(mXDisplay, screen, 0,
+                                            NV_CTRL_STRING_NVIDIA_DRIVER_VERSION, &buffer))
+            {
+                *version = buffer;
+                XFree(buffer);
+            }
+        }
+    }
+
+    return egl::Error(EGL_SUCCESS);
+}
 }

src/libANGLE/renderer/gl/glx/DisplayGLX.h

@@ -72,6 +72,8 @@ class DisplayGLX : public DisplayGL
                           egl::Surface *drawSurface,
                           egl::Surface *readSurface) const override;
 
+    egl::Error getDriverVersion(std::string *version) const override;
+
     // Synchronizes with the X server, if the display has been opened by ANGLE.
     // Calling this is required at the end of every functions that does buffered
     // X calls (not for glX calls) otherwise there might be race conditions
@@ -102,6 +104,8 @@ class DisplayGLX : public DisplayGL
                                     int profileMask,
                                     glx::Context *context) const;
 
+    egl::Error getNVIDIADriverVersion(std::string *version) const;
+
     FunctionsGL *mFunctionsGL;
 
     //TODO(cwallez) yuck, change generateConfigs to be non-const or add a userdata member to egl::Config?
@@ -133,6 +137,7 @@ class DisplayGLX : public DisplayGL
     int mCurrentSwapInterval;
 
     FunctionsGLX mGLX;
+    Display *mXDisplay;
     egl::Display *mEGLDisplay;
 };
 

src/libANGLE/renderer/gl/renderergl_utils.h

@@ -30,6 +30,7 @@ class FunctionsGL;
 struct WorkaroundsGL;
 
 VendorID GetVendorID(const FunctionsGL *functions);
+std::string GetDriverVersion(const FunctionsGL *functions);
 
 namespace nativegl_gl
 {

src/libANGLE/renderer/gl/wgl/DisplayWGL.cpp

@@ -641,6 +641,12 @@ egl::Error DisplayWGL::waitNative(EGLint engine,
     return egl::Error(EGL_SUCCESS);
 }
 
+egl::Error DisplayWGL::getDriverVersion(std::string *version) const
+{
+    *version = "";
+    return egl::Error(EGL_SUCCESS);
+}
+
 egl::Error DisplayWGL::registerD3DDevice(IUnknown *device, HANDLE *outHandle)
 {
     ASSERT(device != nullptr);

src/libANGLE/renderer/gl/wgl/DisplayWGL.h

@@ -57,6 +57,8 @@ class DisplayWGL : public DisplayGL
                           egl::Surface *drawSurface,
                           egl::Surface *readSurface) const override;
 
+    egl::Error getDriverVersion(std::string *version) const override;
+
     egl::Error registerD3DDevice(IUnknown *device, HANDLE *outHandle);
     void releaseD3DDevice(HANDLE handle);
 

src/libGLESv2.gypi

@@ -613,7 +613,7 @@
                                 'defines':
                                 [
                                     'ANGLE_USE_X11',
-                                ]
+                                ],
                             }],
                         ],
                     }],
@@ -732,16 +732,20 @@
                             [
                                 'ANGLE_USE_X11',
                             ],
+                            'dependencies':
+                            [
+                                '<(angle_path)/src/third_party/libXNVCtrl/libXNVCtrl.gyp:libXNVCtrl',
+                            ],
                             'sources':
                             [
                                 '<@(libangle_gl_glx_sources)',
                             ],
                             'link_settings': {
                                 'ldflags': [
-                                    '<!@(<(pkg-config) --libs-only-L --libs-only-other x11 xi)',
+                                    '<!@(<(pkg-config) --libs-only-L --libs-only-other x11 xi xext)',
                                 ],
                                 'libraries': [
-                                    '<!@(<(pkg-config) --libs-only-l x11 xi) -ldl',
+                                    '<!@(<(pkg-config) --libs-only-l x11 xi xext) -ldl',
                                 ],
                             },
                         }],

src/third_party/libXNVCtrl/BUILD.gn

+# Copyright (c) 2016 The ANGLE Project Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+static_library("libXNVCtrl") {
+    sources = [
+        "NVCtrl.c",
+        "NVCtrl.h",
+        "NVCtrlLib.h",
+        "nv_control.h",
+    ]
+}

src/third_party/libXNVCtrl/LICENSE

+/*
+ * Copyright (c) 2008 NVIDIA, Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
\ No newline at end of file

src/third_party/libXNVCtrl/README.angle

+Name: NVidia Control X Extension Library
+Short Name: libXNVCtrl
+URL: http://cgit.freedesktop.org/~aplattner/nvidia-settings/
+Version: unknown
+Date: 2008
+License: MIT
+Security Critical: no
+
+Description:
+This package provides access to NVidia Control X Extension. It is used to determine the version of the NVIDIA driver in use.
+
+The current version is pulled from nvidia-settings-302.17.
+
+Local Modifications:

src/third_party/libXNVCtrl/libXNVCtrl.gyp

+# Copyright (c) 2016 The ANGLE Project Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+{
+    'targets':
+    [{
+        'target_name': 'libXNVCtrl',
+        'type': 'static_library',
+        'sources':
+        [
+            'NVCtrl.c',
+            'NVCtrl.h',
+            'NVCtrlLib.h',
+            'nv_control.h',
+        ],
+    }],
+}