RecordedCanvasEventImpl.h (28943B)
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 #ifndef mozilla_layers_RecordedCanvasEventImpl_h 8 #define mozilla_layers_RecordedCanvasEventImpl_h 9 10 #include "mozilla/gfx/RecordedEvent.h" 11 #include "mozilla/gfx/RecordingTypes.h" 12 #include "mozilla/layers/CanvasTranslator.h" 13 #include "mozilla/layers/CompositorTypes.h" 14 #include "mozilla/layers/TextureClient.h" 15 16 namespace mozilla { 17 namespace layers { 18 19 using gfx::BackendType; 20 using gfx::DrawTarget; 21 using gfx::IntSize; 22 using gfx::RecordedEvent; 23 using gfx::RecordedEventDerived; 24 using EventType = gfx::RecordedEvent::EventType; 25 using gfx::ReadElement; 26 using gfx::ReferencePtr; 27 using gfx::SurfaceFormat; 28 using gfx::WriteElement; 29 30 const EventType CANVAS_BEGIN_TRANSACTION = EventType::LAST; 31 const EventType CANVAS_END_TRANSACTION = EventType(EventType::LAST + 1); 32 const EventType CANVAS_FLUSH = EventType(EventType::LAST + 2); 33 const EventType TEXTURE_LOCK = EventType(EventType::LAST + 3); 34 const EventType TEXTURE_UNLOCK = EventType(EventType::LAST + 4); 35 const EventType CACHE_DATA_SURFACE = EventType(EventType::LAST + 5); 36 const EventType GET_DATA_FOR_SURFACE = EventType(EventType::LAST + 6); 37 const EventType ADD_SURFACE_ALIAS = EventType(EventType::LAST + 7); 38 const EventType REMOVE_SURFACE_ALIAS = EventType(EventType::LAST + 8); 39 const EventType CANVAS_DRAW_TARGET_CREATION = EventType(EventType::LAST + 9); 40 const EventType TEXTURE_DESTRUCTION = EventType(EventType::LAST + 10); 41 const EventType CHECKPOINT = EventType(EventType::LAST + 11); 42 const EventType PAUSE_TRANSLATION = EventType(EventType::LAST + 12); 43 const EventType RECYCLE_BUFFER = EventType(EventType::LAST + 13); 44 const EventType DROP_BUFFER = EventType(EventType::LAST + 14); 45 const EventType PREPARE_SHMEM = EventType(EventType::LAST + 15); 46 const EventType PRESENT_TEXTURE = EventType(EventType::LAST + 16); 47 const EventType DEVICE_RESET_ACKNOWLEDGED = EventType(EventType::LAST + 17); 48 const EventType AWAIT_TRANSLATION_SYNC = EventType(EventType::LAST + 18); 49 const EventType RESOLVE_EXTERNAL_SNAPSHOT = EventType(EventType::LAST + 19); 50 const EventType ADD_EXPORT_SURFACE = EventType(EventType::LAST + 20); 51 const EventType REMOVE_EXPORT_SURFACE = EventType(EventType::LAST + 21); 52 const EventType LAST_CANVAS_EVENT_TYPE = REMOVE_EXPORT_SURFACE; 53 54 class RecordedCanvasBeginTransaction final 55 : public RecordedEventDerived<RecordedCanvasBeginTransaction> { 56 public: 57 RecordedCanvasBeginTransaction() 58 : RecordedEventDerived(CANVAS_BEGIN_TRANSACTION) {} 59 60 template <class S> 61 MOZ_IMPLICIT RecordedCanvasBeginTransaction(S& aStream); 62 63 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 64 65 template <class S> 66 void Record(S& aStream) const; 67 68 std::string GetName() const final { return "RecordedCanvasBeginTransaction"; } 69 }; 70 71 inline bool RecordedCanvasBeginTransaction::PlayCanvasEvent( 72 CanvasTranslator* aTranslator) const { 73 aTranslator->BeginTransaction(); 74 return true; 75 } 76 77 template <class S> 78 void RecordedCanvasBeginTransaction::Record(S& aStream) const {} 79 80 template <class S> 81 RecordedCanvasBeginTransaction::RecordedCanvasBeginTransaction(S& aStream) 82 : RecordedEventDerived(CANVAS_BEGIN_TRANSACTION) {} 83 84 class RecordedCanvasEndTransaction final 85 : public RecordedEventDerived<RecordedCanvasEndTransaction> { 86 public: 87 RecordedCanvasEndTransaction() 88 : RecordedEventDerived(CANVAS_END_TRANSACTION) {} 89 90 template <class S> 91 MOZ_IMPLICIT RecordedCanvasEndTransaction(S& aStream); 92 93 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 94 95 template <class S> 96 void Record(S& aStream) const; 97 98 std::string GetName() const final { return "RecordedCanvasEndTransaction"; } 99 }; 100 101 inline bool RecordedCanvasEndTransaction::PlayCanvasEvent( 102 CanvasTranslator* aTranslator) const { 103 aTranslator->EndTransaction(); 104 return true; 105 } 106 107 template <class S> 108 void RecordedCanvasEndTransaction::Record(S& aStream) const {} 109 110 template <class S> 111 RecordedCanvasEndTransaction::RecordedCanvasEndTransaction(S& aStream) 112 : RecordedEventDerived(CANVAS_END_TRANSACTION) {} 113 114 class RecordedCanvasFlush final 115 : public RecordedEventDerived<RecordedCanvasFlush> { 116 public: 117 RecordedCanvasFlush() : RecordedEventDerived(CANVAS_FLUSH) {} 118 119 template <class S> 120 MOZ_IMPLICIT RecordedCanvasFlush(S& aStream); 121 122 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 123 124 template <class S> 125 void Record(S& aStream) const; 126 127 std::string GetName() const final { return "RecordedCanvasFlush"; } 128 }; 129 130 inline bool RecordedCanvasFlush::PlayCanvasEvent( 131 CanvasTranslator* aTranslator) const { 132 aTranslator->Flush(); 133 return true; 134 } 135 136 template <class S> 137 void RecordedCanvasFlush::Record(S& aStream) const {} 138 139 template <class S> 140 RecordedCanvasFlush::RecordedCanvasFlush(S& aStream) 141 : RecordedEventDerived(CANVAS_FLUSH) {} 142 143 class RecordedTextureLock final 144 : public RecordedEventDerived<RecordedTextureLock> { 145 public: 146 RecordedTextureLock(const RemoteTextureOwnerId aTextureOwnerId, 147 const OpenMode aMode, bool aInvalidContents) 148 : RecordedEventDerived(TEXTURE_LOCK), 149 mTextureOwnerId(aTextureOwnerId), 150 mMode(aMode), 151 mInvalidContents(aInvalidContents) {} 152 153 template <class S> 154 MOZ_IMPLICIT RecordedTextureLock(S& aStream); 155 156 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 157 158 template <class S> 159 void Record(S& aStream) const; 160 161 std::string GetName() const final { return "TextureLock"; } 162 163 private: 164 RemoteTextureOwnerId mTextureOwnerId; 165 OpenMode mMode = OpenMode::OPEN_NONE; 166 bool mInvalidContents = false; 167 }; 168 169 inline bool RecordedTextureLock::PlayCanvasEvent( 170 CanvasTranslator* aTranslator) const { 171 if (!aTranslator->LockTexture(mTextureOwnerId, mMode, mInvalidContents)) { 172 return false; 173 } 174 return true; 175 } 176 177 template <class S> 178 void RecordedTextureLock::Record(S& aStream) const { 179 WriteElement(aStream, mTextureOwnerId); 180 WriteElement(aStream, mMode); 181 WriteElement(aStream, mInvalidContents); 182 } 183 184 template <class S> 185 RecordedTextureLock::RecordedTextureLock(S& aStream) 186 : RecordedEventDerived(TEXTURE_LOCK) { 187 ReadElement(aStream, mTextureOwnerId); 188 ReadElementConstrained(aStream, mMode, OpenMode::OPEN_NONE, 189 OpenMode::OPEN_READ_WRITE); 190 ReadElement(aStream, mInvalidContents); 191 } 192 193 class RecordedTextureUnlock final 194 : public RecordedEventDerived<RecordedTextureUnlock> { 195 public: 196 explicit RecordedTextureUnlock(const RemoteTextureOwnerId aTextureOwnerId) 197 : RecordedEventDerived(TEXTURE_UNLOCK), 198 mTextureOwnerId(aTextureOwnerId) {} 199 200 template <class S> 201 MOZ_IMPLICIT RecordedTextureUnlock(S& aStream); 202 203 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 204 205 template <class S> 206 void Record(S& aStream) const; 207 208 std::string GetName() const final { return "TextureUnlock"; } 209 210 private: 211 RemoteTextureOwnerId mTextureOwnerId; 212 }; 213 214 inline bool RecordedTextureUnlock::PlayCanvasEvent( 215 CanvasTranslator* aTranslator) const { 216 if (!aTranslator->UnlockTexture(mTextureOwnerId)) { 217 return false; 218 } 219 return true; 220 } 221 222 template <class S> 223 void RecordedTextureUnlock::Record(S& aStream) const { 224 WriteElement(aStream, mTextureOwnerId); 225 } 226 227 template <class S> 228 RecordedTextureUnlock::RecordedTextureUnlock(S& aStream) 229 : RecordedEventDerived(TEXTURE_UNLOCK) { 230 ReadElement(aStream, mTextureOwnerId); 231 } 232 233 class RecordedCacheDataSurface final 234 : public RecordedEventDerived<RecordedCacheDataSurface> { 235 public: 236 explicit RecordedCacheDataSurface(const gfx::SourceSurface* aSurface, 237 bool aForceData = false) 238 : RecordedEventDerived(CACHE_DATA_SURFACE), 239 mSurface(aSurface), 240 mForceData(aForceData) {} 241 242 template <class S> 243 MOZ_IMPLICIT RecordedCacheDataSurface(S& aStream); 244 245 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 246 247 template <class S> 248 void Record(S& aStream) const; 249 250 std::string GetName() const final { return "RecordedCacheDataSurface"; } 251 252 private: 253 ReferencePtr mSurface; 254 bool mForceData = false; 255 }; 256 257 inline bool RecordedCacheDataSurface::PlayCanvasEvent( 258 CanvasTranslator* aTranslator) const { 259 if (RefPtr<gfx::DataSourceSurface> dataSurface = 260 aTranslator->LookupDataSurface(mSurface)) { 261 if (mForceData) { 262 gfx::DataSourceSurface::ScopedMap map( 263 dataSurface, gfx::DataSourceSurface::MapType::READ); 264 } 265 return true; 266 } 267 268 gfx::SourceSurface* surface = aTranslator->LookupSourceSurface(mSurface); 269 if (!surface) { 270 return false; 271 } 272 if (RefPtr<gfx::DataSourceSurface> dataSurface = surface->GetDataSurface()) { 273 if (mForceData) { 274 gfx::DataSourceSurface::ScopedMap map( 275 dataSurface, gfx::DataSourceSurface::MapType::READ); 276 } 277 aTranslator->AddDataSurface(mSurface, std::move(dataSurface)); 278 } 279 return true; 280 } 281 282 template <class S> 283 void RecordedCacheDataSurface::Record(S& aStream) const { 284 WriteElement(aStream, mSurface); 285 WriteElement(aStream, mForceData); 286 } 287 288 template <class S> 289 RecordedCacheDataSurface::RecordedCacheDataSurface(S& aStream) 290 : RecordedEventDerived(CACHE_DATA_SURFACE) { 291 ReadElement(aStream, mSurface); 292 ReadElement(aStream, mForceData); 293 } 294 295 class RecordedGetDataForSurface final 296 : public RecordedEventDerived<RecordedGetDataForSurface> { 297 public: 298 RecordedGetDataForSurface(uint32_t aId, const gfx::SourceSurface* aSurface) 299 : RecordedEventDerived(GET_DATA_FOR_SURFACE), 300 mId(aId), 301 mSurface(aSurface) {} 302 303 template <class S> 304 MOZ_IMPLICIT RecordedGetDataForSurface(S& aStream); 305 306 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 307 308 template <class S> 309 void Record(S& aStream) const; 310 311 std::string GetName() const final { return "RecordedGetDataForSurface"; } 312 313 private: 314 uint32_t mId = 0; 315 ReferencePtr mSurface; 316 }; 317 318 inline bool RecordedGetDataForSurface::PlayCanvasEvent( 319 CanvasTranslator* aTranslator) const { 320 aTranslator->GetDataSurface(mId, mSurface.mLongPtr); 321 return true; 322 } 323 324 template <class S> 325 void RecordedGetDataForSurface::Record(S& aStream) const { 326 WriteElement(aStream, mId); 327 WriteElement(aStream, mSurface); 328 } 329 330 template <class S> 331 RecordedGetDataForSurface::RecordedGetDataForSurface(S& aStream) 332 : RecordedEventDerived(GET_DATA_FOR_SURFACE) { 333 ReadElement(aStream, mId); 334 ReadElement(aStream, mSurface); 335 } 336 337 class RecordedAddSurfaceAlias final 338 : public RecordedEventDerived<RecordedAddSurfaceAlias> { 339 public: 340 RecordedAddSurfaceAlias(ReferencePtr aSurfaceAlias, 341 const RefPtr<gfx::SourceSurface>& aActualSurface) 342 : RecordedEventDerived(ADD_SURFACE_ALIAS), 343 mSurfaceAlias(aSurfaceAlias), 344 mActualSurface(aActualSurface) {} 345 346 template <class S> 347 MOZ_IMPLICIT RecordedAddSurfaceAlias(S& aStream); 348 349 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 350 351 template <class S> 352 void Record(S& aStream) const; 353 354 std::string GetName() const final { return "RecordedAddSurfaceAlias"; } 355 356 private: 357 ReferencePtr mSurfaceAlias; 358 ReferencePtr mActualSurface; 359 }; 360 361 inline bool RecordedAddSurfaceAlias::PlayCanvasEvent( 362 CanvasTranslator* aTranslator) const { 363 RefPtr<gfx::SourceSurface> surface = 364 aTranslator->LookupSourceSurface(mActualSurface); 365 if (!surface) { 366 return false; 367 } 368 369 aTranslator->AddSourceSurface(mSurfaceAlias, surface); 370 return true; 371 } 372 373 template <class S> 374 void RecordedAddSurfaceAlias::Record(S& aStream) const { 375 WriteElement(aStream, mSurfaceAlias); 376 WriteElement(aStream, mActualSurface); 377 } 378 379 template <class S> 380 RecordedAddSurfaceAlias::RecordedAddSurfaceAlias(S& aStream) 381 : RecordedEventDerived(ADD_SURFACE_ALIAS) { 382 ReadElement(aStream, mSurfaceAlias); 383 ReadElement(aStream, mActualSurface); 384 } 385 386 class RecordedRemoveSurfaceAlias final 387 : public RecordedEventDerived<RecordedRemoveSurfaceAlias> { 388 public: 389 explicit RecordedRemoveSurfaceAlias(ReferencePtr aSurfaceAlias) 390 : RecordedEventDerived(REMOVE_SURFACE_ALIAS), 391 mSurfaceAlias(aSurfaceAlias) {} 392 393 template <class S> 394 MOZ_IMPLICIT RecordedRemoveSurfaceAlias(S& aStream); 395 396 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 397 398 template <class S> 399 void Record(S& aStream) const; 400 401 std::string GetName() const final { return "RecordedRemoveSurfaceAlias"; } 402 403 private: 404 ReferencePtr mSurfaceAlias; 405 }; 406 407 inline bool RecordedRemoveSurfaceAlias::PlayCanvasEvent( 408 CanvasTranslator* aTranslator) const { 409 aTranslator->RemoveSourceSurface(mSurfaceAlias); 410 return true; 411 } 412 413 template <class S> 414 void RecordedRemoveSurfaceAlias::Record(S& aStream) const { 415 WriteElement(aStream, mSurfaceAlias); 416 } 417 418 template <class S> 419 RecordedRemoveSurfaceAlias::RecordedRemoveSurfaceAlias(S& aStream) 420 : RecordedEventDerived(REMOVE_SURFACE_ALIAS) { 421 ReadElement(aStream, mSurfaceAlias); 422 } 423 424 class RecordedDeviceResetAcknowledged final 425 : public RecordedEventDerived<RecordedDeviceResetAcknowledged> { 426 public: 427 RecordedDeviceResetAcknowledged() 428 : RecordedEventDerived(DEVICE_RESET_ACKNOWLEDGED) {} 429 430 template <class S> 431 MOZ_IMPLICIT RecordedDeviceResetAcknowledged(S& aStream); 432 433 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 434 435 template <class S> 436 void Record(S& aStream) const; 437 438 std::string GetName() const final { 439 return "RecordedDeviceResetAcknowledged"; 440 } 441 }; 442 443 inline bool RecordedDeviceResetAcknowledged::PlayCanvasEvent( 444 CanvasTranslator* aTranslator) const { 445 aTranslator->DeviceResetAcknowledged(); 446 return true; 447 } 448 449 template <class S> 450 void RecordedDeviceResetAcknowledged::Record(S& aStream) const {} 451 452 template <class S> 453 RecordedDeviceResetAcknowledged::RecordedDeviceResetAcknowledged(S& aStream) 454 : RecordedEventDerived(DEVICE_RESET_ACKNOWLEDGED) {} 455 456 class RecordedCanvasDrawTargetCreation final 457 : public RecordedEventDerived<RecordedCanvasDrawTargetCreation> { 458 public: 459 RecordedCanvasDrawTargetCreation(ReferencePtr aRefPtr, 460 RemoteTextureOwnerId aTextureOwnerId, 461 BackendType aType, const IntSize& aSize, 462 SurfaceFormat aFormat) 463 : RecordedEventDerived(CANVAS_DRAW_TARGET_CREATION), 464 mRefPtr(aRefPtr), 465 mTextureOwnerId(aTextureOwnerId), 466 mBackendType(aType), 467 mSize(aSize), 468 mFormat(aFormat) {} 469 470 template <class S> 471 MOZ_IMPLICIT RecordedCanvasDrawTargetCreation(S& aStream); 472 473 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 474 475 template <class S> 476 void Record(S& aStream) const; 477 478 std::string GetName() const final { return "Canvas DrawTarget Creation"; } 479 480 ReferencePtr mRefPtr; 481 RemoteTextureOwnerId mTextureOwnerId; 482 BackendType mBackendType = BackendType::NONE; 483 IntSize mSize; 484 SurfaceFormat mFormat = SurfaceFormat::UNKNOWN; 485 }; 486 487 inline bool RecordedCanvasDrawTargetCreation::PlayCanvasEvent( 488 CanvasTranslator* aTranslator) const { 489 RefPtr<DrawTarget> newDT = 490 aTranslator->CreateDrawTarget(mRefPtr, mTextureOwnerId, mSize, mFormat); 491 492 // If we couldn't create a DrawTarget this will probably cause us to crash 493 // with nullptr later in the playback, so return false to abort. 494 return !!newDT; 495 } 496 497 template <class S> 498 void RecordedCanvasDrawTargetCreation::Record(S& aStream) const { 499 WriteElement(aStream, mRefPtr); 500 WriteElement(aStream, mTextureOwnerId); 501 WriteElement(aStream, mBackendType); 502 WriteElement(aStream, mSize); 503 WriteElement(aStream, mFormat); 504 } 505 506 template <class S> 507 RecordedCanvasDrawTargetCreation::RecordedCanvasDrawTargetCreation(S& aStream) 508 : RecordedEventDerived(CANVAS_DRAW_TARGET_CREATION) { 509 ReadElement(aStream, mRefPtr); 510 ReadElement(aStream, mTextureOwnerId); 511 ReadElementConstrained(aStream, mBackendType, BackendType::NONE, 512 BackendType::WEBRENDER_TEXT); 513 ReadElement(aStream, mSize); 514 ReadElementConstrained(aStream, mFormat, SurfaceFormat::A8R8G8B8_UINT32, 515 SurfaceFormat::UNKNOWN); 516 } 517 518 class RecordedTextureDestruction final 519 : public RecordedEventDerived<RecordedTextureDestruction> { 520 public: 521 RecordedTextureDestruction(RemoteTextureOwnerId aTextureOwnerId, 522 RemoteTextureTxnType aTxnType, 523 RemoteTextureTxnId aTxnId) 524 : RecordedEventDerived(TEXTURE_DESTRUCTION), 525 mTextureOwnerId(aTextureOwnerId), 526 mTxnType(aTxnType), 527 mTxnId(aTxnId) {} 528 529 template <class S> 530 MOZ_IMPLICIT RecordedTextureDestruction(S& aStream); 531 532 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 533 534 template <class S> 535 void Record(S& aStream) const; 536 537 std::string GetName() const final { return "RecordedTextureDestruction"; } 538 539 private: 540 RemoteTextureOwnerId mTextureOwnerId; 541 RemoteTextureTxnType mTxnType = 0; 542 RemoteTextureTxnId mTxnId = 0; 543 }; 544 545 inline bool RecordedTextureDestruction::PlayCanvasEvent( 546 CanvasTranslator* aTranslator) const { 547 aTranslator->RemoveTexture(mTextureOwnerId, mTxnType, mTxnId); 548 return true; 549 } 550 551 template <class S> 552 void RecordedTextureDestruction::Record(S& aStream) const { 553 WriteElement(aStream, mTextureOwnerId); 554 WriteElement(aStream, mTxnType); 555 WriteElement(aStream, mTxnId); 556 } 557 558 template <class S> 559 RecordedTextureDestruction::RecordedTextureDestruction(S& aStream) 560 : RecordedEventDerived(TEXTURE_DESTRUCTION) { 561 ReadElement(aStream, mTextureOwnerId); 562 ReadElement(aStream, mTxnType); 563 ReadElement(aStream, mTxnId); 564 } 565 566 class RecordedCheckpoint final 567 : public RecordedEventDerived<RecordedCheckpoint> { 568 public: 569 RecordedCheckpoint() : RecordedEventDerived(CHECKPOINT) {} 570 571 template <class S> 572 MOZ_IMPLICIT RecordedCheckpoint(S& aStream) 573 : RecordedEventDerived(CHECKPOINT) {} 574 575 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const { 576 aTranslator->CheckpointReached(); 577 return true; 578 } 579 580 template <class S> 581 void Record(S& aStream) const {} 582 583 std::string GetName() const final { return "RecordedCheckpoint"; } 584 }; 585 586 class RecordedPauseTranslation final 587 : public RecordedEventDerived<RecordedPauseTranslation> { 588 public: 589 RecordedPauseTranslation() : RecordedEventDerived(PAUSE_TRANSLATION) {} 590 591 template <class S> 592 MOZ_IMPLICIT RecordedPauseTranslation(S& aStream) 593 : RecordedEventDerived(PAUSE_TRANSLATION) {} 594 595 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const { 596 aTranslator->PauseTranslation(); 597 return true; 598 } 599 600 template <class S> 601 void Record(S& aStream) const {} 602 603 std::string GetName() const final { return "RecordedPauseTranslation"; } 604 }; 605 606 class RecordedAwaitTranslationSync final 607 : public RecordedEventDerived<RecordedAwaitTranslationSync> { 608 public: 609 explicit RecordedAwaitTranslationSync(uint64_t aSyncId) 610 : RecordedEventDerived(AWAIT_TRANSLATION_SYNC), mSyncId(aSyncId) {} 611 612 template <class S> 613 MOZ_IMPLICIT RecordedAwaitTranslationSync(S& aStream); 614 615 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const { 616 aTranslator->AwaitTranslationSync(mSyncId); 617 return true; 618 } 619 620 template <class S> 621 void Record(S& aStream) const; 622 623 std::string GetName() const final { return "RecordedAwaitTranslationSync"; } 624 625 private: 626 uint64_t mSyncId = 0; 627 }; 628 629 template <class S> 630 void RecordedAwaitTranslationSync::Record(S& aStream) const { 631 WriteElement(aStream, mSyncId); 632 } 633 634 template <class S> 635 RecordedAwaitTranslationSync::RecordedAwaitTranslationSync(S& aStream) 636 : RecordedEventDerived(AWAIT_TRANSLATION_SYNC) { 637 ReadElement(aStream, mSyncId); 638 } 639 640 class RecordedResolveExternalSnapshot final 641 : public RecordedEventDerived<RecordedResolveExternalSnapshot> { 642 public: 643 explicit RecordedResolveExternalSnapshot(uint64_t aSyncId, 644 ReferencePtr aRefPtr, 645 const IntSize& aSize, 646 SurfaceFormat aFormat) 647 : RecordedEventDerived(RESOLVE_EXTERNAL_SNAPSHOT), 648 mSyncId(aSyncId), 649 mRefPtr(aRefPtr), 650 mSize(aSize), 651 mFormat(aFormat) {} 652 653 template <class S> 654 MOZ_IMPLICIT RecordedResolveExternalSnapshot(S& aStream); 655 656 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const { 657 DrawTarget* drawTarget = aTranslator->GetCurrentDrawTarget(); 658 if (!drawTarget) { 659 return false; 660 } 661 return aTranslator->ResolveExternalSnapshot(mSyncId, mRefPtr, mSize, 662 mFormat, drawTarget); 663 } 664 665 template <class S> 666 void Record(S& aStream) const; 667 668 std::string GetName() const final { 669 return "RecordedResolveExternalSnapshot"; 670 } 671 672 private: 673 uint64_t mSyncId = 0; 674 ReferencePtr mRefPtr; 675 IntSize mSize; 676 SurfaceFormat mFormat = SurfaceFormat::UNKNOWN; 677 }; 678 679 template <class S> 680 void RecordedResolveExternalSnapshot::Record(S& aStream) const { 681 WriteElement(aStream, mSyncId); 682 WriteElement(aStream, mRefPtr); 683 WriteElement(aStream, mSize); 684 WriteElement(aStream, mFormat); 685 } 686 687 template <class S> 688 RecordedResolveExternalSnapshot::RecordedResolveExternalSnapshot(S& aStream) 689 : RecordedEventDerived(RESOLVE_EXTERNAL_SNAPSHOT) { 690 ReadElement(aStream, mSyncId); 691 ReadElement(aStream, mRefPtr); 692 ReadElement(aStream, mSize); 693 ReadElementConstrained(aStream, mFormat, SurfaceFormat::B8G8R8A8, 694 SurfaceFormat::UNKNOWN); 695 } 696 697 class RecordedRecycleBuffer final 698 : public RecordedEventDerived<RecordedRecycleBuffer> { 699 public: 700 RecordedRecycleBuffer() : RecordedEventDerived(RECYCLE_BUFFER) {} 701 702 template <class S> 703 MOZ_IMPLICIT RecordedRecycleBuffer(S& aStream) 704 : RecordedEventDerived(RECYCLE_BUFFER) {} 705 706 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const { 707 aTranslator->RecycleBuffer(); 708 return true; 709 } 710 711 template <class S> 712 void Record(S& aStream) const {} 713 714 std::string GetName() const final { return "RecordedNextBuffer"; } 715 }; 716 717 class RecordedDropBuffer final 718 : public RecordedEventDerived<RecordedDropBuffer> { 719 public: 720 RecordedDropBuffer() : RecordedEventDerived(DROP_BUFFER) {} 721 722 template <class S> 723 MOZ_IMPLICIT RecordedDropBuffer(S& aStream) 724 : RecordedEventDerived(DROP_BUFFER) {} 725 726 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const { 727 // Use the next buffer without recycling which drops the current buffer. 728 aTranslator->NextBuffer(); 729 return true; 730 } 731 732 template <class S> 733 void Record(S& aStream) const {} 734 735 std::string GetName() const final { return "RecordedDropAndMoveNextBuffer"; } 736 }; 737 738 class RecordedPrepareShmem final 739 : public RecordedEventDerived<RecordedPrepareShmem> { 740 public: 741 explicit RecordedPrepareShmem(const RemoteTextureOwnerId aTextureOwnerId) 742 : RecordedEventDerived(PREPARE_SHMEM), mTextureOwnerId(aTextureOwnerId) {} 743 744 template <class S> 745 MOZ_IMPLICIT RecordedPrepareShmem(S& aStream); 746 747 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 748 749 template <class S> 750 void Record(S& aStream) const; 751 752 std::string GetName() const final { return "RecordedPrepareShmem"; } 753 754 private: 755 RemoteTextureOwnerId mTextureOwnerId; 756 }; 757 758 inline bool RecordedPrepareShmem::PlayCanvasEvent( 759 CanvasTranslator* aTranslator) const { 760 aTranslator->PrepareShmem(mTextureOwnerId); 761 return true; 762 } 763 764 template <class S> 765 void RecordedPrepareShmem::Record(S& aStream) const { 766 WriteElement(aStream, mTextureOwnerId); 767 } 768 769 template <class S> 770 RecordedPrepareShmem::RecordedPrepareShmem(S& aStream) 771 : RecordedEventDerived(PREPARE_SHMEM) { 772 ReadElement(aStream, mTextureOwnerId); 773 } 774 775 class RecordedPresentTexture final 776 : public RecordedEventDerived<RecordedPresentTexture> { 777 public: 778 RecordedPresentTexture(const RemoteTextureOwnerId aTextureOwnerId, 779 RemoteTextureId aId) 780 : RecordedEventDerived(PRESENT_TEXTURE), 781 mTextureOwnerId(aTextureOwnerId), 782 mLastRemoteTextureId(aId) {} 783 784 template <class S> 785 MOZ_IMPLICIT RecordedPresentTexture(S& aStream); 786 787 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 788 789 template <class S> 790 void Record(S& aStream) const; 791 792 std::string GetName() const final { return "PresentTexture"; } 793 794 private: 795 RemoteTextureOwnerId mTextureOwnerId; 796 RemoteTextureId mLastRemoteTextureId; 797 }; 798 799 inline bool RecordedPresentTexture::PlayCanvasEvent( 800 CanvasTranslator* aTranslator) const { 801 if (!aTranslator->PresentTexture(mTextureOwnerId, mLastRemoteTextureId)) { 802 return false; 803 } 804 return true; 805 } 806 807 template <class S> 808 void RecordedPresentTexture::Record(S& aStream) const { 809 WriteElement(aStream, mTextureOwnerId); 810 WriteElement(aStream, mLastRemoteTextureId.mId); 811 } 812 813 template <class S> 814 RecordedPresentTexture::RecordedPresentTexture(S& aStream) 815 : RecordedEventDerived(PRESENT_TEXTURE) { 816 ReadElement(aStream, mTextureOwnerId); 817 ReadElement(aStream, mLastRemoteTextureId.mId); 818 } 819 820 class RecordedAddExportSurface final 821 : public RecordedEventDerived<RecordedAddExportSurface> { 822 public: 823 RecordedAddExportSurface(ReferencePtr aExportID, 824 const RefPtr<gfx::SourceSurface>& aActualSurface) 825 : RecordedEventDerived(ADD_EXPORT_SURFACE), 826 mExportID(aExportID), 827 mActualSurface(aActualSurface) {} 828 829 template <class S> 830 MOZ_IMPLICIT RecordedAddExportSurface(S& aStream); 831 832 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 833 834 template <class S> 835 void Record(S& aStream) const; 836 837 std::string GetName() const final { return "RecordedAddExportSurface"; } 838 839 private: 840 ReferencePtr mExportID; 841 ReferencePtr mActualSurface; 842 }; 843 844 inline bool RecordedAddExportSurface::PlayCanvasEvent( 845 CanvasTranslator* aTranslator) const { 846 RefPtr<gfx::SourceSurface> surface = 847 aTranslator->LookupSourceSurface(mActualSurface); 848 if (!surface) { 849 return false; 850 } 851 852 aTranslator->AddExportSurface(mExportID, surface); 853 return true; 854 } 855 856 template <class S> 857 void RecordedAddExportSurface::Record(S& aStream) const { 858 WriteElement(aStream, mExportID); 859 WriteElement(aStream, mActualSurface); 860 } 861 862 template <class S> 863 RecordedAddExportSurface::RecordedAddExportSurface(S& aStream) 864 : RecordedEventDerived(ADD_EXPORT_SURFACE) { 865 ReadElement(aStream, mExportID); 866 ReadElement(aStream, mActualSurface); 867 } 868 869 class RecordedRemoveExportSurface final 870 : public RecordedEventDerived<RecordedRemoveExportSurface> { 871 public: 872 explicit RecordedRemoveExportSurface(ReferencePtr aExportID) 873 : RecordedEventDerived(REMOVE_EXPORT_SURFACE), mExportID(aExportID) {} 874 875 template <class S> 876 MOZ_IMPLICIT RecordedRemoveExportSurface(S& aStream); 877 878 bool PlayCanvasEvent(CanvasTranslator* aTranslator) const; 879 880 template <class S> 881 void Record(S& aStream) const; 882 883 std::string GetName() const final { return "RecordedRemoveExportSurface"; } 884 885 private: 886 ReferencePtr mExportID; 887 }; 888 889 inline bool RecordedRemoveExportSurface::PlayCanvasEvent( 890 CanvasTranslator* aTranslator) const { 891 aTranslator->RemoveExportSurface(mExportID); 892 return true; 893 } 894 895 template <class S> 896 void RecordedRemoveExportSurface::Record(S& aStream) const { 897 WriteElement(aStream, mExportID); 898 } 899 900 template <class S> 901 RecordedRemoveExportSurface::RecordedRemoveExportSurface(S& aStream) 902 : RecordedEventDerived(REMOVE_EXPORT_SURFACE) { 903 ReadElement(aStream, mExportID); 904 } 905 906 #define FOR_EACH_CANVAS_EVENT(f) \ 907 f(CANVAS_BEGIN_TRANSACTION, RecordedCanvasBeginTransaction); \ 908 f(CANVAS_END_TRANSACTION, RecordedCanvasEndTransaction); \ 909 f(CANVAS_FLUSH, RecordedCanvasFlush); \ 910 f(TEXTURE_LOCK, RecordedTextureLock); \ 911 f(TEXTURE_UNLOCK, RecordedTextureUnlock); \ 912 f(CACHE_DATA_SURFACE, RecordedCacheDataSurface); \ 913 f(GET_DATA_FOR_SURFACE, RecordedGetDataForSurface); \ 914 f(ADD_SURFACE_ALIAS, RecordedAddSurfaceAlias); \ 915 f(REMOVE_SURFACE_ALIAS, RecordedRemoveSurfaceAlias); \ 916 f(CANVAS_DRAW_TARGET_CREATION, RecordedCanvasDrawTargetCreation); \ 917 f(TEXTURE_DESTRUCTION, RecordedTextureDestruction); \ 918 f(CHECKPOINT, RecordedCheckpoint); \ 919 f(PAUSE_TRANSLATION, RecordedPauseTranslation); \ 920 f(RECYCLE_BUFFER, RecordedRecycleBuffer); \ 921 f(DROP_BUFFER, RecordedDropBuffer); \ 922 f(PREPARE_SHMEM, RecordedPrepareShmem); \ 923 f(PRESENT_TEXTURE, RecordedPresentTexture); \ 924 f(DEVICE_RESET_ACKNOWLEDGED, RecordedDeviceResetAcknowledged); \ 925 f(AWAIT_TRANSLATION_SYNC, RecordedAwaitTranslationSync); \ 926 f(RESOLVE_EXTERNAL_SNAPSHOT, RecordedResolveExternalSnapshot); \ 927 f(ADD_EXPORT_SURFACE, RecordedAddExportSurface); \ 928 f(REMOVE_EXPORT_SURFACE, RecordedRemoveExportSurface); 929 930 } // namespace layers 931 } // namespace mozilla 932 933 #endif // mozilla_layers_RecordedCanvasEventImpl_h