gfx/layers/RemoteTextureMap.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 "mozilla/layers/RemoteTextureMap.h"
   8
   9 #include <algorithm>
  10 #include <vector>
  11
  12 #include "CompositableHost.h"
  13 #include "mozilla/ipc/ProtocolUtils.h"
  14 #include "mozilla/gfx/gfxVars.h"
  15 #include "mozilla/layers/AsyncImagePipelineManager.h"
  16 #include "mozilla/layers/BufferTexture.h"
  17 #include "mozilla/layers/CompositorThread.h"
  18 #include "mozilla/layers/ImageDataSerializer.h"
  19 #include "mozilla/layers/RemoteTextureHostWrapper.h"
  20 #include "mozilla/layers/TextureClientSharedSurface.h"
  21 #include "mozilla/layers/WebRenderTextureHost.h"
  22 #include "mozilla/StaticPrefs_gfx.h"
  23 #include "mozilla/StaticPrefs_webgl.h"
  24 #include "mozilla/webgpu/ExternalTexture.h"
  25 #include "mozilla/webrender/RenderThread.h"
  26 #include "SharedSurface.h"
  27
  28 namespace mozilla::layers {
  29
  30 RemoteTextureRecycleBin::RemoteTextureRecycleBin(bool aIsShared)
  31     : mIsShared(aIsShared) {}
  32
  33 RemoteTextureRecycleBin::~RemoteTextureRecycleBin() = default;
  34
  35 RemoteTextureOwnerClient::RemoteTextureOwnerClient(
  36     const base::ProcessId aForPid)
  37     : mForPid(aForPid) {}
  38
  39 RemoteTextureOwnerClient::~RemoteTextureOwnerClient() = default;
  40
  41 bool RemoteTextureOwnerClient::IsRegistered(
  42     const RemoteTextureOwnerId aOwnerId) {
  43   auto it = mOwnerIds.find(aOwnerId);
  44   if (it == mOwnerIds.end()) {
  45     return false;
  46   }
  47   return true;
  48 }
  49
  50 void RemoteTextureOwnerClient::RegisterTextureOwner(
  51     const RemoteTextureOwnerId aOwnerId, bool aSharedRecycling) {
  52   MOZ_ASSERT(mOwnerIds.find(aOwnerId) == mOwnerIds.end());
  53   mOwnerIds.emplace(aOwnerId);
  54   RefPtr<RemoteTextureRecycleBin> recycleBin;
  55   if (aSharedRecycling) {
  56     if (!mSharedRecycleBin) {
  57       mSharedRecycleBin = new RemoteTextureRecycleBin(true);
  58     }
  59     recycleBin = mSharedRecycleBin;
  60   }
  61   RemoteTextureMap::Get()->RegisterTextureOwner(aOwnerId, mForPid, recycleBin);
  62 }
  63
  64 void RemoteTextureOwnerClient::UnregisterTextureOwner(
  65     const RemoteTextureOwnerId aOwnerId) {
  66   auto it = mOwnerIds.find(aOwnerId);
  67   if (it == mOwnerIds.end()) {
  68     return;
  69   }
  70   mOwnerIds.erase(it);
  71   RemoteTextureMap::Get()->UnregisterTextureOwner(aOwnerId, mForPid);
  72 }
  73
  74 void RemoteTextureOwnerClient::UnregisterAllTextureOwners() {
  75   if (mOwnerIds.empty()) {
  76     return;
  77   }
  78   RemoteTextureMap::Get()->UnregisterTextureOwners(mOwnerIds, mForPid);
  79   mOwnerIds.clear();
  80   mSharedRecycleBin = nullptr;
  81 }
  82
  83 bool RemoteTextureOwnerClient::WaitForTxn(const RemoteTextureOwnerId aOwnerId,
  84                                           RemoteTextureTxnType aTxnType,
  85                                           RemoteTextureTxnId aTxnId) {
  86   auto it = mOwnerIds.find(aOwnerId);
  87   if (it == mOwnerIds.end() || !aTxnType || !aTxnId) {
  88     return false;
  89   }
  90   return RemoteTextureMap::Get()->WaitForTxn(aOwnerId, mForPid, aTxnType,
  91                                              aTxnId);
  92 }
  93
  94 void RemoteTextureOwnerClient::ClearRecycledTextures() {
  95   RemoteTextureMap::Get()->ClearRecycledTextures(mOwnerIds, mForPid,
  96                                                  mSharedRecycleBin);
  97 }
  98
  99 void RemoteTextureOwnerClient::NotifyContextLost(
 100     const RemoteTextureOwnerIdSet* aOwnerIds) {
 101   if (aOwnerIds) {
 102     for (const auto& id : *aOwnerIds) {
 103       if (mOwnerIds.find(id) == mOwnerIds.end()) {
 104         MOZ_ASSERT_UNREACHABLE("owner id not registered by client");
 105         return;
 106       }
 107     }
 108   } else {
 109     aOwnerIds = &mOwnerIds;
 110   }
 111   if (aOwnerIds->empty()) {
 112     return;
 113   }
 114   RemoteTextureMap::Get()->NotifyContextLost(*aOwnerIds, mForPid);
 115 }
 116
 117 void RemoteTextureOwnerClient::NotifyContextRestored(
 118     const RemoteTextureOwnerIdSet* aOwnerIds) {
 119   if (aOwnerIds) {
 120     for (const auto& id : *aOwnerIds) {
 121       if (mOwnerIds.find(id) == mOwnerIds.end()) {
 122         MOZ_ASSERT_UNREACHABLE("owner id not registered by client");
 123         return;
 124       }
 125     }
 126   } else {
 127     aOwnerIds = &mOwnerIds;
 128   }
 129   if (aOwnerIds->empty()) {
 130     return;
 131   }
 132   RemoteTextureMap::Get()->NotifyContextRestored(*aOwnerIds, mForPid);
 133 }
 134
 135 void RemoteTextureOwnerClient::PushTexture(
 136     const RemoteTextureId aTextureId, const RemoteTextureOwnerId aOwnerId,
 137     UniquePtr<TextureData>&& aTextureData) {
 138   MOZ_ASSERT(IsRegistered(aOwnerId));
 139
 140   RefPtr<TextureHost> textureHost = RemoteTextureMap::CreateRemoteTexture(
 141       aTextureData.get(), TextureFlags::DEFAULT);
 142   if (!textureHost) {
 143     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 144     return;
 145   }
 146
 147   RemoteTextureMap::Get()->PushTexture(aTextureId, aOwnerId, mForPid,
 148                                        std::move(aTextureData), textureHost,
 149                                        /* aResourceWrapper */ nullptr);
 150 }
 151
 152 void RemoteTextureOwnerClient::PushTexture(
 153     const RemoteTextureId aTextureId, const RemoteTextureOwnerId aOwnerId,
 154     const std::shared_ptr<gl::SharedSurface>& aSharedSurface,
 155     const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat,
 156     const SurfaceDescriptor& aDesc) {
 157   MOZ_ASSERT(IsRegistered(aOwnerId));
 158
 159   UniquePtr<TextureData> textureData =
 160       MakeUnique<SharedSurfaceTextureData>(aDesc, aFormat, aSize);
 161   RefPtr<TextureHost> textureHost = RemoteTextureMap::CreateRemoteTexture(
 162       textureData.get(), TextureFlags::DEFAULT);
 163   if (!textureHost) {
 164     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 165     return;
 166   }
 167
 168   RemoteTextureMap::Get()->PushTexture(
 169       aTextureId, aOwnerId, mForPid, std::move(textureData), textureHost,
 170       SharedResourceWrapper::SharedSurface(aSharedSurface));
 171 }
 172
 173 void RemoteTextureOwnerClient::PushTexture(
 174     const RemoteTextureId aTextureId, const RemoteTextureOwnerId aOwnerId,
 175     const std::shared_ptr<webgpu::ExternalTexture>& aExternalTexture,
 176     const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat,
 177     const SurfaceDescriptor& aDesc) {
 178   MOZ_ASSERT(IsRegistered(aOwnerId));
 179
 180   UniquePtr<TextureData> textureData =
 181       MakeUnique<SharedSurfaceTextureData>(aDesc, aFormat, aSize);
 182   RefPtr<TextureHost> textureHost = RemoteTextureMap::CreateRemoteTexture(
 183       textureData.get(), TextureFlags::DEFAULT);
 184   if (!textureHost) {
 185     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 186     return;
 187   }
 188
 189   RemoteTextureMap::Get()->PushTexture(
 190       aTextureId, aOwnerId, mForPid, std::move(textureData), textureHost,
 191       SharedResourceWrapper::ExternalTexture(aExternalTexture));
 192 }
 193
 194 void RemoteTextureOwnerClient::PushDummyTexture(
 195     const RemoteTextureId aTextureId, const RemoteTextureOwnerId aOwnerId) {
 196   MOZ_ASSERT(IsRegistered(aOwnerId));
 197
 198   auto flags = TextureFlags::DEALLOCATE_CLIENT | TextureFlags::REMOTE_TEXTURE |
 199                TextureFlags::DUMMY_TEXTURE;
 200   auto* rawData = BufferTextureData::Create(
 201       gfx::IntSize(1, 1), gfx::SurfaceFormat::B8G8R8A8, gfx::BackendType::SKIA,
 202       LayersBackend::LAYERS_WR, flags, ALLOC_DEFAULT, nullptr);
 203   if (!rawData) {
 204     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 205     return;
 206   }
 207
 208   auto textureData = UniquePtr<TextureData>(rawData);
 209
 210   RefPtr<TextureHost> textureHost = RemoteTextureMap::CreateRemoteTexture(
 211       textureData.get(), TextureFlags::DUMMY_TEXTURE);
 212   if (!textureHost) {
 213     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 214     return;
 215   }
 216
 217   RemoteTextureMap::Get()->PushTexture(aTextureId, aOwnerId, mForPid,
 218                                        std::move(textureData), textureHost,
 219                                        /* aResourceWrapper */ nullptr);
 220 }
 221
 222 void RemoteTextureOwnerClient::GetLatestBufferSnapshot(
 223     const RemoteTextureOwnerId aOwnerId, const mozilla::ipc::Shmem& aDestShmem,
 224     const gfx::IntSize& aSize) {
 225   MOZ_ASSERT(IsRegistered(aOwnerId));
 226   RemoteTextureMap::Get()->GetLatestBufferSnapshot(aOwnerId, mForPid,
 227                                                    aDestShmem, aSize);
 228 }
 229
 230 UniquePtr<TextureData> RemoteTextureOwnerClient::GetRecycledTextureData(
 231     const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat,
 232     TextureType aTextureType, RemoteTextureOwnerId aOwnerId) {
 233   return RemoteTextureMap::Get()->GetRecycledTextureData(
 234       aOwnerId, mForPid, mSharedRecycleBin, aSize, aFormat, aTextureType);
 235 }
 236
 237 UniquePtr<TextureData>
 238 RemoteTextureOwnerClient::CreateOrRecycleBufferTextureData(
 239     const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat,
 240     RemoteTextureOwnerId aOwnerId) {
 241   auto texture =
 242       GetRecycledTextureData(aSize, aFormat, TextureType::Unknown, aOwnerId);
 243   if (texture) {
 244     return texture;
 245   }
 246
 247   auto flags = TextureFlags::DEALLOCATE_CLIENT | TextureFlags::REMOTE_TEXTURE;
 248   auto* data = BufferTextureData::Create(aSize, aFormat, gfx::BackendType::SKIA,
 249                                          LayersBackend::LAYERS_WR, flags,
 250                                          ALLOC_DEFAULT, nullptr);
 251   return UniquePtr<TextureData>(data);
 252 }
 253
 254 std::shared_ptr<gl::SharedSurface>
 255 RemoteTextureOwnerClient::GetRecycledSharedSurface(
 256     const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat,
 257     SurfaceDescriptor::Type aType, RemoteTextureOwnerId aOwnerId) {
 258   UniquePtr<SharedResourceWrapper> wrapper =
 259       RemoteTextureMap::Get()->RemoteTextureMap::GetRecycledSharedTexture(
 260           aOwnerId, mForPid, mSharedRecycleBin, aSize, aFormat, aType);
 261   if (!wrapper) {
 262     return nullptr;
 263   }
 264   MOZ_ASSERT(wrapper->mSharedSurface);
 265   return wrapper->mSharedSurface;
 266 }
 267
 268 std::shared_ptr<webgpu::ExternalTexture>
 269 RemoteTextureOwnerClient::GetRecycledExternalTexture(
 270     const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat,
 271     SurfaceDescriptor::Type aType, RemoteTextureOwnerId aOwnerId) {
 272   UniquePtr<SharedResourceWrapper> wrapper =
 273       RemoteTextureMap::Get()->RemoteTextureMap::GetRecycledSharedTexture(
 274           aOwnerId, mForPid, mSharedRecycleBin, aSize, aFormat, aType);
 275   if (!wrapper) {
 276     return nullptr;
 277   }
 278   MOZ_ASSERT(wrapper->mExternalTexture);
 279   return wrapper->mExternalTexture;
 280 }
 281
 282 StaticAutoPtr<RemoteTextureMap> RemoteTextureMap::sInstance;
 283
 284 /* static */
 285 void RemoteTextureMap::Init() {
 286   MOZ_ASSERT(!sInstance);
 287   sInstance = new RemoteTextureMap();
 288 }
 289
 290 /* static */
 291 void RemoteTextureMap::Shutdown() {
 292   if (sInstance) {
 293     sInstance = nullptr;
 294   }
 295 }
 296
 297 RemoteTextureMap::RemoteTextureMap() : mMonitor("RemoteTextureMap::mMonitor") {}
 298
 299 RemoteTextureMap::~RemoteTextureMap() = default;
 300
 301 bool RemoteTextureMap::RecycleTexture(
 302     const RefPtr<RemoteTextureRecycleBin>& aRecycleBin,
 303     TextureDataHolder& aHolder, bool aExpireOldTextures) {
 304   if (!aHolder.mTextureData ||
 305       (aHolder.mTextureHost &&
 306        aHolder.mTextureHost->GetFlags() & TextureFlags::DUMMY_TEXTURE)) {
 307     return false;
 308   }
 309
 310   // Expire old textures so they don't sit in the list forever if unused.
 311   constexpr size_t kSharedTextureLimit = 21;
 312   constexpr size_t kTextureLimit = 7;
 313   while (aRecycleBin->mRecycledTextures.size() >=
 314          (aRecycleBin->mIsShared ? kSharedTextureLimit : kTextureLimit)) {
 315     if (!aExpireOldTextures) {
 316       // There are too many textures, and we can't expire any to make room.
 317       return false;
 318     }
 319     aRecycleBin->mRecycledTextures.pop_front();
 320   }
 321
 322   TextureData::Info info;
 323   aHolder.mTextureData->FillInfo(info);
 324   RemoteTextureRecycleBin::RecycledTextureHolder recycled{info.size,
 325                                                           info.format};
 326   if (aHolder.mResourceWrapper) {
 327     // Don't attempt to recycle non-recyclable shared surfaces
 328     if (aHolder.mResourceWrapper->mSharedSurface &&
 329         !aHolder.mResourceWrapper->mSharedSurface->mDesc.canRecycle) {
 330       return false;
 331     }
 332
 333     // Recycle shared texture
 334     SurfaceDescriptor desc;
 335     if (!aHolder.mTextureData->Serialize(desc)) {
 336       return false;
 337     }
 338     recycled.mType = desc.type();
 339     recycled.mResourceWrapper = std::move(aHolder.mResourceWrapper);
 340   } else {
 341     // Recycle texture data
 342     recycled.mTextureData = std::move(aHolder.mTextureData);
 343   }
 344   if (!StaticPrefs::gfx_remote_texture_recycle_disabled()) {
 345     aRecycleBin->mRecycledTextures.push_back(std::move(recycled));
 346   }
 347
 348   return true;
 349 }
 350
 351 void RemoteTextureMap::PushTexture(
 352     const RemoteTextureId aTextureId, const RemoteTextureOwnerId aOwnerId,
 353     const base::ProcessId aForPid, UniquePtr<TextureData>&& aTextureData,
 354     RefPtr<TextureHost>& aTextureHost,
 355     UniquePtr<SharedResourceWrapper>&& aResourceWrapper) {
 356   MOZ_RELEASE_ASSERT(aTextureHost);
 357
 358   std::vector<RefPtr<TextureHost>>
 359       releasingTextures;  // Release outside the monitor
 360   std::vector<std::function<void(const RemoteTextureInfo&)>>
 361       renderingReadyCallbacks;  // Call outside the monitor
 362   {
 363     MonitorAutoLock lock(mMonitor);
 364
 365     auto* owner = GetTextureOwner(lock, aOwnerId, aForPid);
 366     if (!owner) {
 367       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 368       return;
 369     }
 370
 371     if (owner->mIsContextLost &&
 372         !(aTextureHost->GetFlags() & TextureFlags::DUMMY_TEXTURE)) {
 373       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 374       gfxCriticalNoteOnce << "Texture pushed during context lost";
 375     }
 376
 377     auto textureData = MakeUnique<TextureDataHolder>(
 378         aTextureId, aTextureHost, std::move(aTextureData),
 379         std::move(aResourceWrapper));
 380
 381     MOZ_ASSERT(owner->mLatestPushedTextureId < aTextureId);
 382     if (owner->mLatestPushedTextureId < aTextureId) {
 383       owner->mLatestPushedTextureId = aTextureId;
 384     }
 385     MOZ_ASSERT(owner->mLatestUsingTextureId < aTextureId);
 386
 387     owner->mWaitingTextureDataHolders.push_back(std::move(textureData));
 388
 389     {
 390       GetRenderingReadyCallbacks(lock, owner, aTextureId,
 391                                  renderingReadyCallbacks);
 392       // Update mRemoteTextureHost.
 393       // This happens when PushTexture() with RemoteTextureId is called after
 394       // GetRemoteTexture() with the RemoteTextureId.
 395       const auto key = std::pair(aForPid, aTextureId);
 396       auto it = mRemoteTextureHostWrapperHolders.find(key);
 397       if (it != mRemoteTextureHostWrapperHolders.end()) {
 398         MOZ_ASSERT(!it->second->mRemoteTextureHost);
 399         it->second->mRemoteTextureHost = aTextureHost;
 400       }
 401     }
 402
 403     mMonitor.Notify();
 404
 405     // Release owner->mReleasingRenderedTextureHosts before checking
 406     // NumCompositableRefs()
 407     if (!owner->mReleasingRenderedTextureHosts.empty()) {
 408       std::transform(
 409           owner->mReleasingRenderedTextureHosts.begin(),
 410           owner->mReleasingRenderedTextureHosts.end(),
 411           std::back_inserter(releasingTextures),
 412           [](CompositableTextureHostRef& aRef) { return aRef.get(); });
 413       owner->mReleasingRenderedTextureHosts.clear();
 414     }
 415
 416     // Drop obsoleted remote textures.
 417     while (!owner->mUsingTextureDataHolders.empty()) {
 418       auto& front = owner->mUsingTextureDataHolders.front();
 419       // If mLatestRenderedTextureHost is last compositable ref of remote
 420       // texture's TextureHost, its RemoteTextureHostWrapper is already
 421       // unregistered. It happens when pushed remote textures that follow are
 422       // not rendered since last mLatestRenderedTextureHost update. In this
 423       // case, remove the TextureHost from mUsingTextureDataHolders. It is for
 424       // unblocking remote texture recyclieng.
 425       if (front->mTextureHost &&
 426           front->mTextureHost->NumCompositableRefs() == 1 &&
 427           front->mTextureHost == owner->mLatestRenderedTextureHost) {
 428         owner->mUsingTextureDataHolders.pop_front();
 429         continue;
 430       }
 431       // When compositable ref of TextureHost becomes 0, the TextureHost is not
 432       // used by WebRender anymore.
 433       if (front->mTextureHost &&
 434           front->mTextureHost->NumCompositableRefs() == 0) {
 435         owner->mReleasingTextureDataHolders.push_back(std::move(front));
 436         owner->mUsingTextureDataHolders.pop_front();
 437       } else if (front->mTextureHost &&
 438                  front->mTextureHost->NumCompositableRefs() >= 0) {
 439         // Remote texture is still in use by WebRender.
 440         break;
 441       } else {
 442         MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 443         owner->mUsingTextureDataHolders.pop_front();
 444       }
 445     }
 446     while (!owner->mReleasingTextureDataHolders.empty()) {
 447       RecycleTexture(owner->mRecycleBin,
 448                      *owner->mReleasingTextureDataHolders.front(), true);
 449       owner->mReleasingTextureDataHolders.pop_front();
 450     }
 451   }
 452
 453   const auto info = RemoteTextureInfo(aTextureId, aOwnerId, aForPid);
 454   for (auto& callback : renderingReadyCallbacks) {
 455     callback(info);
 456   }
 457 }
 458
 459 bool RemoteTextureMap::RemoveTexture(const RemoteTextureId aTextureId,
 460                                      const RemoteTextureOwnerId aOwnerId,
 461                                      const base::ProcessId aForPid) {
 462   MonitorAutoLock lock(mMonitor);
 463
 464   auto* owner = GetTextureOwner(lock, aOwnerId, aForPid);
 465   if (!owner) {
 466     return false;
 467   }
 468
 469   for (auto it = owner->mWaitingTextureDataHolders.begin();
 470        it != owner->mWaitingTextureDataHolders.end(); it++) {
 471     auto& data = *it;
 472     if (data->mTextureId == aTextureId) {
 473       if (mRemoteTextureHostWrapperHolders.find(std::pair(
 474               aForPid, aTextureId)) != mRemoteTextureHostWrapperHolders.end()) {
 475         return false;
 476       }
 477       if (!RecycleTexture(owner->mRecycleBin, *data, false)) {
 478         owner->mReleasingTextureDataHolders.push_back(std::move(data));
 479       }
 480       owner->mWaitingTextureDataHolders.erase(it);
 481       return true;
 482     }
 483   }
 484
 485   return false;
 486 }
 487
 488 void RemoteTextureMap::GetLatestBufferSnapshot(
 489     const RemoteTextureOwnerId aOwnerId, const base::ProcessId aForPid,
 490     const mozilla::ipc::Shmem& aDestShmem, const gfx::IntSize& aSize) {
 491   // The compositable ref of remote texture should be updated in mMonitor lock.
 492   CompositableTextureHostRef textureHostRef;
 493   RefPtr<TextureHost> releasingTexture;  // Release outside the monitor
 494   std::shared_ptr<webgpu::ExternalTexture> externalTexture;
 495   {
 496     MonitorAutoLock lock(mMonitor);
 497
 498     auto* owner = GetTextureOwner(lock, aOwnerId, aForPid);
 499     if (!owner) {
 500       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 501       return;
 502     }
 503
 504     // Get latest TextureHost of remote Texture.
 505     if (owner->mWaitingTextureDataHolders.empty() &&
 506         owner->mUsingTextureDataHolders.empty()) {
 507       return;
 508     }
 509     const auto* holder = !owner->mWaitingTextureDataHolders.empty()
 510                              ? owner->mWaitingTextureDataHolders.back().get()
 511                              : owner->mUsingTextureDataHolders.back().get();
 512     TextureHost* textureHost = holder->mTextureHost;
 513
 514     if (textureHost->GetSize() != aSize) {
 515       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 516       return;
 517     }
 518     if (textureHost->GetFormat() != gfx::SurfaceFormat::R8G8B8A8 &&
 519         textureHost->GetFormat() != gfx::SurfaceFormat::B8G8R8A8) {
 520       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 521       return;
 522     }
 523     if (holder->mResourceWrapper &&
 524         holder->mResourceWrapper->mExternalTexture) {
 525       // Increment compositable ref to prevent that TextureDataHolder is removed
 526       // during memcpy.
 527       textureHostRef = textureHost;
 528       externalTexture = holder->mResourceWrapper->mExternalTexture;
 529     } else if (textureHost->AsBufferTextureHost()) {
 530       // Increment compositable ref to prevent that TextureDataHolder is removed
 531       // during memcpy.
 532       textureHostRef = textureHost;
 533     } else {
 534       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 535       return;
 536     }
 537   }
 538
 539   if (!textureHostRef) {
 540     return;
 541   }
 542
 543   if (externalTexture) {
 544     externalTexture->GetSnapshot(aDestShmem, aSize);
 545   } else if (auto* bufferTextureHost = textureHostRef->AsBufferTextureHost()) {
 546     uint32_t stride = ImageDataSerializer::ComputeRGBStride(
 547         bufferTextureHost->GetFormat(), aSize.width);
 548     uint32_t bufferSize = stride * aSize.height;
 549     uint8_t* dst = aDestShmem.get<uint8_t>();
 550     uint8_t* src = bufferTextureHost->GetBuffer();
 551
 552     MOZ_ASSERT(bufferSize <= aDestShmem.Size<uint8_t>());
 553     memcpy(dst, src, bufferSize);
 554   }
 555
 556   {
 557     MonitorAutoLock lock(mMonitor);
 558     // Release compositable ref in mMonitor lock, but release RefPtr outside the
 559     // monitor
 560     releasingTexture = textureHostRef;
 561     textureHostRef = nullptr;
 562   }
 563 }
 564
 565 void RemoteTextureMap::RegisterTextureOwner(
 566     const RemoteTextureOwnerId aOwnerId, const base::ProcessId aForPid,
 567     const RefPtr<RemoteTextureRecycleBin>& aRecycleBin) {
 568   MonitorAutoLock lock(mMonitor);
 569
 570   const auto key = std::pair(aForPid, aOwnerId);
 571   auto it = mTextureOwners.find(key);
 572   if (it != mTextureOwners.end()) {
 573     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 574     return;
 575   }
 576   auto owner = MakeUnique<TextureOwner>();
 577   if (aRecycleBin) {
 578     owner->mRecycleBin = aRecycleBin;
 579   } else {
 580     owner->mRecycleBin = new RemoteTextureRecycleBin(false);
 581   }
 582
 583   auto itWaiting = mWaitingTextureOwners.find(key);
 584   if (itWaiting != mWaitingTextureOwners.end()) {
 585     owner->mRenderingReadyCallbackHolders.swap(
 586         itWaiting->second->mRenderingReadyCallbackHolders);
 587     mWaitingTextureOwners.erase(itWaiting);
 588   }
 589
 590   mTextureOwners.emplace(key, std::move(owner));
 591 }
 592
 593 void RemoteTextureMap::KeepTextureDataAliveForTextureHostIfNecessary(
 594     const MonitorAutoLock& aProofOfLock, RemoteTextureMap::TextureOwner* aOwner,
 595     std::deque<UniquePtr<TextureDataHolder>>& aHolders) {
 596   for (auto& holder : aHolders) {
 597     // If remote texture of TextureHost still exist, keep
 598     // SharedResourceWrapper/TextureData alive while the TextureHost is alive.
 599     if (holder->mTextureHost &&
 600         holder->mTextureHost->NumCompositableRefs() > 0) {
 601       RefPtr<nsISerialEventTarget> eventTarget = GetCurrentSerialEventTarget();
 602       RefPtr<Runnable> runnable = NS_NewRunnableFunction(
 603           "RemoteTextureMap::UnregisterTextureOwner::Runnable",
 604           [data = std::move(holder->mTextureData),
 605            wrapper = std::move(holder->mResourceWrapper)]() {});
 606
 607       auto destroyedCallback = [eventTarget = std::move(eventTarget),
 608                                 runnable = std::move(runnable)]() mutable {
 609         eventTarget->Dispatch(runnable.forget());
 610       };
 611
 612       holder->mTextureHost->SetDestroyedCallback(destroyedCallback);
 613     } else {
 614       RecycleTexture(aOwner->mRecycleBin, *holder, true);
 615     }
 616   }
 617 }
 618
 619 UniquePtr<RemoteTextureMap::TextureOwner>
 620 RemoteTextureMap::UnregisterTextureOwner(
 621     MonitorAutoLock& aProofOfLock, const RemoteTextureOwnerId aOwnerId,
 622     const base::ProcessId aForPid,
 623     std::vector<RefPtr<TextureHost>>& aReleasingTextures,
 624     std::vector<std::function<void(const RemoteTextureInfo&)>>&
 625         aRenderingReadyCallbacks) {
 626   const auto key = std::pair(aForPid, aOwnerId);
 627   auto it = mTextureOwners.find(key);
 628   if (it == mTextureOwners.end()) {
 629     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 630     return nullptr;
 631   }
 632
 633   auto* owner = it->second.get();
 634   // If waiting for a last use, and it hasn't arrived yet, then defer
 635   // unregistering.
 636   if (owner->mWaitForTxn) {
 637     owner->mDeferUnregister = GetCurrentSerialEventTarget();
 638     // If another thread is waiting on this owner to produce textures,
 639     // it must be notified that owner is going away.
 640     if (!owner->mLatestTextureHost &&
 641         owner->mWaitingTextureDataHolders.empty()) {
 642       aProofOfLock.Notify();
 643     }
 644     return nullptr;
 645   }
 646
 647   if (owner->mLatestTextureHost) {
 648     // Release CompositableRef in mMonitor
 649     aReleasingTextures.emplace_back(owner->mLatestTextureHost);
 650     owner->mLatestTextureHost = nullptr;
 651   }
 652
 653   // mReleasingRenderedTextureHosts and mLatestRenderedTextureHost could
 654   // simply be cleared. Since NumCompositableRefs() > 0 keeps TextureHosts in
 655   // mUsingTextureDataHolders alive. They need to be cleared before
 656   // KeepTextureDataAliveForTextureHostIfNecessary() call. The function uses
 657   // NumCompositableRefs().
 658   if (!owner->mReleasingRenderedTextureHosts.empty()) {
 659     std::transform(owner->mReleasingRenderedTextureHosts.begin(),
 660                    owner->mReleasingRenderedTextureHosts.end(),
 661                    std::back_inserter(aReleasingTextures),
 662                    [](CompositableTextureHostRef& aRef) { return aRef.get(); });
 663     owner->mReleasingRenderedTextureHosts.clear();
 664   }
 665   if (owner->mLatestRenderedTextureHost) {
 666     owner->mLatestRenderedTextureHost = nullptr;
 667   }
 668
 669   GetAllRenderingReadyCallbacks(aProofOfLock, owner, aRenderingReadyCallbacks);
 670
 671   KeepTextureDataAliveForTextureHostIfNecessary(
 672       aProofOfLock, owner, owner->mWaitingTextureDataHolders);
 673
 674   KeepTextureDataAliveForTextureHostIfNecessary(
 675       aProofOfLock, owner, owner->mUsingTextureDataHolders);
 676
 677   KeepTextureDataAliveForTextureHostIfNecessary(
 678       aProofOfLock, owner, owner->mReleasingTextureDataHolders);
 679
 680   UniquePtr<TextureOwner> releasingOwner = std::move(it->second);
 681   mTextureOwners.erase(it);
 682   return releasingOwner;
 683 }
 684
 685 void RemoteTextureMap::UnregisterTextureOwner(
 686     const RemoteTextureOwnerId aOwnerId, const base::ProcessId aForPid) {
 687   UniquePtr<TextureOwner> releasingOwner;  // Release outside the monitor
 688   std::vector<RefPtr<TextureHost>>
 689       releasingTextures;  // Release outside the monitor
 690   std::vector<std::function<void(const RemoteTextureInfo&)>>
 691       renderingReadyCallbacks;  // Call outside the monitor
 692   {
 693     MonitorAutoLock lock(mMonitor);
 694
 695     releasingOwner = UnregisterTextureOwner(
 696         lock, aOwnerId, aForPid, releasingTextures, renderingReadyCallbacks);
 697     if (!releasingOwner) {
 698       return;
 699     }
 700
 701     mMonitor.Notify();
 702   }
 703
 704   const auto info =
 705       RemoteTextureInfo(RemoteTextureId{0}, RemoteTextureOwnerId{0}, 0);
 706   for (auto& callback : renderingReadyCallbacks) {
 707     callback(info);
 708   }
 709 }
 710
 711 void RemoteTextureMap::UnregisterTextureOwners(
 712     const RemoteTextureOwnerIdSet& aOwnerIds, const base::ProcessId aForPid) {
 713   std::vector<UniquePtr<TextureOwner>>
 714       releasingOwners;  // Release outside the monitor
 715   std::vector<RefPtr<TextureHost>>
 716       releasingTextures;  // Release outside the monitor
 717   std::vector<std::function<void(const RemoteTextureInfo&)>>
 718       renderingReadyCallbacks;  // Call outside the monitor
 719   {
 720     MonitorAutoLock lock(mMonitor);
 721
 722     for (const auto& id : aOwnerIds) {
 723       if (auto releasingOwner = UnregisterTextureOwner(
 724               lock, id, aForPid, releasingTextures, renderingReadyCallbacks)) {
 725         releasingOwners.push_back(std::move(releasingOwner));
 726       }
 727     }
 728
 729     if (releasingOwners.empty()) {
 730       return;
 731     }
 732
 733     mMonitor.Notify();
 734   }
 735
 736   const auto info =
 737       RemoteTextureInfo(RemoteTextureId{0}, RemoteTextureOwnerId{0}, 0);
 738   for (auto& callback : renderingReadyCallbacks) {
 739     callback(info);
 740   }
 741 }
 742
 743 already_AddRefed<RemoteTextureTxnScheduler>
 744 RemoteTextureMap::RegisterTxnScheduler(base::ProcessId aForPid,
 745                                        RemoteTextureTxnType aType) {
 746   MonitorAutoLock lock(mMonitor);
 747
 748   const auto key = std::pair(aForPid, aType);
 749   auto it = mTxnSchedulers.find(key);
 750   if (it != mTxnSchedulers.end()) {
 751     return do_AddRef(it->second);
 752   }
 753
 754   RefPtr<RemoteTextureTxnScheduler> scheduler(
 755       new RemoteTextureTxnScheduler(aForPid, aType));
 756   mTxnSchedulers.emplace(key, scheduler.get());
 757   return scheduler.forget();
 758 }
 759
 760 void RemoteTextureMap::UnregisterTxnScheduler(base::ProcessId aForPid,
 761                                               RemoteTextureTxnType aType) {
 762   MonitorAutoLock lock(mMonitor);
 763
 764   const auto key = std::pair(aForPid, aType);
 765   auto it = mTxnSchedulers.find(key);
 766   if (it == mTxnSchedulers.end()) {
 767     MOZ_ASSERT_UNREACHABLE("Remote texture txn scheduler does not exist.");
 768     return;
 769   }
 770   mTxnSchedulers.erase(it);
 771 }
 772
 773 already_AddRefed<RemoteTextureTxnScheduler> RemoteTextureTxnScheduler::Create(
 774     mozilla::ipc::IProtocol* aProtocol) {
 775   if (auto* instance = RemoteTextureMap::Get()) {
 776     if (auto* toplevel = aProtocol->ToplevelProtocol()) {
 777       auto pid = toplevel->OtherPidMaybeInvalid();
 778       if (pid != base::kInvalidProcessId) {
 779         return instance->RegisterTxnScheduler(pid, toplevel->GetProtocolId());
 780       }
 781     }
 782   }
 783   return nullptr;
 784 }
 785
 786 RemoteTextureTxnScheduler::~RemoteTextureTxnScheduler() {
 787   NotifyTxn(std::numeric_limits<RemoteTextureTxnId>::max());
 788   RemoteTextureMap::Get()->UnregisterTxnScheduler(mForPid, mType);
 789 }
 790
 791 void RemoteTextureTxnScheduler::NotifyTxn(RemoteTextureTxnId aTxnId) {
 792   MonitorAutoLock lock(RemoteTextureMap::Get()->mMonitor);
 793
 794   mLastTxnId = aTxnId;
 795
 796   for (; !mWaits.empty(); mWaits.pop_front()) {
 797     auto& wait = mWaits.front();
 798     if (wait.mTxnId > aTxnId) {
 799       break;
 800     }
 801     RemoteTextureMap::Get()->NotifyTxn(lock, wait.mOwnerId, mForPid);
 802   }
 803 }
 804
 805 bool RemoteTextureTxnScheduler::WaitForTxn(const MonitorAutoLock& aProofOfLock,
 806                                            RemoteTextureOwnerId aOwnerId,
 807                                            RemoteTextureTxnId aTxnId) {
 808   if (aTxnId <= mLastTxnId) {
 809     return false;
 810   }
 811   mWaits.insert(std::upper_bound(mWaits.begin(), mWaits.end(), aTxnId),
 812                 Wait{aOwnerId, aTxnId});
 813   return true;
 814 }
 815
 816 void RemoteTextureMap::ClearRecycledTextures(
 817     const RemoteTextureOwnerIdSet& aOwnerIds, const base::ProcessId aForPid,
 818     const RefPtr<RemoteTextureRecycleBin>& aRecycleBin) {
 819   std::list<RemoteTextureRecycleBin::RecycledTextureHolder>
 820       releasingTextures;  // Release outside the monitor
 821   {
 822     MonitorAutoLock lock(mMonitor);
 823
 824     if (aRecycleBin) {
 825       releasingTextures.splice(releasingTextures.end(),
 826                                aRecycleBin->mRecycledTextures);
 827     }
 828
 829     for (const auto& id : aOwnerIds) {
 830       const auto key = std::pair(aForPid, id);
 831       auto it = mTextureOwners.find(key);
 832       if (it == mTextureOwners.end()) {
 833         MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 834         continue;
 835       }
 836       auto& owner = it->second;
 837
 838       releasingTextures.splice(releasingTextures.end(),
 839                                owner->mRecycleBin->mRecycledTextures);
 840     }
 841   }
 842 }
 843
 844 void RemoteTextureMap::NotifyContextLost(
 845     const RemoteTextureOwnerIdSet& aOwnerIds, const base::ProcessId aForPid) {
 846   MonitorAutoLock lock(mMonitor);
 847
 848   bool changed = false;
 849   for (const auto& id : aOwnerIds) {
 850     const auto key = std::pair(aForPid, id);
 851     auto it = mTextureOwners.find(key);
 852     if (it == mTextureOwners.end()) {
 853       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 854       continue;
 855     }
 856     auto& owner = it->second;
 857     if (!owner->mIsContextLost) {
 858       owner->mIsContextLost = true;
 859       changed = true;
 860     }
 861   }
 862
 863   if (changed) {
 864     mMonitor.Notify();
 865   }
 866 }
 867
 868 void RemoteTextureMap::NotifyContextRestored(
 869     const RemoteTextureOwnerIdSet& aOwnerIds, const base::ProcessId aForPid) {
 870   MonitorAutoLock lock(mMonitor);
 871
 872   bool changed = false;
 873   for (const auto& id : aOwnerIds) {
 874     const auto key = std::pair(aForPid, id);
 875     auto it = mTextureOwners.find(key);
 876     if (it == mTextureOwners.end()) {
 877       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 878       continue;
 879     }
 880     auto& owner = it->second;
 881     if (owner->mIsContextLost) {
 882       owner->mIsContextLost = false;
 883       changed = true;
 884     }
 885   }
 886
 887   if (changed) {
 888     mMonitor.Notify();
 889   }
 890 }
 891
 892 /* static */
 893 RefPtr<TextureHost> RemoteTextureMap::CreateRemoteTexture(
 894     TextureData* aTextureData, TextureFlags aTextureFlags) {
 895   SurfaceDescriptor desc;
 896   DebugOnly<bool> ret = aTextureData->Serialize(desc);
 897   MOZ_ASSERT(ret);
 898   TextureFlags flags = aTextureFlags | TextureFlags::REMOTE_TEXTURE |
 899                        TextureFlags::DEALLOCATE_CLIENT;
 900
 901   Maybe<wr::ExternalImageId> externalImageId = Nothing();
 902   RefPtr<TextureHost> textureHost =
 903       TextureHost::Create(desc, null_t(), nullptr, LayersBackend::LAYERS_WR,
 904                           flags, externalImageId);
 905   MOZ_ASSERT(textureHost);
 906   if (!textureHost) {
 907     gfxCriticalNoteOnce << "Failed to create remote texture";
 908     return nullptr;
 909   }
 910
 911   textureHost->EnsureRenderTexture(Nothing());
 912
 913   return textureHost;
 914 }
 915
 916 void RemoteTextureMap::UpdateTexture(const MonitorAutoLock& aProofOfLock,
 917                                      RemoteTextureMap::TextureOwner* aOwner,
 918                                      const RemoteTextureId aTextureId) {
 919   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
 920   MOZ_ASSERT(aOwner);
 921   MOZ_ASSERT(aTextureId >= aOwner->mLatestUsingTextureId);
 922
 923   if (aTextureId == aOwner->mLatestUsingTextureId) {
 924     // No need to update texture.
 925     return;
 926   }
 927
 928   // Move remote textures to mUsingTextureDataHolders.
 929   while (!aOwner->mWaitingTextureDataHolders.empty()) {
 930     auto& front = aOwner->mWaitingTextureDataHolders.front();
 931     if (aTextureId < front->mTextureId) {
 932       break;
 933     }
 934     MOZ_RELEASE_ASSERT(front->mTextureHost);
 935     aOwner->mLatestTextureHost = front->mTextureHost;
 936     aOwner->mLatestUsingTextureId = front->mTextureId;
 937
 938     UniquePtr<TextureDataHolder> holder = std::move(front);
 939     aOwner->mWaitingTextureDataHolders.pop_front();
 940     // If there are textures not being used by the compositor that will be
 941     // obsoleted by this new texture, then queue them for removal later on
 942     // the creating thread.
 943     while (!aOwner->mUsingTextureDataHolders.empty()) {
 944       auto& back = aOwner->mUsingTextureDataHolders.back();
 945       if (back->mTextureHost &&
 946           back->mTextureHost->NumCompositableRefs() == 0) {
 947         if (!RecycleTexture(aOwner->mRecycleBin, *back, false)) {
 948           aOwner->mReleasingTextureDataHolders.push_back(std::move(back));
 949         }
 950         aOwner->mUsingTextureDataHolders.pop_back();
 951         continue;
 952       }
 953       break;
 954     }
 955     aOwner->mUsingTextureDataHolders.push_back(std::move(holder));
 956   }
 957 }
 958
 959 void RemoteTextureMap::GetRenderingReadyCallbacks(
 960     const MonitorAutoLock& aProofOfLock, RemoteTextureMap::TextureOwner* aOwner,
 961     const RemoteTextureId aTextureId,
 962     std::vector<std::function<void(const RemoteTextureInfo&)>>& aFunctions) {
 963   MOZ_ASSERT(aOwner);
 964
 965   while (!aOwner->mRenderingReadyCallbackHolders.empty()) {
 966     auto& front = aOwner->mRenderingReadyCallbackHolders.front();
 967     if (aTextureId < front->mTextureId) {
 968       break;
 969     }
 970     if (front->mCallback) {
 971       aFunctions.push_back(std::move(front->mCallback));
 972     }
 973     aOwner->mRenderingReadyCallbackHolders.pop_front();
 974   }
 975 }
 976
 977 void RemoteTextureMap::GetAllRenderingReadyCallbacks(
 978     const MonitorAutoLock& aProofOfLock, RemoteTextureMap::TextureOwner* aOwner,
 979     std::vector<std::function<void(const RemoteTextureInfo&)>>& aFunctions) {
 980   GetRenderingReadyCallbacks(aProofOfLock, aOwner, RemoteTextureId::Max(),
 981                              aFunctions);
 982   MOZ_ASSERT(aOwner->mRenderingReadyCallbackHolders.empty());
 983 }
 984
 985 bool RemoteTextureMap::WaitForRemoteTextureOwner(
 986     RemoteTextureHostWrapper* aTextureHostWrapper) {
 987   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
 988   MOZ_ASSERT(aTextureHostWrapper);
 989
 990   const auto& ownerId = aTextureHostWrapper->mOwnerId;
 991   const auto& forPid = aTextureHostWrapper->mForPid;
 992
 993   MonitorAutoLock lock(mMonitor);
 994
 995   auto* owner = GetTextureOwner(lock, ownerId, forPid);
 996   // If there is no texture owner yet, then we might need to wait for one to
 997   // be created, if allowed. If so, we must also wait for an initial texture
 998   // host to be created so we can use it.
 999   if (!owner || (!owner->mLatestTextureHost &&
1000                  owner->mWaitingTextureDataHolders.empty())) {
1001     const TimeDuration timeout = TimeDuration::FromMilliseconds(10000);
1002     while (!owner || (!owner->mLatestTextureHost &&
1003                       owner->mWaitingTextureDataHolders.empty())) {
1004       if (owner && (owner->mIsContextLost || owner->mDeferUnregister)) {
1005         // If the context was lost, no further updates are expected.
1006         return false;
1007       }
1008       CVStatus status = mMonitor.Wait(timeout);
1009       if (status == CVStatus::Timeout) {
1010         return false;
1011       }
1012       owner = GetTextureOwner(lock, ownerId, forPid);
1013     }
1014   }
1015   return true;
1016 }
1017
1018 void RemoteTextureMap::GetRemoteTexture(
1019     RemoteTextureHostWrapper* aTextureHostWrapper) {
1020   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
1021   MOZ_ASSERT(aTextureHostWrapper);
1022
1023   if (aTextureHostWrapper->IsReadyForRendering()) {
1024     return;
1025   }
1026
1027   const auto& textureId = aTextureHostWrapper->mTextureId;
1028   const auto& ownerId = aTextureHostWrapper->mOwnerId;
1029   const auto& forPid = aTextureHostWrapper->mForPid;
1030   const auto& size = aTextureHostWrapper->mSize;
1031
1032   RefPtr<TextureHost> textureHost;
1033   {
1034     MonitorAutoLock lock(mMonitor);
1035
1036     auto* owner = GetTextureOwner(lock, ownerId, forPid);
1037     if (!owner) {
1038       return;
1039     }
1040
1041     UpdateTexture(lock, owner, textureId);
1042
1043     if (owner->mLatestTextureHost &&
1044         (owner->mLatestTextureHost->GetFlags() & TextureFlags::DUMMY_TEXTURE)) {
1045       // Remote texture allocation was failed.
1046       return;
1047     }
1048
1049     if (textureId == owner->mLatestUsingTextureId) {
1050       MOZ_ASSERT(owner->mLatestTextureHost);
1051       MOZ_ASSERT(owner->mLatestTextureHost->GetSize() == size);
1052       if (owner->mLatestTextureHost->GetSize() != size) {
1053         gfxCriticalNoteOnce << "unexpected remote texture size: "
1054                             << owner->mLatestTextureHost->GetSize()
1055                             << " expected: " << size;
1056       }
1057       textureHost = owner->mLatestTextureHost;
1058     }
1059
1060     // Update mRemoteTextureHost
1061     if (textureId == owner->mLatestUsingTextureId) {
1062       const auto key = std::pair(forPid, textureId);
1063       auto it = mRemoteTextureHostWrapperHolders.find(key);
1064       if (it != mRemoteTextureHostWrapperHolders.end() &&
1065           !it->second->mRemoteTextureHost) {
1066         it->second->mRemoteTextureHost = owner->mLatestTextureHost;
1067       } else {
1068         MOZ_ASSERT(it->second->mRemoteTextureHost == owner->mLatestTextureHost);
1069       }
1070     }
1071
1072     if (textureHost) {
1073       aTextureHostWrapper->SetRemoteTextureHost(lock, textureHost);
1074       aTextureHostWrapper->ApplyTextureFlagsToRemoteTexture();
1075     }
1076   }
1077 }
1078
1079 void RemoteTextureMap::NotifyTxn(const MonitorAutoLock& aProofOfLock,
1080                                  const RemoteTextureOwnerId aOwnerId,
1081                                  const base::ProcessId aForPid) {
1082   if (auto* owner = GetTextureOwner(aProofOfLock, aOwnerId, aForPid)) {
1083     if (!owner->mWaitForTxn) {
1084       MOZ_ASSERT_UNREACHABLE("Expected texture owner to wait for txn.");
1085       return;
1086     }
1087     owner->mWaitForTxn = false;
1088     if (!owner->mDeferUnregister) {
1089       // If unregistering was not deferred, then don't try to force
1090       // unregistering yet.
1091       return;
1092     }
1093     owner->mDeferUnregister->Dispatch(NS_NewRunnableFunction(
1094         "RemoteTextureMap::SetLastRemoteTextureUse::Runnable",
1095         [aOwnerId, aForPid]() {
1096           RemoteTextureMap::Get()->UnregisterTextureOwner(aOwnerId, aForPid);
1097         }));
1098   }
1099 }
1100
1101 bool RemoteTextureMap::WaitForTxn(const RemoteTextureOwnerId aOwnerId,
1102                                   const base::ProcessId aForPid,
1103                                   RemoteTextureTxnType aTxnType,
1104                                   RemoteTextureTxnId aTxnId) {
1105   MonitorAutoLock lock(mMonitor);
1106   if (auto* owner = GetTextureOwner(lock, aOwnerId, aForPid)) {
1107     if (owner->mDeferUnregister) {
1108       MOZ_ASSERT_UNREACHABLE(
1109           "Texture owner must wait for txn before unregistering.");
1110       return false;
1111     }
1112     if (owner->mWaitForTxn) {
1113       MOZ_ASSERT_UNREACHABLE("Texture owner already waiting for txn.");
1114       return false;
1115     }
1116     const auto key = std::pair(aForPid, aTxnType);
1117     auto it = mTxnSchedulers.find(key);
1118     if (it == mTxnSchedulers.end()) {
1119       // During shutdown, different toplevel protocols may go away in
1120       // disadvantageous orders, causing us to sometimes be processing
1121       // waits even though the source of transactions upon which the
1122       // wait depends shut down. This is generally harmless to ignore,
1123       // as it means no further transactions will be generated of that
1124       // type and all such transactions have been processed before it
1125       // unregistered.
1126       NS_WARNING("Could not find scheduler for txn type.");
1127       return false;
1128     }
1129     if (it->second->WaitForTxn(lock, aOwnerId, aTxnId)) {
1130       owner->mWaitForTxn = true;
1131     }
1132     return true;
1133   }
1134   return false;
1135 }
1136
1137 void RemoteTextureMap::ReleaseRemoteTextureHost(
1138     RemoteTextureHostWrapper* aTextureHostWrapper) {
1139   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
1140   MOZ_ASSERT(aTextureHostWrapper);
1141
1142   RefPtr<TextureHost> releasingTexture;  // Release outside the mutex
1143   {
1144     MonitorAutoLock lock(mMonitor);
1145     releasingTexture = aTextureHostWrapper->GetRemoteTextureHost(lock);
1146     aTextureHostWrapper->ClearRemoteTextureHost(lock);
1147   }
1148 }
1149
1150 RefPtr<TextureHost> RemoteTextureMap::GetOrCreateRemoteTextureHostWrapper(
1151     const RemoteTextureId aTextureId, const RemoteTextureOwnerId aOwnerId,
1152     const base::ProcessId aForPid, const gfx::IntSize& aSize,
1153     const TextureFlags aFlags) {
1154   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
1155   MonitorAutoLock lock(mMonitor);
1156
1157   const auto key = std::pair(aForPid, aTextureId);
1158   auto it = mRemoteTextureHostWrapperHolders.find(key);
1159   if (it != mRemoteTextureHostWrapperHolders.end()) {
1160     return it->second->mRemoteTextureHostWrapper;
1161   }
1162
1163   auto wrapper = RemoteTextureHostWrapper::Create(aTextureId, aOwnerId, aForPid,
1164                                                   aSize, aFlags);
1165   auto wrapperHolder = MakeUnique<RemoteTextureHostWrapperHolder>(wrapper);
1166
1167   mRemoteTextureHostWrapperHolders.emplace(key, std::move(wrapperHolder));
1168
1169   return wrapper;
1170 }
1171
1172 void RemoteTextureMap::UnregisterRemoteTextureHostWrapper(
1173     const RemoteTextureId aTextureId, const RemoteTextureOwnerId aOwnerId,
1174     const base::ProcessId aForPid) {
1175   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
1176
1177   std::vector<RefPtr<TextureHost>>
1178       releasingTextures;  // Release outside the monitor
1179   {
1180     MonitorAutoLock lock(mMonitor);
1181
1182     const auto key = std::pair(aForPid, aTextureId);
1183     auto it = mRemoteTextureHostWrapperHolders.find(key);
1184     if (it == mRemoteTextureHostWrapperHolders.end()) {
1185       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
1186       return;
1187     }
1188     releasingTextures.emplace_back(it->second->mRemoteTextureHostWrapper);
1189     if (it->second->mRemoteTextureHost) {
1190       releasingTextures.emplace_back(it->second->mRemoteTextureHost);
1191     }
1192
1193     mRemoteTextureHostWrapperHolders.erase(it);
1194     mMonitor.Notify();
1195   }
1196 }
1197
1198 bool RemoteTextureMap::CheckRemoteTextureReady(
1199     const RemoteTextureInfo& aInfo,
1200     std::function<void(const RemoteTextureInfo&)>&& aCallback) {
1201   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
1202
1203   MonitorAutoLock lock(mMonitor);
1204
1205   auto* owner = GetTextureOwner(lock, aInfo.mOwnerId, aInfo.mForPid);
1206   if (aInfo.mWaitForRemoteTextureOwner && !owner) {
1207     // Remote texture owner is not registered yet. Waiting for remote texture
1208     // owner
1209
1210     const auto key = std::pair(aInfo.mForPid, aInfo.mOwnerId);
1211     if (!mWaitingTextureOwners[key]) {
1212       auto waitingOwner = MakeUnique<WaitingTextureOwner>();
1213       mWaitingTextureOwners[key] = std::move(waitingOwner);
1214     }
1215
1216     MOZ_ASSERT(mWaitingTextureOwners[key]);
1217
1218     WaitingTextureOwner* waitingOwner = mWaitingTextureOwners[key].get();
1219
1220     auto callbackHolder = MakeUnique<RenderingReadyCallbackHolder>(
1221         aInfo.mTextureId, std::move(aCallback));
1222     waitingOwner->mRenderingReadyCallbackHolders.push_back(
1223         std::move(callbackHolder));
1224
1225     return false;
1226   }
1227
1228   if (!owner || owner->mIsContextLost) {
1229     // Owner is already removed or context lost. No need to wait texture ready.
1230     return true;
1231   }
1232
1233   const auto key = std::pair(aInfo.mForPid, aInfo.mTextureId);
1234   auto it = mRemoteTextureHostWrapperHolders.find(key);
1235   if (it == mRemoteTextureHostWrapperHolders.end()) {
1236     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
1237     gfxCriticalNoteOnce << "Remote texture does not exist id:"
1238                         << uint64_t(aInfo.mTextureId);
1239     return true;
1240   }
1241
1242   if (owner->mLatestPushedTextureId >= aInfo.mTextureId) {
1243     return true;
1244   }
1245
1246   auto callbackHolder = MakeUnique<RenderingReadyCallbackHolder>(
1247       aInfo.mTextureId, std::move(aCallback));
1248   owner->mRenderingReadyCallbackHolders.push_back(std::move(callbackHolder));
1249
1250   return false;
1251 }
1252
1253 bool RemoteTextureMap::WaitRemoteTextureReady(const RemoteTextureInfo& aInfo) {
1254   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
1255
1256   MonitorAutoLock lock(mMonitor);
1257
1258   auto* owner = GetTextureOwner(lock, aInfo.mOwnerId, aInfo.mForPid);
1259   if (aInfo.mWaitForRemoteTextureOwner &&
1260       (!owner || (!owner->mLatestTextureHost &&
1261                   owner->mWaitingTextureDataHolders.empty()))) {
1262     const TimeDuration timeout = TimeDuration::FromMilliseconds(10000);
1263     while (!owner || (!owner->mLatestTextureHost &&
1264                       owner->mWaitingTextureDataHolders.empty())) {
1265       if (owner && (owner->mIsContextLost || owner->mDeferUnregister)) {
1266         // If the context was lost, no further updates are expected.
1267         return false;
1268       }
1269       CVStatus status = mMonitor.Wait(timeout);
1270       if (status == CVStatus::Timeout) {
1271         return false;
1272       }
1273       owner = GetTextureOwner(lock, aInfo.mOwnerId, aInfo.mForPid);
1274     }
1275   }
1276
1277   if (!owner || owner->mIsContextLost) {
1278     // Owner is already removed or context lost.
1279     return false;
1280   }
1281
1282   const auto key = std::pair(aInfo.mForPid, aInfo.mTextureId);
1283   auto it = mRemoteTextureHostWrapperHolders.find(key);
1284   if (it == mRemoteTextureHostWrapperHolders.end()) {
1285     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
1286     gfxCriticalNoteOnce << "Remote texture does not exist id:"
1287                         << uint64_t(aInfo.mTextureId);
1288     return false;
1289   }
1290
1291   const TimeDuration timeout = TimeDuration::FromMilliseconds(1000);
1292
1293   while (owner->mLatestPushedTextureId < aInfo.mTextureId) {
1294     CVStatus status = mMonitor.Wait(timeout);
1295     if (status == CVStatus::Timeout) {
1296       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
1297       gfxCriticalNoteOnce << "Remote texture wait time out id:"
1298                           << uint64_t(aInfo.mTextureId);
1299       return false;
1300     }
1301
1302     auto it = mRemoteTextureHostWrapperHolders.find(key);
1303     if (it == mRemoteTextureHostWrapperHolders.end()) {
1304       MOZ_ASSERT_UNREACHABLE("unexpected to be called");
1305       return false;
1306     }
1307
1308     auto* owner = GetTextureOwner(lock, aInfo.mOwnerId, aInfo.mForPid);
1309     // When owner is alreay unregistered, remote texture will not be pushed.
1310     if (!owner || owner->mIsContextLost) {
1311       // This could happen with IPC abnormal shutdown
1312       return false;
1313     }
1314   }
1315
1316   return true;
1317 }
1318
1319 void RemoteTextureMap::SuppressRemoteTextureReadyCheck(
1320     const RemoteTextureInfo& aInfo) {
1321   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
1322   MonitorAutoLock lock(mMonitor);
1323
1324   // Clear if WaitingTextureOwner exists.
1325   auto itWaiting =
1326       mWaitingTextureOwners.find(std::pair(aInfo.mForPid, aInfo.mOwnerId));
1327   if (itWaiting != mWaitingTextureOwners.end()) {
1328     mWaitingTextureOwners.erase(itWaiting);
1329   }
1330
1331   const auto key = std::pair(aInfo.mForPid, aInfo.mTextureId);
1332   auto it = mRemoteTextureHostWrapperHolders.find(key);
1333   if (it == mRemoteTextureHostWrapperHolders.end()) {
1334     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
1335     return;
1336   }
1337   it->second->mReadyCheckSuppressed = true;
1338 }
1339
1340 UniquePtr<TextureData> RemoteTextureMap::GetRecycledTextureData(
1341     const RemoteTextureOwnerId aOwnerId, const base::ProcessId aForPid,
1342     const RefPtr<RemoteTextureRecycleBin>& aRecycleBin,
1343     const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat,
1344     TextureType aTextureType) {
1345   MonitorAutoLock lock(mMonitor);
1346
1347   RefPtr<RemoteTextureRecycleBin> bin;
1348   if (aOwnerId.IsValid()) {
1349     if (auto* owner = GetTextureOwner(lock, aOwnerId, aForPid)) {
1350       bin = owner->mRecycleBin;
1351     }
1352   } else {
1353     bin = aRecycleBin;
1354   }
1355   if (!bin) {
1356     return nullptr;
1357   }
1358
1359   for (auto it = bin->mRecycledTextures.begin();
1360        it != bin->mRecycledTextures.end(); it++) {
1361     auto& holder = *it;
1362     if (holder.mTextureData &&
1363         holder.mTextureData->GetTextureType() == aTextureType &&
1364         holder.mSize == aSize && holder.mFormat == aFormat) {
1365       UniquePtr<TextureData> texture = std::move(holder.mTextureData);
1366       bin->mRecycledTextures.erase(it);
1367       return texture;
1368     }
1369   }
1370
1371   return nullptr;
1372 }
1373
1374 UniquePtr<SharedResourceWrapper> RemoteTextureMap::GetRecycledSharedTexture(
1375     const RemoteTextureOwnerId aOwnerId, const base::ProcessId aForPid,
1376     const RefPtr<RemoteTextureRecycleBin>& aRecycleBin,
1377     const gfx::IntSize& aSize, const gfx::SurfaceFormat aFormat,
1378     SurfaceDescriptor::Type aType) {
1379   MonitorAutoLock lock(mMonitor);
1380
1381   RefPtr<RemoteTextureRecycleBin> bin;
1382   if (aOwnerId.IsValid()) {
1383     if (auto* owner = GetTextureOwner(lock, aOwnerId, aForPid)) {
1384       bin = owner->mRecycleBin;
1385     }
1386   } else {
1387     bin = aRecycleBin;
1388   }
1389   if (!bin) {
1390     return nullptr;
1391   }
1392
1393   for (auto it = bin->mRecycledTextures.begin();
1394        it != bin->mRecycledTextures.end(); it++) {
1395     auto& holder = *it;
1396     if (holder.mType == aType && holder.mSize == aSize &&
1397         holder.mFormat == aFormat) {
1398       UniquePtr<SharedResourceWrapper> wrapper =
1399           std::move(holder.mResourceWrapper);
1400       bin->mRecycledTextures.erase(it);
1401       return wrapper;
1402     }
1403   }
1404
1405   return nullptr;
1406 }
1407
1408 RemoteTextureMap::TextureOwner* RemoteTextureMap::GetTextureOwner(
1409     const MonitorAutoLock& aProofOfLock, const RemoteTextureOwnerId aOwnerId,
1410     const base::ProcessId aForPid) {
1411   const auto key = std::pair(aForPid, aOwnerId);
1412   auto it = mTextureOwners.find(key);
1413   if (it == mTextureOwners.end()) {
1414     return nullptr;
1415   }
1416   return it->second.get();
1417 }
1418
1419 RemoteTextureMap::TextureDataHolder::TextureDataHolder(
1420     const RemoteTextureId aTextureId, RefPtr<TextureHost> aTextureHost,
1421     UniquePtr<TextureData>&& aTextureData,
1422     UniquePtr<SharedResourceWrapper>&& aResourceWrapper)
1423     : mTextureId(aTextureId),
1424       mTextureHost(aTextureHost),
1425       mTextureData(std::move(aTextureData)),
1426       mResourceWrapper(std::move(aResourceWrapper)) {}
1427
1428 RemoteTextureMap::RenderingReadyCallbackHolder::RenderingReadyCallbackHolder(
1429     const RemoteTextureId aTextureId,
1430     std::function<void(const RemoteTextureInfo&)>&& aCallback)
1431     : mTextureId(aTextureId), mCallback(aCallback) {}
1432
1433 RemoteTextureMap::RemoteTextureHostWrapperHolder::
1434     RemoteTextureHostWrapperHolder(
1435         RefPtr<TextureHost> aRemoteTextureHostWrapper)
1436     : mRemoteTextureHostWrapper(aRemoteTextureHostWrapper) {}
1437
1438 }  // namespace mozilla::layers