widget/GfxInfoX11.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: sw=2 ts=8 et :
   3  */
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #include <unistd.h>
   9 #include <sys/types.h>
  10 #include <sys/wait.h>
  11 #include <errno.h>
  12 #include <sys/utsname.h>
  13 #include "nsCRTGlue.h"
  14 #include "prenv.h"
  15
  16 #include "GfxInfoX11.h"
  17
  18 #ifdef MOZ_CRASHREPORTER
  19 #include "nsExceptionHandler.h"
  20 #include "nsICrashReporter.h"
  21 #endif
  22
  23 namespace mozilla {
  24 namespace widget {
  25
  26 #ifdef DEBUG
  27 NS_IMPL_ISUPPORTS_INHERITED(GfxInfo, GfxInfoBase, nsIGfxInfoDebug)
  28 #endif
  29
  30 // these global variables will be set when firing the glxtest process
  31 int glxtest_pipe = 0;
  32 pid_t glxtest_pid = 0;
  33
  34 nsresult
  35 GfxInfo::Init()
  36 {
  37     mGLMajorVersion = 0;
  38     mMajorVersion = 0;
  39     mMinorVersion = 0;
  40     mRevisionVersion = 0;
  41     mIsMesa = false;
  42     mIsNVIDIA = false;
  43     mIsFGLRX = false;
  44     mIsNouveau = false;
  45     mIsIntel = false;
  46     mIsOldSwrast = false;
  47     mIsLlvmpipe = false;
  48     mHasTextureFromPixmap = false;
  49     return GfxInfoBase::Init();
  50 }
  51
  52 void
  53 GfxInfo::GetData()
  54 {
  55     // to understand this function, see bug 639842. We retrieve the OpenGL driver information in a
  56     // separate process to protect against bad drivers.
  57
  58     // if glxtest_pipe == 0, that means that we already read the information
  59     if (!glxtest_pipe)
  60         return;
  61
  62     enum { buf_size = 1024 };
  63     char buf[buf_size];
  64     ssize_t bytesread = read(glxtest_pipe,
  65                              &buf,
  66                              buf_size-1); // -1 because we'll append a zero
  67     close(glxtest_pipe);
  68     glxtest_pipe = 0;
  69
  70     // bytesread < 0 would mean that the above read() call failed.
  71     // This should never happen. If it did, the outcome would be to blacklist anyway.
  72     if (bytesread < 0)
  73         bytesread = 0;
  74
  75     // let buf be a zero-terminated string
  76     buf[bytesread] = 0;
  77
  78     // Wait for the glxtest process to finish. This serves 2 purposes:
  79     // * avoid having a zombie glxtest process laying around
  80     // * get the glxtest process status info.
  81     int glxtest_status = 0;
  82     bool wait_for_glxtest_process = true;
  83     bool waiting_for_glxtest_process_failed = false;
  84     int waitpid_errno = 0;
  85     while(wait_for_glxtest_process) {
  86         wait_for_glxtest_process = false;
  87         if (waitpid(glxtest_pid, &glxtest_status, 0) == -1) {
  88             waitpid_errno = errno;
  89             if (waitpid_errno == EINTR) {
  90                 wait_for_glxtest_process = true;
  91             } else {
  92                 // Bug 718629
  93                 // ECHILD happens when the glxtest process got reaped got reaped after a PR_CreateProcess
  94                 // as per bug 227246. This shouldn't matter, as we still seem to get the data
  95                 // from the pipe, and if we didn't, the outcome would be to blacklist anyway.
  96                 waiting_for_glxtest_process_failed = (waitpid_errno != ECHILD);
  97             }
  98         }
  99     }
 100
 101     bool exited_with_error_code = !waiting_for_glxtest_process_failed &&
 102                                   WIFEXITED(glxtest_status) &&
 103                                   WEXITSTATUS(glxtest_status) != EXIT_SUCCESS;
 104     bool received_signal = !waiting_for_glxtest_process_failed &&
 105                            WIFSIGNALED(glxtest_status);
 106
 107     bool error = waiting_for_glxtest_process_failed || exited_with_error_code || received_signal;
 108
 109     nsCString textureFromPixmap;
 110     nsCString *stringToFill = nullptr;
 111     char *bufptr = buf;
 112     if (!error) {
 113         while(true) {
 114             char *line = NS_strtok("\n", &bufptr);
 115             if (!line)
 116                 break;
 117             if (stringToFill) {
 118                 stringToFill->Assign(line);
 119                 stringToFill = nullptr;
 120             }
 121             else if(!strcmp(line, "VENDOR"))
 122                 stringToFill = &mVendor;
 123             else if(!strcmp(line, "RENDERER"))
 124                 stringToFill = &mRenderer;
 125             else if(!strcmp(line, "VERSION"))
 126                 stringToFill = &mVersion;
 127             else if(!strcmp(line, "TFP"))
 128                 stringToFill = &textureFromPixmap;
 129         }
 130     }
 131
 132     if (!strcmp(textureFromPixmap.get(), "TRUE"))
 133         mHasTextureFromPixmap = true;
 134
 135     // only useful for Linux kernel version check for FGLRX driver.
 136     // assumes X client == X server, which is sad.
 137     struct utsname unameobj;
 138     if (!uname(&unameobj))
 139     {
 140       mOS.Assign(unameobj.sysname);
 141       mOSRelease.Assign(unameobj.release);
 142     }
 143
 144     const char *spoofedVendor = PR_GetEnv("MOZ_GFX_SPOOF_GL_VENDOR");
 145     if (spoofedVendor)
 146         mVendor.Assign(spoofedVendor);
 147     const char *spoofedRenderer = PR_GetEnv("MOZ_GFX_SPOOF_GL_RENDERER");
 148     if (spoofedRenderer)
 149         mRenderer.Assign(spoofedRenderer);
 150     const char *spoofedVersion = PR_GetEnv("MOZ_GFX_SPOOF_GL_VERSION");
 151     if (spoofedVersion)
 152         mVersion.Assign(spoofedVersion);
 153     const char *spoofedOS = PR_GetEnv("MOZ_GFX_SPOOF_OS");
 154     if (spoofedOS)
 155         mOS.Assign(spoofedOS);
 156     const char *spoofedOSRelease = PR_GetEnv("MOZ_GFX_SPOOF_OS_RELEASE");
 157     if (spoofedOSRelease)
 158         mOSRelease.Assign(spoofedOSRelease);
 159
 160     if (error ||
 161         mVendor.IsEmpty() ||
 162         mRenderer.IsEmpty() ||
 163         mVersion.IsEmpty() ||
 164         mOS.IsEmpty() ||
 165         mOSRelease.IsEmpty())
 166     {
 167         mAdapterDescription.AppendLiteral("GLXtest process failed");
 168         if (waiting_for_glxtest_process_failed)
 169             mAdapterDescription.AppendPrintf(" (waitpid failed with errno=%d for pid %d)", waitpid_errno, glxtest_pid);
 170         if (exited_with_error_code)
 171             mAdapterDescription.AppendPrintf(" (exited with status %d)", WEXITSTATUS(glxtest_status));
 172         if (received_signal)
 173             mAdapterDescription.AppendPrintf(" (received signal %d)", WTERMSIG(glxtest_status));
 174         if (bytesread) {
 175             mAdapterDescription.AppendLiteral(": ");
 176             mAdapterDescription.Append(nsDependentCString(buf));
 177             mAdapterDescription.Append('\n');
 178         }
 179 #ifdef MOZ_CRASHREPORTER
 180         CrashReporter::AppendAppNotesToCrashReport(mAdapterDescription);
 181 #endif
 182         return;
 183     }
 184
 185     mAdapterDescription.Append(mVendor);
 186     mAdapterDescription.AppendLiteral(" -- ");
 187     mAdapterDescription.Append(mRenderer);
 188
 189     nsAutoCString note;
 190     note.AppendLiteral("OpenGL: ");
 191     note.Append(mAdapterDescription);
 192     note.AppendLiteral(" -- ");
 193     note.Append(mVersion);
 194     if (mHasTextureFromPixmap)
 195         note.AppendLiteral(" -- texture_from_pixmap");
 196     note.Append('\n');
 197 #ifdef MOZ_CRASHREPORTER
 198     CrashReporter::AppendAppNotesToCrashReport(note);
 199 #endif
 200
 201     // determine the major OpenGL version. That's the first integer in the version string.
 202     mGLMajorVersion = strtol(mVersion.get(), 0, 10);
 203
 204     // determine driver type (vendor) and where in the version string
 205     // the actual driver version numbers should be expected to be found (whereToReadVersionNumbers)
 206     const char *whereToReadVersionNumbers = nullptr;
 207     const char *Mesa_in_version_string = strstr(mVersion.get(), "Mesa");
 208     if (Mesa_in_version_string) {
 209         mIsMesa = true;
 210         // with Mesa, the version string contains "Mesa major.minor" and that's all the version information we get:
 211         // there is no actual driver version info.
 212         whereToReadVersionNumbers = Mesa_in_version_string + strlen("Mesa");
 213         if (strcasestr(mVendor.get(), "nouveau"))
 214             mIsNouveau = true;
 215         if (strcasestr(mRenderer.get(), "intel")) // yes, intel is in the renderer string
 216             mIsIntel = true;
 217         if (strcasestr(mRenderer.get(), "llvmpipe"))
 218             mIsLlvmpipe = true;
 219         if (strcasestr(mRenderer.get(), "software rasterizer"))
 220             mIsOldSwrast = true;
 221     } else if (strstr(mVendor.get(), "NVIDIA Corporation")) {
 222         mIsNVIDIA = true;
 223         // with the NVIDIA driver, the version string contains "NVIDIA major.minor"
 224         // note that here the vendor and version strings behave differently, that's why we don't put this above
 225         // alongside Mesa_in_version_string.
 226         const char *NVIDIA_in_version_string = strstr(mVersion.get(), "NVIDIA");
 227         if (NVIDIA_in_version_string)
 228             whereToReadVersionNumbers = NVIDIA_in_version_string + strlen("NVIDIA");
 229     } else if (strstr(mVendor.get(), "ATI Technologies Inc")) {
 230         mIsFGLRX = true;
 231         // with the FGLRX driver, the version string only gives a OpenGL version :/ so let's return that.
 232         // that can at least give a rough idea of how old the driver is.
 233         whereToReadVersionNumbers = mVersion.get();
 234     }
 235
 236     // read major.minor version numbers of the driver (not to be confused with the OpenGL version)
 237     if (whereToReadVersionNumbers) {
 238         // copy into writable buffer, for tokenization
 239         strncpy(buf, whereToReadVersionNumbers, buf_size);
 240         bufptr = buf;
 241
 242         // now try to read major.minor version numbers. In case of failure, gracefully exit: these numbers have
 243         // been initialized as 0 anyways
 244         char *token = NS_strtok(".", &bufptr);
 245         if (token) {
 246             mMajorVersion = strtol(token, 0, 10);
 247             token = NS_strtok(".", &bufptr);
 248             if (token) {
 249                 mMinorVersion = strtol(token, 0, 10);
 250                 token = NS_strtok(".", &bufptr);
 251                 if (token)
 252                     mRevisionVersion = strtol(token, 0, 10);
 253             }
 254         }
 255     }
 256 }
 257
 258 static inline uint64_t version(uint32_t major, uint32_t minor, uint32_t revision = 0)
 259 {
 260     return (uint64_t(major) << 32) + (uint64_t(minor) << 16) + uint64_t(revision);
 261 }
 262
 263 const nsTArray<GfxDriverInfo>&
 264 GfxInfo::GetGfxDriverInfo()
 265 {
 266   // Nothing here yet.
 267   //if (!mDriverInfo->Length()) {
 268   //
 269   //}
 270   return *mDriverInfo;
 271 }
 272
 273 nsresult
 274 GfxInfo::GetFeatureStatusImpl(int32_t aFeature,
 275                               int32_t *aStatus,
 276                               nsAString & aSuggestedDriverVersion,
 277                               const nsTArray<GfxDriverInfo>& aDriverInfo,
 278                               OperatingSystem* aOS /* = nullptr */)
 279
 280 {
 281   GetData();
 282
 283   NS_ENSURE_ARG_POINTER(aStatus);
 284   *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
 285   aSuggestedDriverVersion.SetIsVoid(true);
 286   OperatingSystem os = DRIVER_OS_LINUX;
 287   if (aOS)
 288     *aOS = os;
 289
 290   if (mGLMajorVersion == 1) {
 291     // We're on OpenGL 1. In most cases that indicates really old hardware.
 292     // We better block them, rather than rely on them to fail gracefully, because they don't!
 293     // see bug 696636
 294     *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
 295     return NS_OK;
 296   }
 297
 298   // Don't evaluate any special cases if we're checking the downloaded blocklist.
 299   if (!aDriverInfo.Length()) {
 300     // Only check features relevant to Linux.
 301     if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS ||
 302         aFeature == nsIGfxInfo::FEATURE_WEBGL_OPENGL ||
 303         aFeature == nsIGfxInfo::FEATURE_WEBGL_MSAA) {
 304
 305       // Disable OpenGL layers when we don't have texture_from_pixmap because it regresses performance.
 306       if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS && !mHasTextureFromPixmap) {
 307         *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 308         aSuggestedDriverVersion.AssignLiteral("<Anything with EXT_texture_from_pixmap support>");
 309         return NS_OK;
 310       }
 311
 312       // whitelist the linux test slaves' current configuration.
 313       // this is necessary as they're still using the slightly outdated 190.42 driver.
 314       // this isn't a huge risk, as at least this is the exact setting in which we do continuous testing,
 315       // and this only affects GeForce 9400 cards on linux on this precise driver version, which is very few users.
 316       // We do the same thing on Windows XP, see in widget/windows/GfxInfo.cpp
 317       if (mIsNVIDIA &&
 318           !strcmp(mRenderer.get(), "GeForce 9400/PCI/SSE2") &&
 319           !strcmp(mVersion.get(), "3.2.0 NVIDIA 190.42"))
 320       {
 321         *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
 322         return NS_OK;
 323       }
 324
 325       if (mIsMesa) {
 326         if (mIsNouveau && version(mMajorVersion, mMinorVersion) < version(8,0)) {
 327           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 328           aSuggestedDriverVersion.AssignLiteral("Mesa 8.0");
 329         }
 330         else if (version(mMajorVersion, mMinorVersion, mRevisionVersion) < version(7,10,3)) {
 331           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 332           aSuggestedDriverVersion.AssignLiteral("Mesa 7.10.3");
 333         }
 334         else if (mIsOldSwrast) {
 335           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 336         }
 337         else if (mIsLlvmpipe && version(mMajorVersion, mMinorVersion) < version(9, 1)) {
 338           // bug 791905, Mesa bug 57733, fixed in Mesa 9.1 according to
 339           // https://bugs.freedesktop.org/show_bug.cgi?id=57733#c3
 340           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 341         }
 342         else if (aFeature == nsIGfxInfo::FEATURE_WEBGL_MSAA)
 343         {
 344           if (mIsIntel && version(mMajorVersion, mMinorVersion) < version(8,1)) {
 345             *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 346             aSuggestedDriverVersion.AssignLiteral("Mesa 8.1");
 347           }
 348         }
 349
 350       } else if (mIsNVIDIA) {
 351         if (version(mMajorVersion, mMinorVersion, mRevisionVersion) < version(257,21)) {
 352           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 353           aSuggestedDriverVersion.AssignLiteral("NVIDIA 257.21");
 354         }
 355       } else if (mIsFGLRX) {
 356         // FGLRX does not report a driver version number, so we have the OpenGL version instead.
 357         // by requiring OpenGL 3, we effectively require recent drivers.
 358         if (version(mMajorVersion, mMinorVersion, mRevisionVersion) < version(3, 0)) {
 359           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 360           aSuggestedDriverVersion.AssignLiteral("<Something recent>");
 361         }
 362         // Bug 724640: FGLRX + Linux 2.6.32 is a crashy combo
 363         bool unknownOS = mOS.IsEmpty() || mOSRelease.IsEmpty();
 364         bool badOS = mOS.Find("Linux", true) != -1 &&
 365                      mOSRelease.Find("2.6.32") != -1;
 366         if (unknownOS || badOS) {
 367           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION;
 368         }
 369       } else {
 370         // like on windows, let's block unknown vendors. Think of virtual machines.
 371         // Also, this case is hit whenever the GLXtest probe failed to get driver info or crashed.
 372         *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
 373       }
 374     }
 375   }
 376
 377   return GfxInfoBase::GetFeatureStatusImpl(aFeature, aStatus, aSuggestedDriverVersion, aDriverInfo, &os);
 378 }
 379
 380
 381 NS_IMETHODIMP
 382 GfxInfo::GetD2DEnabled(bool *aEnabled)
 383 {
 384   return NS_ERROR_FAILURE;
 385 }
 386
 387 NS_IMETHODIMP
 388 GfxInfo::GetDWriteEnabled(bool *aEnabled)
 389 {
 390   return NS_ERROR_FAILURE;
 391 }
 392
 393 /* readonly attribute DOMString DWriteVersion; */
 394 NS_IMETHODIMP
 395 GfxInfo::GetDWriteVersion(nsAString & aDwriteVersion)
 396 {
 397   return NS_ERROR_FAILURE;
 398 }
 399
 400 /* readonly attribute DOMString cleartypeParameters; */
 401 NS_IMETHODIMP
 402 GfxInfo::GetCleartypeParameters(nsAString & aCleartypeParams)
 403 {
 404   return NS_ERROR_FAILURE;
 405 }
 406
 407 /* readonly attribute DOMString adapterDescription; */
 408 NS_IMETHODIMP
 409 GfxInfo::GetAdapterDescription(nsAString & aAdapterDescription)
 410 {
 411   GetData();
 412   AppendASCIItoUTF16(mAdapterDescription, aAdapterDescription);
 413   return NS_OK;
 414 }
 415
 416 /* readonly attribute DOMString adapterDescription2; */
 417 NS_IMETHODIMP
 418 GfxInfo::GetAdapterDescription2(nsAString & aAdapterDescription)
 419 {
 420   return NS_ERROR_FAILURE;
 421 }
 422
 423 /* readonly attribute DOMString adapterRAM; */
 424 NS_IMETHODIMP
 425 GfxInfo::GetAdapterRAM(nsAString & aAdapterRAM)
 426 {
 427   aAdapterRAM.Truncate();
 428   return NS_OK;
 429 }
 430
 431 /* readonly attribute DOMString adapterRAM2; */
 432 NS_IMETHODIMP
 433 GfxInfo::GetAdapterRAM2(nsAString & aAdapterRAM)
 434 {
 435   return NS_ERROR_FAILURE;
 436 }
 437
 438 /* readonly attribute DOMString adapterDriver; */
 439 NS_IMETHODIMP
 440 GfxInfo::GetAdapterDriver(nsAString & aAdapterDriver)
 441 {
 442   aAdapterDriver.Truncate();
 443   return NS_OK;
 444 }
 445
 446 /* readonly attribute DOMString adapterDriver2; */
 447 NS_IMETHODIMP
 448 GfxInfo::GetAdapterDriver2(nsAString & aAdapterDriver)
 449 {
 450   return NS_ERROR_FAILURE;
 451 }
 452
 453 /* readonly attribute DOMString adapterDriverVersion; */
 454 NS_IMETHODIMP
 455 GfxInfo::GetAdapterDriverVersion(nsAString & aAdapterDriverVersion)
 456 {
 457   GetData();
 458   CopyASCIItoUTF16(mVersion, aAdapterDriverVersion);
 459   return NS_OK;
 460 }
 461
 462 /* readonly attribute DOMString adapterDriverVersion2; */
 463 NS_IMETHODIMP
 464 GfxInfo::GetAdapterDriverVersion2(nsAString & aAdapterDriverVersion)
 465 {
 466   return NS_ERROR_FAILURE;
 467 }
 468
 469 /* readonly attribute DOMString adapterDriverDate; */
 470 NS_IMETHODIMP
 471 GfxInfo::GetAdapterDriverDate(nsAString & aAdapterDriverDate)
 472 {
 473   aAdapterDriverDate.Truncate();
 474   return NS_OK;
 475 }
 476
 477 /* readonly attribute DOMString adapterDriverDate2; */
 478 NS_IMETHODIMP
 479 GfxInfo::GetAdapterDriverDate2(nsAString & aAdapterDriverDate)
 480 {
 481   return NS_ERROR_FAILURE;
 482 }
 483
 484 /* readonly attribute DOMString adapterVendorID; */
 485 NS_IMETHODIMP
 486 GfxInfo::GetAdapterVendorID(nsAString & aAdapterVendorID)
 487 {
 488   GetData();
 489   CopyUTF8toUTF16(mVendor, aAdapterVendorID);
 490   return NS_OK;
 491 }
 492
 493 /* readonly attribute DOMString adapterVendorID2; */
 494 NS_IMETHODIMP
 495 GfxInfo::GetAdapterVendorID2(nsAString & aAdapterVendorID)
 496 {
 497   return NS_ERROR_FAILURE;
 498 }
 499
 500 /* readonly attribute DOMString adapterDeviceID; */
 501 NS_IMETHODIMP
 502 GfxInfo::GetAdapterDeviceID(nsAString & aAdapterDeviceID)
 503 {
 504   GetData();
 505   CopyUTF8toUTF16(mRenderer, aAdapterDeviceID);
 506   return NS_OK;
 507 }
 508
 509 /* readonly attribute DOMString adapterDeviceID2; */
 510 NS_IMETHODIMP
 511 GfxInfo::GetAdapterDeviceID2(nsAString & aAdapterDeviceID)
 512 {
 513   return NS_ERROR_FAILURE;
 514 }
 515
 516 /* readonly attribute DOMString adapterSubsysID; */
 517 NS_IMETHODIMP
 518 GfxInfo::GetAdapterSubsysID(nsAString & aAdapterSubsysID)
 519 {
 520   return NS_ERROR_FAILURE;
 521 }
 522
 523 /* readonly attribute DOMString adapterSubsysID2; */
 524 NS_IMETHODIMP
 525 GfxInfo::GetAdapterSubsysID2(nsAString & aAdapterSubsysID)
 526 {
 527   return NS_ERROR_FAILURE;
 528 }
 529
 530 /* readonly attribute boolean isGPU2Active; */
 531 NS_IMETHODIMP
 532 GfxInfo::GetIsGPU2Active(bool* aIsGPU2Active)
 533 {
 534   return NS_ERROR_FAILURE;
 535 }
 536
 537 #ifdef DEBUG
 538
 539 // Implement nsIGfxInfoDebug
 540 // We don't support spoofing anything on Linux
 541
 542 /* void spoofVendorID (in DOMString aVendorID); */
 543 NS_IMETHODIMP GfxInfo::SpoofVendorID(const nsAString & aVendorID)
 544 {
 545   CopyUTF16toUTF8(aVendorID, mVendor);
 546   return NS_OK;
 547 }
 548
 549 /* void spoofDeviceID (in unsigned long aDeviceID); */
 550 NS_IMETHODIMP GfxInfo::SpoofDeviceID(const nsAString & aDeviceID)
 551 {
 552   CopyUTF16toUTF8(aDeviceID, mRenderer);
 553   return NS_OK;
 554 }
 555
 556 /* void spoofDriverVersion (in DOMString aDriverVersion); */
 557 NS_IMETHODIMP GfxInfo::SpoofDriverVersion(const nsAString & aDriverVersion)
 558 {
 559   CopyUTF16toUTF8(aDriverVersion, mVersion);
 560   return NS_OK;
 561 }
 562
 563 /* void spoofOSVersion (in unsigned long aVersion); */
 564 NS_IMETHODIMP GfxInfo::SpoofOSVersion(uint32_t aVersion)
 565 {
 566   // We don't support OS versioning on Linux. There's just "Linux".
 567   return NS_OK;
 568 }
 569
 570 #endif
 571
 572 } // end namespace widget
 573 } // end namespace mozilla