gfx/layers/RecordedCanvasEventImpl.h

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