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) >= 0)
 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                               nsACString& aFailureId,
 279                               OperatingSystem* aOS /* = nullptr */)
 280
 281 {
 282   GetData();
 283
 284   NS_ENSURE_ARG_POINTER(aStatus);
 285   *aStatus = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
 286   aSuggestedDriverVersion.SetIsVoid(true);
 287   OperatingSystem os = OperatingSystem::Linux;
 288   if (aOS)
 289     *aOS = os;
 290
 291   if (mGLMajorVersion == 1) {
 292     // We're on OpenGL 1. In most cases that indicates really old hardware.
 293     // We better block them, rather than rely on them to fail gracefully, because they don't!
 294     // see bug 696636
 295     *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
 296     aFailureId = "FEATURE_FAILURE_OPENGL_1";
 297     return NS_OK;
 298   }
 299
 300   // Don't evaluate any special cases if we're checking the downloaded blocklist.
 301   if (!aDriverInfo.Length()) {
 302     // Blacklist software GL implementations from using layers acceleration.
 303     // On the test infrastructure, we'll force-enable layers acceleration.
 304     if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS &&
 305         (mIsLlvmpipe || mIsOldSwrast) &&
 306         !PR_GetEnv("MOZ_LAYERS_ALLOW_SOFTWARE_GL"))
 307     {
 308       *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
 309       aFailureId = "FEATURE_FAILURE_SOFTWARE_GL";
 310       return NS_OK;
 311     }
 312
 313     // Only check features relevant to Linux.
 314     if (aFeature == nsIGfxInfo::FEATURE_OPENGL_LAYERS ||
 315         aFeature == nsIGfxInfo::FEATURE_WEBGL_OPENGL ||
 316         aFeature == nsIGfxInfo::FEATURE_WEBGL2 ||
 317         aFeature == nsIGfxInfo::FEATURE_WEBGL_MSAA) {
 318
 319       // whitelist the linux test slaves' current configuration.
 320       // this is necessary as they're still using the slightly outdated 190.42 driver.
 321       // this isn't a huge risk, as at least this is the exact setting in which we do continuous testing,
 322       // and this only affects GeForce 9400 cards on linux on this precise driver version, which is very few users.
 323       // We do the same thing on Windows XP, see in widget/windows/GfxInfo.cpp
 324       if (mIsNVIDIA &&
 325           !strcmp(mRenderer.get(), "GeForce 9400/PCI/SSE2") &&
 326           !strcmp(mVersion.get(), "3.2.0 NVIDIA 190.42"))
 327       {
 328         *aStatus = nsIGfxInfo::FEATURE_STATUS_OK;
 329         return NS_OK;
 330       }
 331
 332       if (mIsMesa) {
 333         if (mIsNouveau && version(mMajorVersion, mMinorVersion) < version(8,0)) {
 334           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 335           aFailureId = "FEATURE_FAILURE_MESA_1";
 336           aSuggestedDriverVersion.AssignLiteral("Mesa 8.0");
 337         }
 338         else if (version(mMajorVersion, mMinorVersion, mRevisionVersion) < version(7,10,3)) {
 339           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 340           aFailureId = "FEATURE_FAILURE_MESA_2";
 341           aSuggestedDriverVersion.AssignLiteral("Mesa 7.10.3");
 342         }
 343         else if (mIsOldSwrast) {
 344           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 345           aFailureId = "FEATURE_FAILURE_SW_RAST";
 346         }
 347         else if (mIsLlvmpipe && version(mMajorVersion, mMinorVersion) < version(9, 1)) {
 348           // bug 791905, Mesa bug 57733, fixed in Mesa 9.1 according to
 349           // https://bugs.freedesktop.org/show_bug.cgi?id=57733#c3
 350           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 351           aFailureId = "FEATURE_FAILURE_MESA_3";
 352         }
 353         else if (aFeature == nsIGfxInfo::FEATURE_WEBGL_MSAA)
 354         {
 355           if (mIsIntel && version(mMajorVersion, mMinorVersion) < version(8,1)) {
 356             *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 357             aFailureId = "FEATURE_FAILURE_MESA_4";
 358             aSuggestedDriverVersion.AssignLiteral("Mesa 8.1");
 359           }
 360         }
 361
 362       } else if (mIsNVIDIA) {
 363         if (version(mMajorVersion, mMinorVersion, mRevisionVersion) < version(257,21)) {
 364           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 365           aFailureId = "FEATURE_FAILURE_OLD_NV";
 366           aSuggestedDriverVersion.AssignLiteral("NVIDIA 257.21");
 367         }
 368       } else if (mIsFGLRX) {
 369         // FGLRX does not report a driver version number, so we have the OpenGL version instead.
 370         // by requiring OpenGL 3, we effectively require recent drivers.
 371         if (version(mMajorVersion, mMinorVersion, mRevisionVersion) < version(3, 0)) {
 372           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DRIVER_VERSION;
 373           aFailureId = "FEATURE_FAILURE_OLD_FGLRX";
 374           aSuggestedDriverVersion.AssignLiteral("<Something recent>");
 375         }
 376         // Bug 724640: FGLRX + Linux 2.6.32 is a crashy combo
 377         bool unknownOS = mOS.IsEmpty() || mOSRelease.IsEmpty();
 378         bool badOS = mOS.Find("Linux", true) != -1 &&
 379                      mOSRelease.Find("2.6.32") != -1;
 380         if (unknownOS || badOS) {
 381           *aStatus = nsIGfxInfo::FEATURE_BLOCKED_OS_VERSION;
 382           aFailureId = "FEATURE_FAILURE_OLD_OS";
 383         }
 384       } else {
 385         // like on windows, let's block unknown vendors. Think of virtual machines.
 386         // Also, this case is hit whenever the GLXtest probe failed to get driver info or crashed.
 387         *aStatus = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
 388       }
 389     }
 390   }
 391
 392   return GfxInfoBase::GetFeatureStatusImpl(aFeature, aStatus, aSuggestedDriverVersion, aDriverInfo, aFailureId, &os);
 393 }
 394
 395
 396 NS_IMETHODIMP
 397 GfxInfo::GetD2DEnabled(bool *aEnabled)
 398 {
 399   return NS_ERROR_FAILURE;
 400 }
 401
 402 NS_IMETHODIMP
 403 GfxInfo::GetDWriteEnabled(bool *aEnabled)
 404 {
 405   return NS_ERROR_FAILURE;
 406 }
 407
 408 NS_IMETHODIMP
 409 GfxInfo::GetDWriteVersion(nsAString & aDwriteVersion)
 410 {
 411   return NS_ERROR_FAILURE;
 412 }
 413
 414 NS_IMETHODIMP
 415 GfxInfo::GetCleartypeParameters(nsAString & aCleartypeParams)
 416 {
 417   return NS_ERROR_FAILURE;
 418 }
 419
 420 NS_IMETHODIMP
 421 GfxInfo::GetAdapterDescription(nsAString & aAdapterDescription)
 422 {
 423   GetData();
 424   AppendASCIItoUTF16(mAdapterDescription, aAdapterDescription);
 425   return NS_OK;
 426 }
 427
 428 NS_IMETHODIMP
 429 GfxInfo::GetAdapterDescription2(nsAString & aAdapterDescription)
 430 {
 431   return NS_ERROR_FAILURE;
 432 }
 433
 434 NS_IMETHODIMP
 435 GfxInfo::GetAdapterRAM(nsAString & aAdapterRAM)
 436 {
 437   aAdapterRAM.Truncate();
 438   return NS_OK;
 439 }
 440
 441 NS_IMETHODIMP
 442 GfxInfo::GetAdapterRAM2(nsAString & aAdapterRAM)
 443 {
 444   return NS_ERROR_FAILURE;
 445 }
 446
 447 NS_IMETHODIMP
 448 GfxInfo::GetAdapterDriver(nsAString & aAdapterDriver)
 449 {
 450   aAdapterDriver.Truncate();
 451   return NS_OK;
 452 }
 453
 454 NS_IMETHODIMP
 455 GfxInfo::GetAdapterDriver2(nsAString & aAdapterDriver)
 456 {
 457   return NS_ERROR_FAILURE;
 458 }
 459
 460 NS_IMETHODIMP
 461 GfxInfo::GetAdapterDriverVersion(nsAString & aAdapterDriverVersion)
 462 {
 463   GetData();
 464   CopyASCIItoUTF16(mVersion, aAdapterDriverVersion);
 465   return NS_OK;
 466 }
 467
 468 NS_IMETHODIMP
 469 GfxInfo::GetAdapterDriverVersion2(nsAString & aAdapterDriverVersion)
 470 {
 471   return NS_ERROR_FAILURE;
 472 }
 473
 474 NS_IMETHODIMP
 475 GfxInfo::GetAdapterDriverDate(nsAString & aAdapterDriverDate)
 476 {
 477   aAdapterDriverDate.Truncate();
 478   return NS_OK;
 479 }
 480
 481 NS_IMETHODIMP
 482 GfxInfo::GetAdapterDriverDate2(nsAString & aAdapterDriverDate)
 483 {
 484   return NS_ERROR_FAILURE;
 485 }
 486
 487 NS_IMETHODIMP
 488 GfxInfo::GetAdapterVendorID(nsAString & aAdapterVendorID)
 489 {
 490   GetData();
 491   CopyUTF8toUTF16(mVendor, aAdapterVendorID);
 492   return NS_OK;
 493 }
 494
 495 NS_IMETHODIMP
 496 GfxInfo::GetAdapterVendorID2(nsAString & aAdapterVendorID)
 497 {
 498   return NS_ERROR_FAILURE;
 499 }
 500
 501 NS_IMETHODIMP
 502 GfxInfo::GetAdapterDeviceID(nsAString & aAdapterDeviceID)
 503 {
 504   GetData();
 505   CopyUTF8toUTF16(mRenderer, aAdapterDeviceID);
 506   return NS_OK;
 507 }
 508
 509 NS_IMETHODIMP
 510 GfxInfo::GetAdapterDeviceID2(nsAString & aAdapterDeviceID)
 511 {
 512   return NS_ERROR_FAILURE;
 513 }
 514
 515 NS_IMETHODIMP
 516 GfxInfo::GetAdapterSubsysID(nsAString & aAdapterSubsysID)
 517 {
 518   return NS_ERROR_FAILURE;
 519 }
 520
 521 NS_IMETHODIMP
 522 GfxInfo::GetAdapterSubsysID2(nsAString & aAdapterSubsysID)
 523 {
 524   return NS_ERROR_FAILURE;
 525 }
 526
 527 NS_IMETHODIMP
 528 GfxInfo::GetIsGPU2Active(bool* aIsGPU2Active)
 529 {
 530   return NS_ERROR_FAILURE;
 531 }
 532
 533 #ifdef DEBUG
 534
 535 // Implement nsIGfxInfoDebug
 536 // We don't support spoofing anything on Linux
 537
 538 NS_IMETHODIMP GfxInfo::SpoofVendorID(const nsAString & aVendorID)
 539 {
 540   CopyUTF16toUTF8(aVendorID, mVendor);
 541   return NS_OK;
 542 }
 543
 544 NS_IMETHODIMP GfxInfo::SpoofDeviceID(const nsAString & aDeviceID)
 545 {
 546   CopyUTF16toUTF8(aDeviceID, mRenderer);
 547   return NS_OK;
 548 }
 549
 550 NS_IMETHODIMP GfxInfo::SpoofDriverVersion(const nsAString & aDriverVersion)
 551 {
 552   CopyUTF16toUTF8(aDriverVersion, mVersion);
 553   return NS_OK;
 554 }
 555
 556 NS_IMETHODIMP GfxInfo::SpoofOSVersion(uint32_t aVersion)
 557 {
 558   // We don't support OS versioning on Linux. There's just "Linux".
 559   return NS_OK;
 560 }
 561
 562 #endif
 563
 564 } // end namespace widget
 565 } // end namespace mozilla