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/. */
7 #ifndef mozilla_layers_RecordedCanvasEventImpl_h
8 #define mozilla_layers_RecordedCanvasEventImpl_h
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"
19 using gfx::BackendType
;
20 using gfx::DrawTarget
;
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
;
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
;
52 class RecordedCanvasBeginTransaction final
53 : public RecordedEventDerived
<RecordedCanvasBeginTransaction
> {
55 RecordedCanvasBeginTransaction()
56 : RecordedEventDerived(CANVAS_BEGIN_TRANSACTION
) {}
59 MOZ_IMPLICIT
RecordedCanvasBeginTransaction(S
& aStream
);
61 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
64 void Record(S
& aStream
) const;
66 std::string
GetName() const final
{ return "RecordedCanvasBeginTransaction"; }
69 inline bool RecordedCanvasBeginTransaction::PlayCanvasEvent(
70 CanvasTranslator
* aTranslator
) const {
71 aTranslator
->BeginTransaction();
76 void RecordedCanvasBeginTransaction::Record(S
& aStream
) const {}
79 RecordedCanvasBeginTransaction::RecordedCanvasBeginTransaction(S
& aStream
)
80 : RecordedEventDerived(CANVAS_BEGIN_TRANSACTION
) {}
82 class RecordedCanvasEndTransaction final
83 : public RecordedEventDerived
<RecordedCanvasEndTransaction
> {
85 RecordedCanvasEndTransaction()
86 : RecordedEventDerived(CANVAS_END_TRANSACTION
) {}
89 MOZ_IMPLICIT
RecordedCanvasEndTransaction(S
& aStream
);
91 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
94 void Record(S
& aStream
) const;
96 std::string
GetName() const final
{ return "RecordedCanvasEndTransaction"; }
99 inline bool RecordedCanvasEndTransaction::PlayCanvasEvent(
100 CanvasTranslator
* aTranslator
) const {
101 aTranslator
->EndTransaction();
106 void RecordedCanvasEndTransaction::Record(S
& aStream
) const {}
109 RecordedCanvasEndTransaction::RecordedCanvasEndTransaction(S
& aStream
)
110 : RecordedEventDerived(CANVAS_END_TRANSACTION
) {}
112 class RecordedCanvasFlush final
113 : public RecordedEventDerived
<RecordedCanvasFlush
> {
115 RecordedCanvasFlush() : RecordedEventDerived(CANVAS_FLUSH
) {}
118 MOZ_IMPLICIT
RecordedCanvasFlush(S
& aStream
);
120 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
123 void Record(S
& aStream
) const;
125 std::string
GetName() const final
{ return "RecordedCanvasFlush"; }
128 inline bool RecordedCanvasFlush::PlayCanvasEvent(
129 CanvasTranslator
* aTranslator
) const {
130 aTranslator
->Flush();
135 void RecordedCanvasFlush::Record(S
& aStream
) const {}
138 RecordedCanvasFlush::RecordedCanvasFlush(S
& aStream
)
139 : RecordedEventDerived(CANVAS_FLUSH
) {}
141 class RecordedTextureLock final
142 : public RecordedEventDerived
<RecordedTextureLock
> {
144 RecordedTextureLock(int64_t aTextureId
, const OpenMode aMode
,
145 bool aInvalidContents
)
146 : RecordedEventDerived(TEXTURE_LOCK
),
147 mTextureId(aTextureId
),
149 mInvalidContents(aInvalidContents
) {}
152 MOZ_IMPLICIT
RecordedTextureLock(S
& aStream
);
154 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
157 void Record(S
& aStream
) const;
159 std::string
GetName() const final
{ return "TextureLock"; }
164 bool mInvalidContents
;
167 inline bool RecordedTextureLock::PlayCanvasEvent(
168 CanvasTranslator
* aTranslator
) const {
169 if (!aTranslator
->LockTexture(mTextureId
, mMode
, mInvalidContents
)) {
176 void RecordedTextureLock::Record(S
& aStream
) const {
177 WriteElement(aStream
, mTextureId
);
178 WriteElement(aStream
, mMode
);
179 WriteElement(aStream
, mInvalidContents
);
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
);
191 class RecordedTextureUnlock final
192 : public RecordedEventDerived
<RecordedTextureUnlock
> {
194 explicit RecordedTextureUnlock(int64_t aTextureId
)
195 : RecordedEventDerived(TEXTURE_UNLOCK
), mTextureId(aTextureId
) {}
198 MOZ_IMPLICIT
RecordedTextureUnlock(S
& aStream
);
200 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
203 void Record(S
& aStream
) const;
205 std::string
GetName() const final
{ return "TextureUnlock"; }
211 inline bool RecordedTextureUnlock::PlayCanvasEvent(
212 CanvasTranslator
* aTranslator
) const {
213 if (!aTranslator
->UnlockTexture(mTextureId
)) {
220 void RecordedTextureUnlock::Record(S
& aStream
) const {
221 WriteElement(aStream
, mTextureId
);
225 RecordedTextureUnlock::RecordedTextureUnlock(S
& aStream
)
226 : RecordedEventDerived(TEXTURE_UNLOCK
) {
227 ReadElement(aStream
, mTextureId
);
230 class RecordedCacheDataSurface final
231 : public RecordedEventDerived
<RecordedCacheDataSurface
> {
233 explicit RecordedCacheDataSurface(gfx::SourceSurface
* aSurface
)
234 : RecordedEventDerived(CACHE_DATA_SURFACE
), mSurface(aSurface
) {}
237 MOZ_IMPLICIT
RecordedCacheDataSurface(S
& aStream
);
239 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
242 void Record(S
& aStream
) const;
244 std::string
GetName() const final
{ return "RecordedCacheDataSurface"; }
247 ReferencePtr mSurface
;
250 inline bool RecordedCacheDataSurface::PlayCanvasEvent(
251 CanvasTranslator
* aTranslator
) const {
252 gfx::SourceSurface
* surface
= aTranslator
->LookupSourceSurface(mSurface
);
257 RefPtr
<gfx::DataSourceSurface
> dataSurface
= surface
->GetDataSurface();
259 aTranslator
->AddDataSurface(mSurface
, std::move(dataSurface
));
264 void RecordedCacheDataSurface::Record(S
& aStream
) const {
265 WriteElement(aStream
, mSurface
);
269 RecordedCacheDataSurface::RecordedCacheDataSurface(S
& aStream
)
270 : RecordedEventDerived(CACHE_DATA_SURFACE
) {
271 ReadElement(aStream
, mSurface
);
274 class RecordedPrepareDataForSurface final
275 : public RecordedEventDerived
<RecordedPrepareDataForSurface
> {
277 explicit RecordedPrepareDataForSurface(const gfx::SourceSurface
* aSurface
)
278 : RecordedEventDerived(PREPARE_DATA_FOR_SURFACE
), mSurface(aSurface
) {}
281 MOZ_IMPLICIT
RecordedPrepareDataForSurface(S
& aStream
);
283 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
286 void Record(S
& aStream
) const;
288 std::string
GetName() const final
{ return "RecordedPrepareDataForSurface"; }
291 ReferencePtr mSurface
;
294 inline bool RecordedPrepareDataForSurface::PlayCanvasEvent(
295 CanvasTranslator
* aTranslator
) const {
296 RefPtr
<gfx::DataSourceSurface
> dataSurface
=
297 aTranslator
->LookupDataSurface(mSurface
);
299 gfx::SourceSurface
* surface
= aTranslator
->LookupSourceSurface(mSurface
);
304 dataSurface
= surface
->GetDataSurface();
310 auto preparedMap
= MakeUnique
<gfx::DataSourceSurface::ScopedMap
>(
311 dataSurface
, gfx::DataSourceSurface::READ
);
312 if (!preparedMap
->IsMapped()) {
316 aTranslator
->SetPreparedMap(mSurface
, std::move(preparedMap
));
322 void RecordedPrepareDataForSurface::Record(S
& aStream
) const {
323 WriteElement(aStream
, mSurface
);
327 RecordedPrepareDataForSurface::RecordedPrepareDataForSurface(S
& aStream
)
328 : RecordedEventDerived(PREPARE_DATA_FOR_SURFACE
) {
329 ReadElement(aStream
, mSurface
);
332 class RecordedGetDataForSurface final
333 : public RecordedEventDerived
<RecordedGetDataForSurface
> {
335 explicit RecordedGetDataForSurface(const gfx::SourceSurface
* aSurface
)
336 : RecordedEventDerived(GET_DATA_FOR_SURFACE
), mSurface(aSurface
) {}
339 MOZ_IMPLICIT
RecordedGetDataForSurface(S
& aStream
);
341 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
344 void Record(S
& aStream
) const;
346 std::string
GetName() const final
{ return "RecordedGetDataForSurface"; }
349 ReferencePtr mSurface
;
352 inline bool RecordedGetDataForSurface::PlayCanvasEvent(
353 CanvasTranslator
* aTranslator
) const {
354 aTranslator
->GetDataSurface(mSurface
.mLongPtr
);
359 void RecordedGetDataForSurface::Record(S
& aStream
) const {
360 WriteElement(aStream
, mSurface
);
364 RecordedGetDataForSurface::RecordedGetDataForSurface(S
& aStream
)
365 : RecordedEventDerived(GET_DATA_FOR_SURFACE
) {
366 ReadElement(aStream
, mSurface
);
369 class RecordedAddSurfaceAlias final
370 : public RecordedEventDerived
<RecordedAddSurfaceAlias
> {
372 RecordedAddSurfaceAlias(ReferencePtr aSurfaceAlias
,
373 const RefPtr
<gfx::SourceSurface
>& aActualSurface
)
374 : RecordedEventDerived(ADD_SURFACE_ALIAS
),
375 mSurfaceAlias(aSurfaceAlias
),
376 mActualSurface(aActualSurface
) {}
379 MOZ_IMPLICIT
RecordedAddSurfaceAlias(S
& aStream
);
381 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
384 void Record(S
& aStream
) const;
386 std::string
GetName() const final
{ return "RecordedAddSurfaceAlias"; }
389 ReferencePtr mSurfaceAlias
;
390 ReferencePtr mActualSurface
;
393 inline bool RecordedAddSurfaceAlias::PlayCanvasEvent(
394 CanvasTranslator
* aTranslator
) const {
395 RefPtr
<gfx::SourceSurface
> surface
=
396 aTranslator
->LookupSourceSurface(mActualSurface
);
401 aTranslator
->AddSourceSurface(mSurfaceAlias
, surface
);
406 void RecordedAddSurfaceAlias::Record(S
& aStream
) const {
407 WriteElement(aStream
, mSurfaceAlias
);
408 WriteElement(aStream
, mActualSurface
);
412 RecordedAddSurfaceAlias::RecordedAddSurfaceAlias(S
& aStream
)
413 : RecordedEventDerived(ADD_SURFACE_ALIAS
) {
414 ReadElement(aStream
, mSurfaceAlias
);
415 ReadElement(aStream
, mActualSurface
);
418 class RecordedRemoveSurfaceAlias final
419 : public RecordedEventDerived
<RecordedRemoveSurfaceAlias
> {
421 explicit RecordedRemoveSurfaceAlias(ReferencePtr aSurfaceAlias
)
422 : RecordedEventDerived(REMOVE_SURFACE_ALIAS
),
423 mSurfaceAlias(aSurfaceAlias
) {}
426 MOZ_IMPLICIT
RecordedRemoveSurfaceAlias(S
& aStream
);
428 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
431 void Record(S
& aStream
) const;
433 std::string
GetName() const final
{ return "RecordedRemoveSurfaceAlias"; }
436 ReferencePtr mSurfaceAlias
;
439 inline bool RecordedRemoveSurfaceAlias::PlayCanvasEvent(
440 CanvasTranslator
* aTranslator
) const {
441 aTranslator
->RemoveSourceSurface(mSurfaceAlias
);
446 void RecordedRemoveSurfaceAlias::Record(S
& aStream
) const {
447 WriteElement(aStream
, mSurfaceAlias
);
451 RecordedRemoveSurfaceAlias::RecordedRemoveSurfaceAlias(S
& aStream
)
452 : RecordedEventDerived(REMOVE_SURFACE_ALIAS
) {
453 ReadElement(aStream
, mSurfaceAlias
);
456 class RecordedDeviceChangeAcknowledged final
457 : public RecordedEventDerived
<RecordedDeviceChangeAcknowledged
> {
459 RecordedDeviceChangeAcknowledged()
460 : RecordedEventDerived(DEVICE_CHANGE_ACKNOWLEDGED
) {}
463 MOZ_IMPLICIT
RecordedDeviceChangeAcknowledged(S
& aStream
);
465 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
468 void Record(S
& aStream
) const;
470 std::string
GetName() const final
{
471 return "RecordedDeviceChangeAcknowledged";
475 inline bool RecordedDeviceChangeAcknowledged::PlayCanvasEvent(
476 CanvasTranslator
* aTranslator
) const {
477 aTranslator
->DeviceChangeAcknowledged();
482 void RecordedDeviceChangeAcknowledged::Record(S
& aStream
) const {}
485 RecordedDeviceChangeAcknowledged::RecordedDeviceChangeAcknowledged(S
& aStream
)
486 : RecordedEventDerived(DEVICE_CHANGE_ACKNOWLEDGED
) {}
488 class RecordedCanvasDrawTargetCreation final
489 : public RecordedEventDerived
<RecordedCanvasDrawTargetCreation
> {
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
),
497 mTextureId(aTextureId
),
498 mTextureOwnerId(aTextureOwnerId
),
504 MOZ_IMPLICIT
RecordedCanvasDrawTargetCreation(S
& aStream
);
506 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
509 void Record(S
& aStream
) const;
511 std::string
GetName() const final
{ return "Canvas DrawTarget Creation"; }
513 ReferencePtr mRefPtr
;
514 int64_t mTextureId
= -1;
515 RemoteTextureOwnerId mTextureOwnerId
;
516 BackendType mBackendType
= BackendType::NONE
;
518 SurfaceFormat mFormat
= SurfaceFormat::UNKNOWN
;
521 inline bool RecordedCanvasDrawTargetCreation::PlayCanvasEvent(
522 CanvasTranslator
* aTranslator
) const {
523 RefPtr
<DrawTarget
> newDT
= aTranslator
->CreateDrawTarget(
524 mRefPtr
, mTextureId
, mTextureOwnerId
, mSize
, mFormat
);
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.
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
);
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
);
554 class RecordedTextureDestruction final
555 : public RecordedEventDerived
<RecordedTextureDestruction
> {
557 RecordedTextureDestruction(int64_t aTextureId
, RemoteTextureTxnType aTxnType
,
558 RemoteTextureTxnId aTxnId
)
559 : RecordedEventDerived(TEXTURE_DESTRUCTION
),
560 mTextureId(aTextureId
),
565 MOZ_IMPLICIT
RecordedTextureDestruction(S
& aStream
);
567 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
570 void Record(S
& aStream
) const;
572 std::string
GetName() const final
{ return "RecordedTextureDestruction"; }
575 int64_t mTextureId
= 0;
576 RemoteTextureTxnType mTxnType
= 0;
577 RemoteTextureTxnId mTxnId
= 0;
580 inline bool RecordedTextureDestruction::PlayCanvasEvent(
581 CanvasTranslator
* aTranslator
) const {
582 aTranslator
->RemoveTexture(mTextureId
, mTxnType
, mTxnId
);
587 void RecordedTextureDestruction::Record(S
& aStream
) const {
588 WriteElement(aStream
, mTextureId
);
589 WriteElement(aStream
, mTxnType
);
590 WriteElement(aStream
, mTxnId
);
594 RecordedTextureDestruction::RecordedTextureDestruction(S
& aStream
)
595 : RecordedEventDerived(TEXTURE_DESTRUCTION
) {
596 ReadElement(aStream
, mTextureId
);
597 ReadElement(aStream
, mTxnType
);
598 ReadElement(aStream
, mTxnId
);
601 class RecordedCheckpoint final
602 : public RecordedEventDerived
<RecordedCheckpoint
> {
604 RecordedCheckpoint() : RecordedEventDerived(CHECKPOINT
) {}
607 MOZ_IMPLICIT
RecordedCheckpoint(S
& aStream
)
608 : RecordedEventDerived(CHECKPOINT
) {}
610 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const {
611 aTranslator
->CheckpointReached();
616 void Record(S
& aStream
) const {}
618 std::string
GetName() const final
{ return "RecordedCheckpoint"; }
621 class RecordedPauseTranslation final
622 : public RecordedEventDerived
<RecordedPauseTranslation
> {
624 RecordedPauseTranslation() : RecordedEventDerived(PAUSE_TRANSLATION
) {}
627 MOZ_IMPLICIT
RecordedPauseTranslation(S
& aStream
)
628 : RecordedEventDerived(PAUSE_TRANSLATION
) {}
630 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const {
631 aTranslator
->PauseTranslation();
636 void Record(S
& aStream
) const {}
638 std::string
GetName() const final
{ return "RecordedPauseTranslation"; }
641 class RecordedRecycleBuffer final
642 : public RecordedEventDerived
<RecordedRecycleBuffer
> {
644 RecordedRecycleBuffer() : RecordedEventDerived(RECYCLE_BUFFER
) {}
647 MOZ_IMPLICIT
RecordedRecycleBuffer(S
& aStream
)
648 : RecordedEventDerived(RECYCLE_BUFFER
) {}
650 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const {
651 aTranslator
->RecycleBuffer();
656 void Record(S
& aStream
) const {}
658 std::string
GetName() const final
{ return "RecordedNextBuffer"; }
661 class RecordedDropBuffer final
662 : public RecordedEventDerived
<RecordedDropBuffer
> {
664 RecordedDropBuffer() : RecordedEventDerived(DROP_BUFFER
) {}
667 MOZ_IMPLICIT
RecordedDropBuffer(S
& aStream
)
668 : RecordedEventDerived(DROP_BUFFER
) {}
670 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const {
671 // Use the next buffer without recycling which drops the current buffer.
672 aTranslator
->NextBuffer();
677 void Record(S
& aStream
) const {}
679 std::string
GetName() const final
{ return "RecordedDropAndMoveNextBuffer"; }
682 class RecordedPrepareShmem final
683 : public RecordedEventDerived
<RecordedPrepareShmem
> {
685 explicit RecordedPrepareShmem(int64_t aTextureId
)
686 : RecordedEventDerived(PREPARE_SHMEM
), mTextureId(aTextureId
) {}
689 MOZ_IMPLICIT
RecordedPrepareShmem(S
& aStream
);
691 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
694 void Record(S
& aStream
) const;
696 std::string
GetName() const final
{ return "RecordedPrepareShmem"; }
699 int64_t mTextureId
= 0;
702 inline bool RecordedPrepareShmem::PlayCanvasEvent(
703 CanvasTranslator
* aTranslator
) const {
704 aTranslator
->PrepareShmem(mTextureId
);
709 void RecordedPrepareShmem::Record(S
& aStream
) const {
710 WriteElement(aStream
, mTextureId
);
714 RecordedPrepareShmem::RecordedPrepareShmem(S
& aStream
)
715 : RecordedEventDerived(PREPARE_SHMEM
) {
716 ReadElement(aStream
, mTextureId
);
719 class RecordedPresentTexture final
720 : public RecordedEventDerived
<RecordedPresentTexture
> {
722 RecordedPresentTexture(int64_t aTextureId
, RemoteTextureId aId
)
723 : RecordedEventDerived(PRESENT_TEXTURE
),
724 mTextureId(aTextureId
),
725 mLastRemoteTextureId(aId
) {}
728 MOZ_IMPLICIT
RecordedPresentTexture(S
& aStream
);
730 bool PlayCanvasEvent(CanvasTranslator
* aTranslator
) const;
733 void Record(S
& aStream
) const;
735 std::string
GetName() const final
{ return "PresentTexture"; }
739 RemoteTextureId mLastRemoteTextureId
;
742 inline bool RecordedPresentTexture::PlayCanvasEvent(
743 CanvasTranslator
* aTranslator
) const {
744 if (!aTranslator
->PresentTexture(mTextureId
, mLastRemoteTextureId
)) {
751 void RecordedPresentTexture::Record(S
& aStream
) const {
752 WriteElement(aStream
, mTextureId
);
753 WriteElement(aStream
, mLastRemoteTextureId
.mId
);
757 RecordedPresentTexture::RecordedPresentTexture(S
& aStream
)
758 : RecordedEventDerived(PRESENT_TEXTURE
) {
759 ReadElement(aStream
, mTextureId
);
760 ReadElement(aStream
, mLastRemoteTextureId
.mId
);
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);
784 } // namespace layers
785 } // namespace mozilla
787 #endif // mozilla_layers_RecordedCanvasEventImpl_h