gfx/webrender_bindings/RenderThread.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "base/task.h"
   8 #include "GeckoProfiler.h"
   9 #include "gfxPlatform.h"
  10 #include "GLContext.h"
  11 #include "RenderThread.h"
  12 #include "nsThread.h"
  13 #include "nsThreadUtils.h"
  14 #include "transport/runnable_utils.h"
  15 #include "mozilla/BackgroundHangMonitor.h"
  16 #include "mozilla/layers/AsyncImagePipelineManager.h"
  17 #include "mozilla/gfx/gfxVars.h"
  18 #include "mozilla/gfx/GPUParent.h"
  19 #include "mozilla/gfx/GPUProcessManager.h"
  20 #include "mozilla/glean/GleanMetrics.h"
  21 #include "mozilla/layers/CompositorThread.h"
  22 #include "mozilla/layers/CompositorBridgeParent.h"
  23 #include "mozilla/layers/CompositorManagerParent.h"
  24 #include "mozilla/layers/WebRenderBridgeParent.h"
  25 #include "mozilla/layers/SharedSurfacesParent.h"
  26 #include "mozilla/layers/SurfacePool.h"
  27 #include "mozilla/layers/SynchronousTask.h"
  28 #include "mozilla/PerfStats.h"
  29 #include "mozilla/StaticPtr.h"
  30 #include "mozilla/Telemetry.h"
  31 #include "mozilla/webrender/RendererOGL.h"
  32 #include "mozilla/webrender/RenderTextureHost.h"
  33 #include "mozilla/widget/CompositorWidget.h"
  34 #include "OGLShaderProgram.h"
  35
  36 #ifdef XP_WIN
  37 #  include "GLContextEGL.h"
  38 #  include "GLLibraryEGL.h"
  39 #  include "mozilla/widget/WinCompositorWindowThread.h"
  40 #  include "mozilla/gfx/DeviceManagerDx.h"
  41 #  include "mozilla/webrender/DCLayerTree.h"
  42 // #  include "nsWindowsHelpers.h"
  43 // #  include <d3d11.h>
  44 #endif
  45
  46 #ifdef MOZ_WIDGET_ANDROID
  47 #  include "GLLibraryEGL.h"
  48 #  include "mozilla/webrender/RenderAndroidSurfaceTextureHost.h"
  49 #endif
  50
  51 #ifdef MOZ_WIDGET_GTK
  52 #  include "mozilla/WidgetUtilsGtk.h"
  53 #  include "GLLibraryEGL.h"
  54 #endif
  55
  56 using namespace mozilla;
  57
  58 static already_AddRefed<gl::GLContext> CreateGLContext(nsACString& aError);
  59
  60 MOZ_DEFINE_MALLOC_SIZE_OF(WebRenderRendererMallocSizeOf)
  61
  62 namespace mozilla::wr {
  63
  64 LazyLogModule gRenderThreadLog("RenderThread");
  65 // Should be called only on RenderThread, since LazyLogModule is not thread safe
  66 #define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__))
  67
  68 static StaticRefPtr<RenderThread> sRenderThread;
  69 static mozilla::BackgroundHangMonitor* sBackgroundHangMonitor;
  70 #ifdef DEBUG
  71 static bool sRenderThreadEverStarted = false;
  72 #endif
  73
  74 RenderThread::RenderThread(RefPtr<nsIThread> aThread)
  75     : mThread(std::move(aThread)),
  76       mThreadPool(false),
  77       mThreadPoolLP(true),
  78       mSingletonGLIsForHardwareWebRender(true),
  79       mWindowInfos("RenderThread.mWindowInfos"),
  80       mRenderTextureMapLock("RenderThread.mRenderTextureMapLock"),
  81       mHasShutdown(false),
  82       mHandlingDeviceReset(false),
  83       mHandlingWebRenderError(false) {}
  84
  85 RenderThread::~RenderThread() { MOZ_ASSERT(mRenderTexturesDeferred.empty()); }
  86
  87 // static
  88 RenderThread* RenderThread::Get() { return sRenderThread; }
  89
  90 // static
  91 void RenderThread::Start(uint32_t aNamespace) {
  92   MOZ_ASSERT(NS_IsMainThread());
  93   MOZ_ASSERT(!sRenderThread);
  94
  95 #ifdef DEBUG
  96   // Check to ensure nobody will try to ever start us more than once during
  97   // the process' lifetime (in particular after ShutDown).
  98   MOZ_ASSERT(!sRenderThreadEverStarted);
  99   sRenderThreadEverStarted = true;
 100 #endif
 101
 102   // When the CanvasRenderer thread is disabled, WebGL may be handled on this
 103   // thread, requiring a bigger stack size. See: CanvasManagerParent::Init
 104   //
 105   // This is 4M, which is higher than the default 256K.
 106   // Increased with bug 1753349 to accommodate the `chromium/5359` branch of
 107   // ANGLE, which has large peak stack usage for some pathological shader
 108   // compilations.
 109   //
 110   // Previously increased to 512K to accommodate Mesa in bug 1753340.
 111   //
 112   // Previously increased to 320K to avoid a stack overflow in the
 113   // Intel Vulkan driver initialization in bug 1716120.
 114   //
 115   // Note: we only override it if it's limited already.
 116   uint32_t stackSize = nsIThreadManager::DEFAULT_STACK_SIZE;
 117   if (stackSize && !gfx::gfxVars::SupportsThreadsafeGL()) {
 118     stackSize = std::max(stackSize, 4096U << 10);
 119   }
 120
 121   RefPtr<nsIThread> thread;
 122   nsresult rv = NS_NewNamedThread(
 123       "Renderer", getter_AddRefs(thread),
 124       NS_NewRunnableFunction(
 125           "Renderer::BackgroundHanSetup",
 126           []() {
 127             sBackgroundHangMonitor = new mozilla::BackgroundHangMonitor(
 128                 "Render",
 129                 /* Timeout values are powers-of-two to enable us get better
 130                    data. 128ms is chosen for transient hangs because 8Hz should
 131                    be the minimally acceptable goal for Render
 132                    responsiveness (normal goal is 60Hz). */
 133                 128,
 134                 /* 2048ms is chosen for permanent hangs because it's longer than
 135                  * most Render hangs seen in the wild, but is short enough
 136                  * to not miss getting native hang stacks. */
 137                 2048);
 138             nsCOMPtr<nsIThread> thread = NS_GetCurrentThread();
 139             nsThread* nsthread = static_cast<nsThread*>(thread.get());
 140             nsthread->SetUseHangMonitor(true);
 141             nsthread->SetPriority(nsISupportsPriority::PRIORITY_HIGH);
 142           }),
 143       {.stackSize = stackSize});
 144
 145   if (NS_FAILED(rv)) {
 146     gfxCriticalNote << "Failed to create Renderer thread: "
 147                     << gfx::hexa((uint32_t)rv);
 148     return;
 149   }
 150
 151   sRenderThread = new RenderThread(thread);
 152 #ifdef XP_WIN
 153   widget::WinCompositorWindowThread::Start();
 154 #endif
 155   layers::SharedSurfacesParent::Initialize();
 156
 157   RefPtr<Runnable> runnable = WrapRunnable(
 158       RefPtr<RenderThread>(sRenderThread.get()), &RenderThread::InitDeviceTask);
 159   sRenderThread->PostRunnable(runnable.forget());
 160 }
 161
 162 // static
 163 void RenderThread::ShutDown() {
 164   MOZ_ASSERT(NS_IsMainThread());
 165   MOZ_ASSERT(sRenderThread);
 166
 167   {
 168     MutexAutoLock lock(sRenderThread->mRenderTextureMapLock);
 169     sRenderThread->mHasShutdown = true;
 170   }
 171
 172   RefPtr<Runnable> runnable = WrapRunnable(
 173       RefPtr<RenderThread>(sRenderThread.get()), &RenderThread::ShutDownTask);
 174   sRenderThread->PostRunnable(runnable.forget());
 175
 176   // This will empty the thread queue and thus run the above runnable while
 177   // spinning the MT event loop.
 178   nsCOMPtr<nsIThread> oldThread = sRenderThread->GetRenderThread();
 179   oldThread->Shutdown();
 180
 181   layers::SharedSurfacesParent::Shutdown();
 182
 183 #ifdef XP_WIN
 184   if (widget::WinCompositorWindowThread::Get()) {
 185     widget::WinCompositorWindowThread::ShutDown();
 186   }
 187 #endif
 188
 189   // We null this out only after we finished shutdown to give everbody the
 190   // chance to check for sRenderThread->mHasShutdown. Hopefully everybody
 191   // checks this before using us!
 192   sRenderThread = nullptr;
 193 }
 194
 195 extern void ClearAllBlobImageResources();
 196
 197 void RenderThread::ShutDownTask() {
 198   MOZ_ASSERT(IsInRenderThread());
 199   LOG("RenderThread::ShutDownTask()");
 200
 201   {
 202     // Clear RenderTextureHosts
 203     MutexAutoLock lock(mRenderTextureMapLock);
 204     mRenderTexturesDeferred.clear();
 205     mRenderTextures.clear();
 206     mSyncObjectNeededRenderTextures.clear();
 207     mRenderTextureOps.clear();
 208   }
 209
 210   // Let go of our handle to the (internally ref-counted) thread pool.
 211   mThreadPool.Release();
 212   mThreadPoolLP.Release();
 213
 214   // Releasing on the render thread will allow us to avoid dispatching to remove
 215   // remaining textures from the texture map.
 216   layers::SharedSurfacesParent::ShutdownRenderThread();
 217
 218 #ifdef XP_WIN
 219   DCLayerTree::Shutdown();
 220 #endif
 221
 222   ClearAllBlobImageResources();
 223   ClearSingletonGL();
 224   ClearSharedSurfacePool();
 225 }
 226
 227 // static
 228 bool RenderThread::IsInRenderThread() {
 229   return sRenderThread && sRenderThread->mThread == NS_GetCurrentThread();
 230 }
 231
 232 // static
 233 already_AddRefed<nsIThread> RenderThread::GetRenderThread() {
 234   nsCOMPtr<nsIThread> thread;
 235   if (sRenderThread) {
 236     thread = sRenderThread->mThread;
 237   }
 238   return thread.forget();
 239 }
 240
 241 void RenderThread::DoAccumulateMemoryReport(
 242     MemoryReport aReport,
 243     const RefPtr<MemoryReportPromise::Private>& aPromise) {
 244   MOZ_ASSERT(IsInRenderThread());
 245
 246   for (auto& r : mRenderers) {
 247     r.second->AccumulateMemoryReport(&aReport);
 248   }
 249
 250   // Note memory used by the shader cache, which is shared across all WR
 251   // instances.
 252   MOZ_ASSERT(aReport.shader_cache == 0);
 253   if (mProgramCache) {
 254     aReport.shader_cache = wr_program_cache_report_memory(
 255         mProgramCache->Raw(), &WebRenderRendererMallocSizeOf);
 256   }
 257
 258   size_t renderTextureMemory = 0;
 259   {
 260     MutexAutoLock lock(mRenderTextureMapLock);
 261     for (const auto& entry : mRenderTextures) {
 262       renderTextureMemory += entry.second->Bytes();
 263     }
 264   }
 265   aReport.render_texture_hosts = renderTextureMemory;
 266
 267   aPromise->Resolve(aReport, __func__);
 268 }
 269
 270 // static
 271 RefPtr<MemoryReportPromise> RenderThread::AccumulateMemoryReport(
 272     MemoryReport aInitial) {
 273   RefPtr<MemoryReportPromise::Private> p =
 274       new MemoryReportPromise::Private(__func__);
 275   MOZ_ASSERT(!IsInRenderThread());
 276   if (!Get()) {
 277     // This happens when the GPU process fails to start and we fall back to the
 278     // basic compositor in the parent process. We could assert against this if
 279     // we made the webrender detection code in gfxPlatform.cpp smarter. See bug
 280     // 1494430 comment 12.
 281     NS_WARNING("No render thread, returning empty memory report");
 282     p->Resolve(aInitial, __func__);
 283     return p;
 284   }
 285
 286   Get()->PostRunnable(
 287       NewRunnableMethod<MemoryReport, RefPtr<MemoryReportPromise::Private>>(
 288           "wr::RenderThread::DoAccumulateMemoryReport", Get(),
 289           &RenderThread::DoAccumulateMemoryReport, aInitial, p));
 290
 291   return p;
 292 }
 293
 294 void RenderThread::AddRenderer(wr::WindowId aWindowId,
 295                                UniquePtr<RendererOGL> aRenderer) {
 296   MOZ_ASSERT(IsInRenderThread());
 297   LOG("RenderThread::AddRenderer() aWindowId %" PRIx64 "", AsUint64(aWindowId));
 298
 299   if (mHasShutdown) {
 300     return;
 301   }
 302
 303   mRenderers[aWindowId] = std::move(aRenderer);
 304   CrashReporter::AnnotateCrashReport(
 305       CrashReporter::Annotation::GraphicsNumRenderers,
 306       (unsigned int)mRenderers.size());
 307
 308   auto windows = mWindowInfos.Lock();
 309   windows->emplace(AsUint64(aWindowId), new WindowInfo());
 310   mWrNotifierEventsQueues.emplace(AsUint64(aWindowId),
 311                                   new std::queue<WrNotifierEvent>);
 312 }
 313
 314 void RenderThread::RemoveRenderer(wr::WindowId aWindowId) {
 315   MOZ_ASSERT(IsInRenderThread());
 316   LOG("RenderThread::RemoveRenderer() aWindowId %" PRIx64 "",
 317       AsUint64(aWindowId));
 318
 319   if (mHasShutdown) {
 320     return;
 321   }
 322
 323   mRenderers.erase(aWindowId);
 324   CrashReporter::AnnotateCrashReport(
 325       CrashReporter::Annotation::GraphicsNumRenderers,
 326       (unsigned int)mRenderers.size());
 327
 328   if (mRenderers.empty()) {
 329     if (mHandlingDeviceReset) {
 330       ClearSingletonGL();
 331     }
 332     mHandlingDeviceReset = false;
 333     mHandlingWebRenderError = false;
 334   }
 335
 336   auto windows = mWindowInfos.Lock();
 337   auto it = windows->find(AsUint64(aWindowId));
 338   MOZ_ASSERT(it != windows->end());
 339   windows->erase(it);
 340
 341   // Defer std::deque<WrNotifierEvent> remove, RemoveRenderer() is called in
 342   // HandleWrNotifierEvents().
 343   RefPtr<Runnable> runnable =
 344       NS_NewRunnableFunction("RenderThread::RemoveRenderer", [aWindowId]() {
 345         auto* self = RenderThread::Get();
 346         auto it = self->mWrNotifierEventsQueues.find(AsUint64(aWindowId));
 347         if (it == self->mWrNotifierEventsQueues.end()) {
 348           return;
 349         }
 350         self->mWrNotifierEventsQueues.erase(it);
 351       });
 352   RenderThread::Get()->PostRunnable(runnable.forget());
 353 }
 354
 355 RendererOGL* RenderThread::GetRenderer(wr::WindowId aWindowId) {
 356   MOZ_ASSERT(IsInRenderThread());
 357
 358   auto it = mRenderers.find(aWindowId);
 359   MOZ_ASSERT(it != mRenderers.end());
 360
 361   if (it == mRenderers.end()) {
 362     return nullptr;
 363   }
 364
 365   return it->second.get();
 366 }
 367
 368 size_t RenderThread::RendererCount() const {
 369   MOZ_ASSERT(IsInRenderThread());
 370   return mRenderers.size();
 371 }
 372
 373 size_t RenderThread::ActiveRendererCount() const {
 374   MOZ_ASSERT(IsInRenderThread());
 375   size_t num_active = 0;
 376   for (const auto& it : mRenderers) {
 377     if (!it.second->IsPaused()) {
 378       num_active++;
 379     }
 380   }
 381   return num_active;
 382 }
 383
 384 void RenderThread::WrNotifierEvent_WakeUp(WrWindowId aWindowId,
 385                                           bool aCompositeNeeded) {
 386   auto windows = mWindowInfos.Lock();
 387   auto it = windows->find(AsUint64(aWindowId));
 388   if (it == windows->end()) {
 389     MOZ_ASSERT(false);
 390     return;
 391   }
 392
 393   WindowInfo* info = it->second.get();
 394
 395   info->mPendingWrNotifierEvents.emplace(
 396       WrNotifierEvent::WakeUp(aCompositeNeeded));
 397   PostWrNotifierEvents(aWindowId, info);
 398 }
 399
 400 void RenderThread::WrNotifierEvent_NewFrameReady(WrWindowId aWindowId,
 401                                                  bool aCompositeNeeded,
 402                                                  FramePublishId aPublishId) {
 403   auto windows = mWindowInfos.Lock();
 404   auto it = windows->find(AsUint64(aWindowId));
 405   if (it == windows->end()) {
 406     MOZ_ASSERT(false);
 407     return;
 408   }
 409   WindowInfo* info = it->second.get();
 410
 411   info->mPendingWrNotifierEvents.emplace(
 412       WrNotifierEvent::NewFrameReady(aCompositeNeeded, aPublishId));
 413   PostWrNotifierEvents(aWindowId, info);
 414 }
 415
 416 void RenderThread::WrNotifierEvent_ExternalEvent(WrWindowId aWindowId,
 417                                                  size_t aRawEvent) {
 418   UniquePtr<RendererEvent> evt(reinterpret_cast<RendererEvent*>(aRawEvent));
 419   {
 420     auto windows = mWindowInfos.Lock();
 421     auto it = windows->find(AsUint64(aWindowId));
 422     if (it == windows->end()) {
 423       MOZ_ASSERT(false);
 424       return;
 425     }
 426     WindowInfo* info = it->second.get();
 427
 428     info->mPendingWrNotifierEvents.emplace(
 429         WrNotifierEvent::ExternalEvent(std::move(evt)));
 430     PostWrNotifierEvents(aWindowId, info);
 431   }
 432 }
 433
 434 void RenderThread::PostWrNotifierEvents(WrWindowId aWindowId) {
 435   {
 436     auto windows = mWindowInfos.Lock();
 437     auto it = windows->find(AsUint64(aWindowId));
 438     if (it == windows->end()) {
 439       MOZ_ASSERT(false);
 440       return;
 441     }
 442     WindowInfo* info = it->second.get();
 443     PostWrNotifierEvents(aWindowId, info);
 444   }
 445 }
 446
 447 void RenderThread::PostWrNotifierEvents(WrWindowId aWindowId,
 448                                         WindowInfo* aInfo) {
 449   // Runnable has already been triggered.
 450   if (aInfo->mWrNotifierEventsRunnable) {
 451     return;
 452   }
 453
 454   // Runnable has not been triggered yet.
 455   RefPtr<nsIRunnable> runnable = NewRunnableMethod<WrWindowId>(
 456       "RenderThread::HandleWrNotifierEvents", this,
 457       &RenderThread::HandleWrNotifierEvents, aWindowId);
 458   aInfo->mWrNotifierEventsRunnable = runnable;
 459   PostRunnable(runnable.forget());
 460 }
 461
 462 void RenderThread::HandleWrNotifierEvents(WrWindowId aWindowId) {
 463   MOZ_ASSERT(IsInRenderThread());
 464
 465   auto eventsIt = mWrNotifierEventsQueues.find(AsUint64(aWindowId));
 466   if (eventsIt == mWrNotifierEventsQueues.end()) {
 467     return;
 468   }
 469   auto* events = eventsIt->second.get();
 470
 471   {
 472     auto windows = mWindowInfos.Lock();
 473     auto infoIt = windows->find(AsUint64(aWindowId));
 474     if (infoIt == windows->end()) {
 475       MOZ_ASSERT(false);
 476       return;
 477     }
 478     WindowInfo* info = infoIt->second.get();
 479     info->mWrNotifierEventsRunnable = nullptr;
 480
 481     if (events->empty() && !info->mPendingWrNotifierEvents.empty()) {
 482       events->swap(info->mPendingWrNotifierEvents);
 483     }
 484   }
 485
 486   bool handleNext = true;
 487
 488   while (!events->empty() && handleNext) {
 489     auto& front = events->front();
 490     switch (front.mTag) {
 491       case WrNotifierEvent::Tag::WakeUp:
 492         WrNotifierEvent_HandleWakeUp(aWindowId, front.CompositeNeeded());
 493         handleNext = false;
 494         break;
 495       case WrNotifierEvent::Tag::NewFrameReady:
 496         WrNotifierEvent_HandleNewFrameReady(aWindowId, front.CompositeNeeded(),
 497                                             front.PublishId());
 498         handleNext = false;
 499         break;
 500       case WrNotifierEvent::Tag::ExternalEvent:
 501         WrNotifierEvent_HandleExternalEvent(aWindowId, front.ExternalEvent());
 502         break;
 503     }
 504     events->pop();
 505   }
 506
 507   {
 508     auto windows = mWindowInfos.Lock();
 509     auto it = windows->find(AsUint64(aWindowId));
 510     if (it == windows->end()) {
 511       return;
 512     }
 513     WindowInfo* info = it->second.get();
 514
 515     if (!events->empty() || !info->mPendingWrNotifierEvents.empty()) {
 516       PostWrNotifierEvents(aWindowId, info);
 517     }
 518   }
 519 }
 520
 521 void RenderThread::WrNotifierEvent_HandleWakeUp(wr::WindowId aWindowId,
 522                                                 bool aCompositeNeeded) {
 523   MOZ_ASSERT(IsInRenderThread());
 524
 525   bool isTrackedFrame = false;
 526   HandleFrameOneDoc(aWindowId, aCompositeNeeded, isTrackedFrame, Nothing());
 527 }
 528
 529 void RenderThread::WrNotifierEvent_HandleNewFrameReady(
 530     wr::WindowId aWindowId, bool aCompositeNeeded, FramePublishId aPublishId) {
 531   MOZ_ASSERT(IsInRenderThread());
 532
 533   bool isTrackedFrame = true;
 534   HandleFrameOneDoc(aWindowId, aCompositeNeeded, isTrackedFrame,
 535                     Some(aPublishId));
 536 }
 537
 538 void RenderThread::WrNotifierEvent_HandleExternalEvent(
 539     wr::WindowId aWindowId, UniquePtr<RendererEvent> aRendererEvent) {
 540   MOZ_ASSERT(IsInRenderThread());
 541
 542   RunEvent(aWindowId, std::move(aRendererEvent));
 543 }
 544
 545 void RenderThread::BeginRecordingForWindow(wr::WindowId aWindowId,
 546                                            const TimeStamp& aRecordingStart,
 547                                            wr::PipelineId aRootPipelineId) {
 548   MOZ_ASSERT(IsInRenderThread());
 549   RendererOGL* renderer = GetRenderer(aWindowId);
 550   MOZ_ASSERT(renderer);
 551
 552   renderer->BeginRecording(aRecordingStart, aRootPipelineId);
 553 }
 554
 555 Maybe<layers::FrameRecording> RenderThread::EndRecordingForWindow(
 556     wr::WindowId aWindowId) {
 557   MOZ_ASSERT(IsInRenderThread());
 558
 559   RendererOGL* renderer = GetRenderer(aWindowId);
 560   MOZ_ASSERT(renderer);
 561   return renderer->EndRecording();
 562 }
 563
 564 void RenderThread::HandleFrameOneDoc(wr::WindowId aWindowId, bool aRender,
 565                                      bool aTrackedFrame,
 566                                      Maybe<FramePublishId> aPublishId) {
 567   MOZ_ASSERT(IsInRenderThread());
 568
 569   if (mHasShutdown) {
 570     return;
 571   }
 572
 573   HandleFrameOneDocInner(aWindowId, aRender, aTrackedFrame, aPublishId);
 574
 575   if (aTrackedFrame) {
 576     DecPendingFrameCount(aWindowId);
 577   }
 578 }
 579
 580 void RenderThread::HandleFrameOneDocInner(wr::WindowId aWindowId, bool aRender,
 581                                           bool aTrackedFrame,
 582                                           Maybe<FramePublishId> aPublishId) {
 583   if (IsDestroyed(aWindowId)) {
 584     return;
 585   }
 586
 587   if (mHandlingDeviceReset) {
 588     return;
 589   }
 590
 591   bool render = aRender;
 592   PendingFrameInfo frame;
 593   if (aTrackedFrame) {
 594     // scope lock
 595     auto windows = mWindowInfos.Lock();
 596     auto it = windows->find(AsUint64(aWindowId));
 597     if (it == windows->end()) {
 598       MOZ_ASSERT(false);
 599       return;
 600     }
 601
 602     WindowInfo* info = it->second.get();
 603     PendingFrameInfo& frameInfo = info->mPendingFrames.front();
 604
 605     frame = frameInfo;
 606   } else {
 607     // Just give the frame info default values.
 608     frame = {TimeStamp::Now(), VsyncId()};
 609   }
 610
 611   // Sadly this doesn't include the lock, since we don't have the frame there
 612   // yet.
 613   glean::wr::time_to_render_start.AccumulateRawDuration(TimeStamp::Now() -
 614                                                         frame.mStartTime);
 615
 616   // It is for ensuring that PrepareForUse() is called before
 617   // RenderTextureHost::Lock().
 618   HandleRenderTextureOps();
 619
 620   if (aPublishId.isSome()) {
 621     SetFramePublishId(aWindowId, aPublishId.ref());
 622   }
 623
 624   UpdateAndRender(aWindowId, frame.mStartId, frame.mStartTime, render,
 625                   /* aReadbackSize */ Nothing(),
 626                   /* aReadbackFormat */ Nothing(),
 627                   /* aReadbackBuffer */ Nothing());
 628
 629   // The start time is from WebRenderBridgeParent::CompositeToTarget. From that
 630   // point until now (when the frame is finally pushed to the screen) is
 631   // equivalent to the COMPOSITE_TIME metric in the non-WR codepath.
 632   TimeDuration compositeDuration = TimeStamp::Now() - frame.mStartTime;
 633   mozilla::Telemetry::Accumulate(mozilla::Telemetry::COMPOSITE_TIME,
 634                                  uint32_t(compositeDuration.ToMilliseconds()));
 635   PerfStats::RecordMeasurement(PerfStats::Metric::Compositing,
 636                                compositeDuration);
 637 }
 638
 639 void RenderThread::SetClearColor(wr::WindowId aWindowId, wr::ColorF aColor) {
 640   if (mHasShutdown) {
 641     return;
 642   }
 643
 644   if (!IsInRenderThread()) {
 645     PostRunnable(NewRunnableMethod<wr::WindowId, wr::ColorF>(
 646         "wr::RenderThread::SetClearColor", this, &RenderThread::SetClearColor,
 647         aWindowId, aColor));
 648     return;
 649   }
 650
 651   if (IsDestroyed(aWindowId)) {
 652     return;
 653   }
 654
 655   auto it = mRenderers.find(aWindowId);
 656   MOZ_ASSERT(it != mRenderers.end());
 657   if (it != mRenderers.end()) {
 658     wr_renderer_set_clear_color(it->second->GetRenderer(), aColor);
 659   }
 660 }
 661
 662 void RenderThread::SetProfilerUI(wr::WindowId aWindowId,
 663                                  const nsACString& aUI) {
 664   if (mHasShutdown) {
 665     return;
 666   }
 667
 668   if (!IsInRenderThread()) {
 669     PostRunnable(NewRunnableMethod<wr::WindowId, nsCString>(
 670         "wr::RenderThread::SetProfilerUI", this, &RenderThread::SetProfilerUI,
 671         aWindowId, nsCString(aUI)));
 672     return;
 673   }
 674
 675   auto it = mRenderers.find(aWindowId);
 676   if (it != mRenderers.end()) {
 677     it->second->SetProfilerUI(aUI);
 678   }
 679 }
 680
 681 void RenderThread::PostEvent(wr::WindowId aWindowId,
 682                              UniquePtr<RendererEvent> aEvent) {
 683   PostRunnable(NewRunnableMethod<wr::WindowId, UniquePtr<RendererEvent>&&>(
 684       "wr::RenderThread::PostEvent", this, &RenderThread::RunEvent, aWindowId,
 685       std::move(aEvent)));
 686 }
 687
 688 void RenderThread::RunEvent(wr::WindowId aWindowId,
 689                             UniquePtr<RendererEvent> aEvent) {
 690   MOZ_ASSERT(IsInRenderThread());
 691
 692   aEvent->Run(*this, aWindowId);
 693   aEvent = nullptr;
 694 }
 695
 696 static void NotifyDidRender(layers::CompositorBridgeParent* aBridge,
 697                             const RefPtr<const WebRenderPipelineInfo>& aInfo,
 698                             VsyncId aCompositeStartId,
 699                             TimeStamp aCompositeStart, TimeStamp aRenderStart,
 700                             TimeStamp aEnd, bool aRender,
 701                             RendererStats aStats) {
 702   if (aRender && aBridge->GetWrBridge()) {
 703     // We call this here to mimic the behavior in LayerManagerComposite, as to
 704     // not change what Talos measures. That is, we do not record an empty frame
 705     // as a frame.
 706     aBridge->GetWrBridge()->RecordFrame();
 707   }
 708
 709   aBridge->NotifyDidRender(aCompositeStartId, aCompositeStart, aRenderStart,
 710                            aEnd, &aStats);
 711
 712   for (const auto& epoch : aInfo->Raw().epochs) {
 713     aBridge->NotifyPipelineRendered(epoch.pipeline_id, epoch.epoch,
 714                                     aCompositeStartId, aCompositeStart,
 715                                     aRenderStart, aEnd, &aStats);
 716   }
 717
 718   if (aBridge->GetWrBridge()) {
 719     aBridge->GetWrBridge()->RetrySkippedComposite();
 720   }
 721 }
 722
 723 static void NotifyDidStartRender(layers::CompositorBridgeParent* aBridge) {
 724   if (aBridge->GetWrBridge()) {
 725     aBridge->GetWrBridge()->RetrySkippedComposite();
 726   }
 727 }
 728
 729 void RenderThread::SetFramePublishId(wr::WindowId aWindowId,
 730                                      FramePublishId aPublishId) {
 731   MOZ_ASSERT(IsInRenderThread());
 732
 733   auto it = mRenderers.find(aWindowId);
 734   MOZ_ASSERT(it != mRenderers.end());
 735   if (it == mRenderers.end()) {
 736     return;
 737   }
 738   auto& renderer = it->second;
 739
 740   renderer->SetFramePublishId(aPublishId);
 741 }
 742
 743 void RenderThread::UpdateAndRender(
 744     wr::WindowId aWindowId, const VsyncId& aStartId,
 745     const TimeStamp& aStartTime, bool aRender,
 746     const Maybe<gfx::IntSize>& aReadbackSize,
 747     const Maybe<wr::ImageFormat>& aReadbackFormat,
 748     const Maybe<Range<uint8_t>>& aReadbackBuffer, bool* aNeedsYFlip) {
 749   AUTO_PROFILER_LABEL("RenderThread::UpdateAndRender", GRAPHICS);
 750   MOZ_ASSERT(IsInRenderThread());
 751   MOZ_ASSERT(aRender || aReadbackBuffer.isNothing());
 752
 753   auto it = mRenderers.find(aWindowId);
 754   MOZ_ASSERT(it != mRenderers.end());
 755   if (it == mRenderers.end()) {
 756     return;
 757   }
 758
 759   TimeStamp start = TimeStamp::Now();
 760
 761   auto& renderer = it->second;
 762
 763   std::string markerName = "Composite #" + std::to_string(AsUint64(aWindowId));
 764   AutoProfilerTracing tracingCompositeMarker(
 765       "Paint", markerName.c_str(), geckoprofiler::category::GRAPHICS,
 766       Some(renderer->GetCompositorBridge()->GetInnerWindowId()));
 767
 768   if (renderer->IsPaused()) {
 769     aRender = false;
 770   }
 771   LOG("RenderThread::UpdateAndRender() aWindowId %" PRIx64 " aRender %d",
 772       AsUint64(aWindowId), aRender);
 773
 774   layers::CompositorThread()->Dispatch(
 775       NewRunnableFunction("NotifyDidStartRenderRunnable", &NotifyDidStartRender,
 776                           renderer->GetCompositorBridge()));
 777
 778   wr::RenderedFrameId latestFrameId;
 779   RendererStats stats = {0};
 780   if (aRender) {
 781     latestFrameId = renderer->UpdateAndRender(
 782         aReadbackSize, aReadbackFormat, aReadbackBuffer, aNeedsYFlip, &stats);
 783   } else {
 784     renderer->Update();
 785   }
 786   // Check graphics reset status even when rendering is skipped.
 787   renderer->CheckGraphicsResetStatus("PostUpdate", /* aForce */ false);
 788
 789   TimeStamp end = TimeStamp::Now();
 790   RefPtr<const WebRenderPipelineInfo> info = renderer->GetLastPipelineInfo();
 791
 792   layers::CompositorThread()->Dispatch(
 793       NewRunnableFunction("NotifyDidRenderRunnable", &NotifyDidRender,
 794                           renderer->GetCompositorBridge(), info, aStartId,
 795                           aStartTime, start, end, aRender, stats));
 796
 797   ipc::FileDescriptor fenceFd;
 798
 799   if (latestFrameId.IsValid()) {
 800     fenceFd = renderer->GetAndResetReleaseFence();
 801
 802     // Wait for GPU after posting NotifyDidRender, since the wait is not
 803     // necessary for the NotifyDidRender.
 804     // The wait is necessary for Textures recycling of AsyncImagePipelineManager
 805     // and for avoiding GPU queue is filled with too much tasks.
 806     // WaitForGPU's implementation is different for each platform.
 807     auto timerId = glean::wr::gpu_wait_time.Start();
 808     renderer->WaitForGPU();
 809     glean::wr::gpu_wait_time.StopAndAccumulate(std::move(timerId));
 810   } else {
 811     // Update frame id for NotifyPipelinesUpdated() when rendering does not
 812     // happen, either because rendering was not requested or the frame was
 813     // canceled. Rendering can sometimes be canceled if UpdateAndRender is
 814     // called when the window is not yet ready (not mapped or 0 size).
 815     latestFrameId = renderer->UpdateFrameId();
 816   }
 817
 818   RenderedFrameId lastCompletedFrameId = renderer->GetLastCompletedFrameId();
 819
 820   RefPtr<layers::AsyncImagePipelineManager> pipelineMgr =
 821       renderer->GetCompositorBridge()->GetAsyncImagePipelineManager();
 822   // pipelineMgr should always be non-null here because it is only nulled out
 823   // after the WebRenderAPI instance for the CompositorBridgeParent is
 824   // destroyed, and that destruction blocks until the renderer thread has
 825   // removed the relevant renderer. And after that happens we should never reach
 826   // this code at all; it would bail out at the mRenderers.find check above.
 827   MOZ_ASSERT(pipelineMgr);
 828   pipelineMgr->NotifyPipelinesUpdated(info, latestFrameId, lastCompletedFrameId,
 829                                       std::move(fenceFd));
 830 }
 831
 832 void RenderThread::Pause(wr::WindowId aWindowId) {
 833   MOZ_ASSERT(IsInRenderThread());
 834   LOG("RenderThread::Pause() aWindowId %" PRIx64 "", AsUint64(aWindowId));
 835
 836   auto it = mRenderers.find(aWindowId);
 837   MOZ_ASSERT(it != mRenderers.end());
 838   if (it == mRenderers.end()) {
 839     gfxCriticalNote << "RenderThread cannot find renderer for window "
 840                     << gfx::hexa(aWindowId) << " to pause.";
 841     return;
 842   }
 843   auto& renderer = it->second;
 844   renderer->Pause();
 845
 846   CrashReporter::AnnotateCrashReport(
 847       CrashReporter::Annotation::GraphicsNumActiveRenderers,
 848       (unsigned int)ActiveRendererCount());
 849 }
 850
 851 bool RenderThread::Resume(wr::WindowId aWindowId) {
 852   MOZ_ASSERT(IsInRenderThread());
 853   LOG("enderThread::Resume() aWindowId %" PRIx64 "", AsUint64(aWindowId));
 854
 855   auto it = mRenderers.find(aWindowId);
 856   MOZ_ASSERT(it != mRenderers.end());
 857   if (it == mRenderers.end()) {
 858     gfxCriticalNote << "RenderThread cannot find renderer for window "
 859                     << gfx::hexa(aWindowId) << " to resume.";
 860     return false;
 861   }
 862   auto& renderer = it->second;
 863   bool resumed = renderer->Resume();
 864
 865   CrashReporter::AnnotateCrashReport(
 866       CrashReporter::Annotation::GraphicsNumActiveRenderers,
 867       (unsigned int)ActiveRendererCount());
 868
 869   return resumed;
 870 }
 871
 872 bool RenderThread::TooManyPendingFrames(wr::WindowId aWindowId) {
 873   const int64_t maxFrameCount = 1;
 874
 875   // Too many pending frames if pending frames exit more than maxFrameCount
 876   // or if RenderBackend is still processing a frame.
 877
 878   auto windows = mWindowInfos.Lock();
 879   auto it = windows->find(AsUint64(aWindowId));
 880   if (it == windows->end()) {
 881     MOZ_ASSERT(false);
 882     return true;
 883   }
 884   WindowInfo* info = it->second.get();
 885
 886   if (info->PendingCount() > maxFrameCount) {
 887     return true;
 888   }
 889   // If there is no ongoing frame build, we accept a new frame.
 890   return info->mPendingFrameBuild > 0;
 891 }
 892
 893 bool RenderThread::IsDestroyed(wr::WindowId aWindowId) {
 894   auto windows = mWindowInfos.Lock();
 895   auto it = windows->find(AsUint64(aWindowId));
 896   if (it == windows->end()) {
 897     return true;
 898   }
 899
 900   return it->second->mIsDestroyed;
 901 }
 902
 903 void RenderThread::SetDestroyed(wr::WindowId aWindowId) {
 904   auto windows = mWindowInfos.Lock();
 905   auto it = windows->find(AsUint64(aWindowId));
 906   if (it == windows->end()) {
 907     MOZ_ASSERT(false);
 908     return;
 909   }
 910   it->second->mIsDestroyed = true;
 911 }
 912
 913 void RenderThread::IncPendingFrameCount(wr::WindowId aWindowId,
 914                                         const VsyncId& aStartId,
 915                                         const TimeStamp& aStartTime) {
 916   auto windows = mWindowInfos.Lock();
 917   auto it = windows->find(AsUint64(aWindowId));
 918   if (it == windows->end()) {
 919     MOZ_ASSERT(false);
 920     return;
 921   }
 922   it->second->mPendingFrameBuild++;
 923   it->second->mPendingFrames.push(PendingFrameInfo{aStartTime, aStartId});
 924 }
 925
 926 void RenderThread::DecPendingFrameBuildCount(wr::WindowId aWindowId) {
 927   auto windows = mWindowInfos.Lock();
 928   auto it = windows->find(AsUint64(aWindowId));
 929   if (it == windows->end()) {
 930     MOZ_ASSERT(false);
 931     return;
 932   }
 933   WindowInfo* info = it->second.get();
 934   MOZ_RELEASE_ASSERT(info->mPendingFrameBuild >= 1);
 935   info->mPendingFrameBuild--;
 936 }
 937
 938 void RenderThread::DecPendingFrameCount(wr::WindowId aWindowId) {
 939   auto windows = mWindowInfos.Lock();
 940   auto it = windows->find(AsUint64(aWindowId));
 941   if (it == windows->end()) {
 942     MOZ_ASSERT(false);
 943     return;
 944   }
 945   WindowInfo* info = it->second.get();
 946   info->mPendingFrames.pop();
 947 }
 948
 949 void RenderThread::RegisterExternalImage(
 950     const wr::ExternalImageId& aExternalImageId,
 951     already_AddRefed<RenderTextureHost> aTexture) {
 952   MutexAutoLock lock(mRenderTextureMapLock);
 953
 954   if (mHasShutdown) {
 955     return;
 956   }
 957   MOZ_ASSERT(mRenderTextures.find(aExternalImageId) == mRenderTextures.end());
 958   RefPtr<RenderTextureHost> texture = aTexture;
 959   if (texture->SyncObjectNeeded()) {
 960     mSyncObjectNeededRenderTextures.emplace(aExternalImageId, texture);
 961   }
 962   mRenderTextures.emplace(aExternalImageId, texture);
 963 }
 964
 965 void RenderThread::UnregisterExternalImage(
 966     const wr::ExternalImageId& aExternalImageId) {
 967   MutexAutoLock lock(mRenderTextureMapLock);
 968   if (mHasShutdown) {
 969     return;
 970   }
 971   auto it = mRenderTextures.find(aExternalImageId);
 972   if (it == mRenderTextures.end()) {
 973     return;
 974   }
 975
 976   auto& texture = it->second;
 977   if (texture->SyncObjectNeeded()) {
 978     MOZ_RELEASE_ASSERT(
 979         mSyncObjectNeededRenderTextures.erase(aExternalImageId) == 1);
 980   }
 981
 982   if (!IsInRenderThread()) {
 983     // The RenderTextureHost should be released in render thread. So, post the
 984     // deletion task here.
 985     // The shmem and raw buffer are owned by compositor ipc channel. It's
 986     // possible that RenderTextureHost is still exist after the shmem/raw buffer
 987     // deletion. Then the buffer in RenderTextureHost becomes invalid. It's fine
 988     // for this situation. Gecko will only release the buffer if WR doesn't need
 989     // it. So, no one will access the invalid buffer in RenderTextureHost.
 990     RefPtr<RenderTextureHost> texture = it->second;
 991     mRenderTextures.erase(it);
 992     mRenderTexturesDeferred.emplace_back(std::move(texture));
 993     PostRunnable(NewRunnableMethod(
 994         "RenderThread::DeferredRenderTextureHostDestroy", this,
 995         &RenderThread::DeferredRenderTextureHostDestroy));
 996   } else {
 997     mRenderTextures.erase(it);
 998   }
 999 }
1000
1001 void RenderThread::DestroyExternalImagesSyncWait(
1002     const std::vector<wr::ExternalImageId>&& aIds) {
1003   if (!IsInRenderThread()) {
1004     layers::SynchronousTask task("Destroy external images");
1005
1006     RefPtr<Runnable> runnable = NS_NewRunnableFunction(
1007         "RenderThread::DestroyExternalImagesSyncWait::Runnable",
1008         [&task, ids = std::move(aIds)]() {
1009           layers::AutoCompleteTask complete(&task);
1010           RenderThread::Get()->DestroyExternalImages(std::move(ids));
1011         });
1012
1013     PostRunnable(runnable.forget());
1014     task.Wait();
1015     return;
1016   }
1017   DestroyExternalImages(std::move(aIds));
1018 }
1019
1020 void RenderThread::DestroyExternalImages(
1021     const std::vector<wr::ExternalImageId>&& aIds) {
1022   MOZ_ASSERT(IsInRenderThread());
1023
1024   std::vector<RefPtr<RenderTextureHost>> hosts;
1025   {
1026     MutexAutoLock lock(mRenderTextureMapLock);
1027     if (mHasShutdown) {
1028       return;
1029     }
1030
1031     for (auto& id : aIds) {
1032       auto it = mRenderTextures.find(id);
1033       if (it == mRenderTextures.end()) {
1034         continue;
1035       }
1036       hosts.emplace_back(it->second);
1037     }
1038   }
1039
1040   for (auto& host : hosts) {
1041     host->Destroy();
1042   }
1043 }
1044
1045 void RenderThread::PrepareForUse(const wr::ExternalImageId& aExternalImageId) {
1046   AddRenderTextureOp(RenderTextureOp::PrepareForUse, aExternalImageId);
1047 }
1048
1049 void RenderThread::NotifyNotUsed(const wr::ExternalImageId& aExternalImageId) {
1050   AddRenderTextureOp(RenderTextureOp::NotifyNotUsed, aExternalImageId);
1051 }
1052
1053 void RenderThread::NotifyForUse(const wr::ExternalImageId& aExternalImageId) {
1054   AddRenderTextureOp(RenderTextureOp::NotifyForUse, aExternalImageId);
1055 }
1056
1057 void RenderThread::AddRenderTextureOp(
1058     RenderTextureOp aOp, const wr::ExternalImageId& aExternalImageId) {
1059   MOZ_ASSERT(!IsInRenderThread());
1060
1061   MutexAutoLock lock(mRenderTextureMapLock);
1062
1063   auto it = mRenderTextures.find(aExternalImageId);
1064   MOZ_ASSERT(it != mRenderTextures.end());
1065   if (it == mRenderTextures.end()) {
1066     return;
1067   }
1068
1069   RefPtr<RenderTextureHost> texture = it->second;
1070   mRenderTextureOps.emplace_back(aOp, std::move(texture));
1071
1072   if (mRenderTextureOpsRunnable) {
1073     // Runnable was already triggered
1074     return;
1075   }
1076
1077   RefPtr<nsIRunnable> runnable =
1078       NewRunnableMethod("RenderThread::HandleRenderTextureOps", this,
1079                         &RenderThread::HandleRenderTextureOps);
1080   mRenderTextureOpsRunnable = runnable;
1081   PostRunnable(runnable.forget());
1082 }
1083
1084 void RenderThread::HandleRenderTextureOps() {
1085   MOZ_ASSERT(IsInRenderThread());
1086
1087   std::list<std::pair<RenderTextureOp, RefPtr<RenderTextureHost>>>
1088       renderTextureOps;
1089   {
1090     MutexAutoLock lock(mRenderTextureMapLock);
1091     mRenderTextureOps.swap(renderTextureOps);
1092     mRenderTextureOpsRunnable = nullptr;
1093   }
1094
1095   for (auto& it : renderTextureOps) {
1096     switch (it.first) {
1097       case RenderTextureOp::PrepareForUse:
1098         it.second->PrepareForUse();
1099         break;
1100       case RenderTextureOp::NotifyForUse:
1101         it.second->NotifyForUse();
1102         break;
1103       case RenderTextureOp::NotifyNotUsed:
1104         it.second->NotifyNotUsed();
1105         break;
1106     }
1107   }
1108 }
1109
1110 void RenderThread::UnregisterExternalImageDuringShutdown(
1111     const wr::ExternalImageId& aExternalImageId) {
1112   MOZ_ASSERT(IsInRenderThread());
1113   MutexAutoLock lock(mRenderTextureMapLock);
1114   MOZ_ASSERT(mHasShutdown);
1115   MOZ_ASSERT(mRenderTextures.find(aExternalImageId) != mRenderTextures.end());
1116   mRenderTextures.erase(aExternalImageId);
1117 }
1118
1119 bool RenderThread::SyncObjectNeeded() {
1120   MOZ_ASSERT(IsInRenderThread());
1121   MutexAutoLock lock(mRenderTextureMapLock);
1122   return !mSyncObjectNeededRenderTextures.empty();
1123 }
1124
1125 void RenderThread::DeferredRenderTextureHostDestroy() {
1126   MutexAutoLock lock(mRenderTextureMapLock);
1127   mRenderTexturesDeferred.clear();
1128 }
1129
1130 RenderTextureHost* RenderThread::GetRenderTexture(
1131     const wr::ExternalImageId& aExternalImageId) {
1132   MutexAutoLock lock(mRenderTextureMapLock);
1133   auto it = mRenderTextures.find(aExternalImageId);
1134   MOZ_ASSERT(it != mRenderTextures.end());
1135   if (it == mRenderTextures.end()) {
1136     return nullptr;
1137   }
1138   return it->second;
1139 }
1140
1141 void RenderThread::InitDeviceTask() {
1142   MOZ_ASSERT(IsInRenderThread());
1143   MOZ_ASSERT(!mSingletonGL);
1144   LOG("RenderThread::InitDeviceTask()");
1145
1146   if (gfx::gfxVars::UseSoftwareWebRender()) {
1147     // Ensure we don't instantiate any shared GL context when SW-WR is used.
1148     return;
1149   }
1150
1151   nsAutoCString err;
1152   CreateSingletonGL(err);
1153   if (gfx::gfxVars::UseWebRenderProgramBinaryDisk()) {
1154     mProgramCache = MakeUnique<WebRenderProgramCache>(ThreadPool().Raw());
1155   }
1156   // Query the shared GL context to force the
1157   // lazy initialization to happen now.
1158   SingletonGL();
1159 }
1160
1161 void RenderThread::PostRunnable(already_AddRefed<nsIRunnable> aRunnable) {
1162   nsCOMPtr<nsIRunnable> runnable = aRunnable;
1163   mThread->Dispatch(runnable.forget());
1164 }
1165
1166 #ifndef XP_WIN
1167 static DeviceResetReason GLenumToResetReason(GLenum aReason) {
1168   switch (aReason) {
1169     case LOCAL_GL_NO_ERROR:
1170       return DeviceResetReason::FORCED_RESET;
1171     case LOCAL_GL_INNOCENT_CONTEXT_RESET_ARB:
1172       return DeviceResetReason::DRIVER_ERROR;
1173     case LOCAL_GL_PURGED_CONTEXT_RESET_NV:
1174       return DeviceResetReason::NVIDIA_VIDEO;
1175     case LOCAL_GL_GUILTY_CONTEXT_RESET_ARB:
1176       return DeviceResetReason::RESET;
1177     case LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB:
1178       return DeviceResetReason::UNKNOWN;
1179     case LOCAL_GL_OUT_OF_MEMORY:
1180       return DeviceResetReason::OUT_OF_MEMORY;
1181     default:
1182       return DeviceResetReason::OTHER;
1183   }
1184 }
1185 #endif
1186
1187 void RenderThread::HandleDeviceReset(const char* aWhere, GLenum aReason) {
1188   MOZ_ASSERT(IsInRenderThread());
1189
1190   // This happens only on simulate device reset.
1191   if (aReason == LOCAL_GL_NO_ERROR) {
1192     if (!mHandlingDeviceReset) {
1193       mHandlingDeviceReset = true;
1194
1195       MutexAutoLock lock(mRenderTextureMapLock);
1196       mRenderTexturesDeferred.clear();
1197       for (const auto& entry : mRenderTextures) {
1198         entry.second->ClearCachedResources();
1199       }
1200
1201       // All RenderCompositors will be destroyed by the GPUProcessManager in
1202       // either OnRemoteProcessDeviceReset via the GPUChild, or
1203       // OnInProcessDeviceReset here directly.
1204       if (XRE_IsGPUProcess()) {
1205         gfx::GPUParent::GetSingleton()->NotifyDeviceReset();
1206       } else {
1207         NS_DispatchToMainThread(NS_NewRunnableFunction(
1208             "gfx::GPUProcessManager::OnInProcessDeviceReset", []() -> void {
1209               gfx::GPUProcessManager::Get()->OnInProcessDeviceReset(
1210                   /* aTrackThreshold */ false);
1211             }));
1212       }
1213     }
1214     return;
1215   }
1216
1217   if (mHandlingDeviceReset) {
1218     return;
1219   }
1220
1221   mHandlingDeviceReset = true;
1222
1223 #ifndef XP_WIN
1224   // On Windows, see DeviceManagerDx::MaybeResetAndReacquireDevices.
1225   gfx::GPUProcessManager::RecordDeviceReset(GLenumToResetReason(aReason));
1226 #endif
1227
1228   {
1229     MutexAutoLock lock(mRenderTextureMapLock);
1230     mRenderTexturesDeferred.clear();
1231     for (const auto& entry : mRenderTextures) {
1232       entry.second->ClearCachedResources();
1233     }
1234   }
1235
1236   // All RenderCompositors will be destroyed by the GPUProcessManager in
1237   // either OnRemoteProcessDeviceReset via the GPUChild, or
1238   // OnInProcessDeviceReset here directly.
1239   // On Windows, device will be re-created before sessions re-creation.
1240   gfxCriticalNote << "GFX: RenderThread detected a device reset in " << aWhere;
1241   if (XRE_IsGPUProcess()) {
1242     gfx::GPUParent::GetSingleton()->NotifyDeviceReset();
1243   } else {
1244 #ifndef XP_WIN
1245     // FIXME(aosmond): Do we need to do this on Windows? nsWindow::OnPaint
1246     // seems to do its own detection for the parent process.
1247     bool guilty = aReason == LOCAL_GL_GUILTY_CONTEXT_RESET_ARB;
1248     NS_DispatchToMainThread(NS_NewRunnableFunction(
1249         "gfx::GPUProcessManager::OnInProcessDeviceReset", [guilty]() -> void {
1250           gfx::GPUProcessManager::Get()->OnInProcessDeviceReset(guilty);
1251         }));
1252 #endif
1253   }
1254 }
1255
1256 bool RenderThread::IsHandlingDeviceReset() {
1257   MOZ_ASSERT(IsInRenderThread());
1258   return mHandlingDeviceReset;
1259 }
1260
1261 void RenderThread::SimulateDeviceReset() {
1262   if (!IsInRenderThread()) {
1263     PostRunnable(NewRunnableMethod("RenderThread::SimulateDeviceReset", this,
1264                                    &RenderThread::SimulateDeviceReset));
1265   } else {
1266     // When this function is called GPUProcessManager::SimulateDeviceReset()
1267     // already triggers destroying all CompositorSessions before re-creating
1268     // them.
1269     HandleDeviceReset("SimulateDeviceReset", LOCAL_GL_NO_ERROR);
1270   }
1271 }
1272
1273 static void DoNotifyWebRenderError(WebRenderError aError) {
1274   layers::CompositorManagerParent::NotifyWebRenderError(aError);
1275 }
1276
1277 void RenderThread::NotifyWebRenderError(WebRenderError aError) {
1278   MOZ_ASSERT(IsInRenderThread());
1279
1280   layers::CompositorThread()->Dispatch(NewRunnableFunction(
1281       "DoNotifyWebRenderErrorRunnable", &DoNotifyWebRenderError, aError));
1282 }
1283
1284 void RenderThread::HandleWebRenderError(WebRenderError aError) {
1285   if (mHandlingWebRenderError) {
1286     return;
1287   }
1288
1289   NotifyWebRenderError(aError);
1290
1291   {
1292     MutexAutoLock lock(mRenderTextureMapLock);
1293     mRenderTexturesDeferred.clear();
1294     for (const auto& entry : mRenderTextures) {
1295       entry.second->ClearCachedResources();
1296     }
1297   }
1298   mHandlingWebRenderError = true;
1299   // WebRender is going to be disabled by
1300   // GPUProcessManager::NotifyWebRenderError()
1301 }
1302
1303 bool RenderThread::IsHandlingWebRenderError() {
1304   MOZ_ASSERT(IsInRenderThread());
1305   return mHandlingWebRenderError;
1306 }
1307
1308 gl::GLContext* RenderThread::SingletonGL() {
1309   nsAutoCString err;
1310   auto* gl = SingletonGL(err);
1311   if (!err.IsEmpty()) {
1312     gfxCriticalNote << err.get();
1313   }
1314   return gl;
1315 }
1316
1317 void RenderThread::CreateSingletonGL(nsACString& aError) {
1318   MOZ_ASSERT(IsInRenderThread());
1319   LOG("RenderThread::CreateSingletonGL()");
1320
1321   mSingletonGL = CreateGLContext(aError);
1322   mSingletonGLIsForHardwareWebRender = !gfx::gfxVars::UseSoftwareWebRender();
1323 }
1324
1325 gl::GLContext* RenderThread::SingletonGL(nsACString& aError) {
1326   MOZ_ASSERT(IsInRenderThread());
1327   if (!mSingletonGL) {
1328     CreateSingletonGL(aError);
1329     mShaders = nullptr;
1330   }
1331   if (mSingletonGL && mSingletonGLIsForHardwareWebRender && !mShaders) {
1332     mShaders = MakeUnique<WebRenderShaders>(mSingletonGL, mProgramCache.get());
1333   }
1334
1335   return mSingletonGL.get();
1336 }
1337
1338 gl::GLContext* RenderThread::SingletonGLForCompositorOGL() {
1339   MOZ_RELEASE_ASSERT(gfx::gfxVars::UseSoftwareWebRender());
1340
1341   if (mSingletonGLIsForHardwareWebRender) {
1342     // Clear singleton GL, since GLContext is for hardware WebRender.
1343     ClearSingletonGL();
1344   }
1345   return SingletonGL();
1346 }
1347
1348 void RenderThread::ClearSingletonGL() {
1349   MOZ_ASSERT(IsInRenderThread());
1350   LOG("RenderThread::ClearSingletonGL()");
1351
1352   if (mSurfacePool) {
1353     mSurfacePool->DestroyGLResourcesForContext(mSingletonGL);
1354   }
1355   if (mProgramsForCompositorOGL) {
1356     mProgramsForCompositorOGL->Clear();
1357     mProgramsForCompositorOGL = nullptr;
1358   }
1359   mShaders = nullptr;
1360   mSingletonGL = nullptr;
1361 }
1362
1363 RefPtr<layers::ShaderProgramOGLsHolder>
1364 RenderThread::GetProgramsForCompositorOGL() {
1365   if (!mSingletonGL) {
1366     return nullptr;
1367   }
1368
1369   if (!mProgramsForCompositorOGL) {
1370     mProgramsForCompositorOGL =
1371         MakeAndAddRef<layers::ShaderProgramOGLsHolder>(mSingletonGL);
1372   }
1373   return mProgramsForCompositorOGL;
1374 }
1375
1376 RefPtr<layers::SurfacePool> RenderThread::SharedSurfacePool() {
1377 #if defined(XP_MACOSX) || defined(MOZ_WAYLAND)
1378   if (!mSurfacePool) {
1379     size_t poolSizeLimit =
1380         StaticPrefs::gfx_webrender_compositor_surface_pool_size_AtStartup();
1381     mSurfacePool = layers::SurfacePool::Create(poolSizeLimit);
1382   }
1383 #endif
1384   return mSurfacePool;
1385 }
1386
1387 void RenderThread::ClearSharedSurfacePool() { mSurfacePool = nullptr; }
1388
1389 static void GLAPIENTRY DebugMessageCallback(GLenum aSource, GLenum aType,
1390                                             GLuint aId, GLenum aSeverity,
1391                                             GLsizei aLength,
1392                                             const GLchar* aMessage,
1393                                             const GLvoid* aUserParam) {
1394   constexpr const char* kContextLost = "Context has been lost.";
1395
1396   if (StaticPrefs::gfx_webrender_gl_debug_message_critical_note_AtStartup() &&
1397       aSeverity == LOCAL_GL_DEBUG_SEVERITY_HIGH) {
1398     auto message = std::string(aMessage, aLength);
1399     // When content lost happned, error messages are flooded by its message.
1400     if (message != kContextLost) {
1401       gfxCriticalNote << message;
1402     } else {
1403       gfxCriticalNoteOnce << message;
1404     }
1405   }
1406
1407   if (StaticPrefs::gfx_webrender_gl_debug_message_print_AtStartup()) {
1408     gl::GLContext* gl = (gl::GLContext*)aUserParam;
1409     gl->DebugCallback(aSource, aType, aId, aSeverity, aLength, aMessage);
1410   }
1411 }
1412
1413 // static
1414 void RenderThread::MaybeEnableGLDebugMessage(gl::GLContext* aGLContext) {
1415   if (!aGLContext) {
1416     return;
1417   }
1418
1419   bool enableDebugMessage =
1420       StaticPrefs::gfx_webrender_gl_debug_message_critical_note_AtStartup() ||
1421       StaticPrefs::gfx_webrender_gl_debug_message_print_AtStartup();
1422
1423   if (enableDebugMessage &&
1424       aGLContext->IsExtensionSupported(gl::GLContext::KHR_debug)) {
1425     aGLContext->fEnable(LOCAL_GL_DEBUG_OUTPUT);
1426     aGLContext->fDisable(LOCAL_GL_DEBUG_OUTPUT_SYNCHRONOUS);
1427     aGLContext->fDebugMessageCallback(&DebugMessageCallback, (void*)aGLContext);
1428     aGLContext->fDebugMessageControl(LOCAL_GL_DONT_CARE, LOCAL_GL_DONT_CARE,
1429                                      LOCAL_GL_DONT_CARE, 0, nullptr, true);
1430   }
1431 }
1432
1433 WebRenderShaders::WebRenderShaders(gl::GLContext* gl,
1434                                    WebRenderProgramCache* programCache) {
1435   mGL = gl;
1436   mShaders =
1437       wr_shaders_new(gl, programCache ? programCache->Raw() : nullptr,
1438                      StaticPrefs::gfx_webrender_precache_shaders_AtStartup());
1439 }
1440
1441 WebRenderShaders::~WebRenderShaders() {
1442   wr_shaders_delete(mShaders, mGL.get());
1443 }
1444
1445 WebRenderThreadPool::WebRenderThreadPool(bool low_priority) {
1446   mThreadPool = wr_thread_pool_new(low_priority);
1447 }
1448
1449 WebRenderThreadPool::~WebRenderThreadPool() { Release(); }
1450
1451 void WebRenderThreadPool::Release() {
1452   if (mThreadPool) {
1453     wr_thread_pool_delete(mThreadPool);
1454     mThreadPool = nullptr;
1455   }
1456 }
1457
1458 WebRenderProgramCache::WebRenderProgramCache(wr::WrThreadPool* aThreadPool) {
1459   MOZ_ASSERT(aThreadPool);
1460
1461   nsAutoString path;
1462   if (gfx::gfxVars::UseWebRenderProgramBinaryDisk()) {
1463     path.Append(gfx::gfxVars::ProfDirectory());
1464   }
1465   mProgramCache = wr_program_cache_new(&path, aThreadPool);
1466   if (gfx::gfxVars::UseWebRenderProgramBinaryDisk()) {
1467     wr_try_load_startup_shaders_from_disk(mProgramCache);
1468   }
1469 }
1470
1471 WebRenderProgramCache::~WebRenderProgramCache() {
1472   wr_program_cache_delete(mProgramCache);
1473 }
1474
1475 }  // namespace mozilla::wr
1476
1477 #ifdef XP_WIN
1478 static already_AddRefed<gl::GLContext> CreateGLContextANGLE(
1479     nsACString& aError) {
1480   const RefPtr<ID3D11Device> d3d11Device =
1481       gfx::DeviceManagerDx::Get()->GetCompositorDevice();
1482   if (!d3d11Device) {
1483     aError.Assign("RcANGLE(no compositor device for EGLDisplay)"_ns);
1484     return nullptr;
1485   }
1486
1487   nsCString failureId;
1488   const auto lib = gl::GLLibraryEGL::Get(&failureId);
1489   if (!lib) {
1490     aError.Assign(
1491         nsPrintfCString("RcANGLE(load EGL lib failed: %s)", failureId.get()));
1492     return nullptr;
1493   }
1494
1495   const auto egl = lib->CreateDisplay(d3d11Device.get());
1496   if (!egl) {
1497     aError.Assign(nsPrintfCString("RcANGLE(create EGLDisplay failed: %s)",
1498                                   failureId.get()));
1499     return nullptr;
1500   }
1501
1502   gl::CreateContextFlags flags = gl::CreateContextFlags::PREFER_ES3;
1503
1504   if (StaticPrefs::gfx_webrender_prefer_robustness_AtStartup()) {
1505     flags |= gl::CreateContextFlags::PREFER_ROBUSTNESS;
1506   }
1507
1508   if (egl->IsExtensionSupported(
1509           gl::EGLExtension::MOZ_create_context_provoking_vertex_dont_care)) {
1510     flags |= gl::CreateContextFlags::PROVOKING_VERTEX_DONT_CARE;
1511   }
1512
1513   // Create GLContext with dummy EGLSurface, the EGLSurface is not used.
1514   // Instread we override it with EGLSurface of SwapChain's back buffer.
1515
1516   auto gl = gl::GLContextEGL::CreateWithoutSurface(egl, {flags}, &failureId);
1517   if (!gl || !gl->IsANGLE()) {
1518     aError.Assign(nsPrintfCString("RcANGLE(create GL context failed: %p, %s)",
1519                                   gl.get(), failureId.get()));
1520     return nullptr;
1521   }
1522
1523   if (!gl->MakeCurrent()) {
1524     aError.Assign(
1525         nsPrintfCString("RcANGLE(make current GL context failed: %p, %x)",
1526                         gl.get(), gl->mEgl->mLib->fGetError()));
1527     return nullptr;
1528   }
1529
1530   return gl.forget();
1531 }
1532 #endif
1533
1534 #if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GTK)
1535 static already_AddRefed<gl::GLContext> CreateGLContextEGL() {
1536   // Create GLContext with dummy EGLSurface.
1537   bool forHardwareWebRender = true;
1538   // SW-WR uses CompositorOGL in native compositor.
1539   if (gfx::gfxVars::UseSoftwareWebRender()) {
1540     forHardwareWebRender = false;
1541   }
1542   RefPtr<gl::GLContext> gl =
1543       gl::GLContextProviderEGL::CreateForCompositorWidget(
1544           nullptr, forHardwareWebRender, /* aForceAccelerated */ true);
1545   if (!gl || !gl->MakeCurrent()) {
1546     gfxCriticalNote << "Failed GL context creation for hardware WebRender: "
1547                     << forHardwareWebRender;
1548     return nullptr;
1549   }
1550   return gl.forget();
1551 }
1552 #endif
1553
1554 #ifdef XP_MACOSX
1555 static already_AddRefed<gl::GLContext> CreateGLContextCGL() {
1556   nsCString failureUnused;
1557   return gl::GLContextProvider::CreateHeadless(
1558       {gl::CreateContextFlags::ALLOW_OFFLINE_RENDERER |
1559        gl::CreateContextFlags::FORBID_SOFTWARE},
1560       &failureUnused);
1561 }
1562 #endif
1563
1564 static already_AddRefed<gl::GLContext> CreateGLContext(nsACString& aError) {
1565   RefPtr<gl::GLContext> gl;
1566
1567 #ifdef XP_WIN
1568   if (gfx::gfxVars::UseWebRenderANGLE()) {
1569     gl = CreateGLContextANGLE(aError);
1570   }
1571 #elif defined(MOZ_WIDGET_ANDROID)
1572   gl = CreateGLContextEGL();
1573 #elif defined(MOZ_WIDGET_GTK)
1574   if (gfx::gfxVars::UseEGL()) {
1575     gl = CreateGLContextEGL();
1576   }
1577 #elif XP_MACOSX
1578   gl = CreateGLContextCGL();
1579 #endif
1580
1581   wr::RenderThread::MaybeEnableGLDebugMessage(gl);
1582
1583   return gl.forget();
1584 }
1585
1586 extern "C" {
1587
1588 void wr_notifier_wake_up(mozilla::wr::WrWindowId aWindowId,
1589                          bool aCompositeNeeded) {
1590   // wake_up is used for things like propagating debug options or memory
1591   // pressure events, so we are not tracking pending frame counts.
1592   mozilla::wr::RenderThread::Get()->WrNotifierEvent_WakeUp(aWindowId,
1593                                                            aCompositeNeeded);
1594 }
1595
1596 void wr_notifier_new_frame_ready(mozilla::wr::WrWindowId aWindowId,
1597                                  bool aCompositeNeeded,
1598                                  mozilla::wr::FramePublishId aPublishId) {
1599   auto* renderThread = mozilla::wr::RenderThread::Get();
1600   renderThread->DecPendingFrameBuildCount(aWindowId);
1601
1602   renderThread->WrNotifierEvent_NewFrameReady(aWindowId, aCompositeNeeded,
1603                                               aPublishId);
1604 }
1605
1606 void wr_notifier_external_event(mozilla::wr::WrWindowId aWindowId,
1607                                 size_t aRawEvent) {
1608   mozilla::wr::RenderThread::Get()->WrNotifierEvent_ExternalEvent(
1609       mozilla::wr::WindowId(aWindowId), aRawEvent);
1610 }
1611
1612 static void NotifyScheduleRender(mozilla::wr::WrWindowId aWindowId,
1613                                  wr::RenderReasons aReasons) {
1614   RefPtr<mozilla::layers::CompositorBridgeParent> cbp = mozilla::layers::
1615       CompositorBridgeParent::GetCompositorBridgeParentFromWindowId(aWindowId);
1616   if (cbp) {
1617     cbp->ScheduleComposition(aReasons);
1618   }
1619 }
1620
1621 void wr_schedule_render(mozilla::wr::WrWindowId aWindowId,
1622                         wr::RenderReasons aReasons) {
1623   layers::CompositorThread()->Dispatch(NewRunnableFunction(
1624       "NotifyScheduleRender", &NotifyScheduleRender, aWindowId, aReasons));
1625 }
1626
1627 static void NotifyDidSceneBuild(
1628     mozilla::wr::WrWindowId aWindowId,
1629     const RefPtr<const wr::WebRenderPipelineInfo>& aInfo) {
1630   RefPtr<mozilla::layers::CompositorBridgeParent> cbp = mozilla::layers::
1631       CompositorBridgeParent::GetCompositorBridgeParentFromWindowId(aWindowId);
1632   if (cbp) {
1633     cbp->NotifyDidSceneBuild(aInfo);
1634   }
1635 }
1636
1637 void wr_finished_scene_build(mozilla::wr::WrWindowId aWindowId,
1638                              mozilla::wr::WrPipelineInfo* aPipelineInfo) {
1639   RefPtr<wr::WebRenderPipelineInfo> info = new wr::WebRenderPipelineInfo();
1640   info->Raw() = std::move(*aPipelineInfo);
1641   layers::CompositorThread()->Dispatch(NewRunnableFunction(
1642       "NotifyDidSceneBuild", &NotifyDidSceneBuild, aWindowId, info));
1643 }
1644
1645 }  // extern C