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::DrawTarget;
  20 using gfx::IntSize;
  21 using gfx::RecordedEvent;
  22 using gfx::RecordedEventDerived;
  23 using EventType = gfx::RecordedEvent::EventType;
  24 using gfx::ReadElement;
  25 using gfx::ReferencePtr;
  26 using gfx::SurfaceFormat;
  27 using gfx::WriteElement;
  28 using ipc::SharedMemoryBasic;
  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 PREPARE_DATA_FOR_SURFACE = EventType(EventType::LAST + 6);
  37 const EventType GET_DATA_FOR_SURFACE = EventType(EventType::LAST + 7);
  38 const EventType ADD_SURFACE_ALIAS = EventType(EventType::LAST + 8);
  39 const EventType REMOVE_SURFACE_ALIAS = EventType(EventType::LAST + 9);
  40 const EventType DEVICE_CHANGE_ACKNOWLEDGED = EventType(EventType::LAST + 10);
  41 const EventType NEXT_TEXTURE_ID = EventType(EventType::LAST + 11);
  42 const EventType TEXTURE_DESTRUCTION = EventType(EventType::LAST + 12);
  43
  44 class RecordedCanvasBeginTransaction final
  45     : public RecordedEventDerived<RecordedCanvasBeginTransaction> {
  46  public:
  47   RecordedCanvasBeginTransaction()
  48       : RecordedEventDerived(CANVAS_BEGIN_TRANSACTION) {}
  49
  50   template <class S>
  51   MOZ_IMPLICIT RecordedCanvasBeginTransaction(S& aStream);
  52
  53   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
  54
  55   template <class S>
  56   void Record(S& aStream) const;
  57
  58   std::string GetName() const final { return "RecordedCanvasBeginTransaction"; }
  59 };
  60
  61 inline bool RecordedCanvasBeginTransaction::PlayCanvasEvent(
  62     CanvasTranslator* aTranslator) const {
  63   aTranslator->BeginTransaction();
  64   return true;
  65 }
  66
  67 template <class S>
  68 void RecordedCanvasBeginTransaction::Record(S& aStream) const {}
  69
  70 template <class S>
  71 RecordedCanvasBeginTransaction::RecordedCanvasBeginTransaction(S& aStream)
  72     : RecordedEventDerived(CANVAS_BEGIN_TRANSACTION) {}
  73
  74 class RecordedCanvasEndTransaction final
  75     : public RecordedEventDerived<RecordedCanvasEndTransaction> {
  76  public:
  77   RecordedCanvasEndTransaction()
  78       : RecordedEventDerived(CANVAS_END_TRANSACTION) {}
  79
  80   template <class S>
  81   MOZ_IMPLICIT RecordedCanvasEndTransaction(S& aStream);
  82
  83   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
  84
  85   template <class S>
  86   void Record(S& aStream) const;
  87
  88   std::string GetName() const final { return "RecordedCanvasEndTransaction"; }
  89 };
  90
  91 inline bool RecordedCanvasEndTransaction::PlayCanvasEvent(
  92     CanvasTranslator* aTranslator) const {
  93   aTranslator->EndTransaction();
  94   return true;
  95 }
  96
  97 template <class S>
  98 void RecordedCanvasEndTransaction::Record(S& aStream) const {}
  99
 100 template <class S>
 101 RecordedCanvasEndTransaction::RecordedCanvasEndTransaction(S& aStream)
 102     : RecordedEventDerived(CANVAS_END_TRANSACTION) {}
 103
 104 class RecordedCanvasFlush final
 105     : public RecordedEventDerived<RecordedCanvasFlush> {
 106  public:
 107   RecordedCanvasFlush() : RecordedEventDerived(CANVAS_FLUSH) {}
 108
 109   template <class S>
 110   MOZ_IMPLICIT RecordedCanvasFlush(S& aStream);
 111
 112   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 113
 114   template <class S>
 115   void Record(S& aStream) const;
 116
 117   std::string GetName() const final { return "RecordedCanvasFlush"; }
 118 };
 119
 120 inline bool RecordedCanvasFlush::PlayCanvasEvent(
 121     CanvasTranslator* aTranslator) const {
 122   aTranslator->Flush();
 123   return true;
 124 }
 125
 126 template <class S>
 127 void RecordedCanvasFlush::Record(S& aStream) const {}
 128
 129 template <class S>
 130 RecordedCanvasFlush::RecordedCanvasFlush(S& aStream)
 131     : RecordedEventDerived(CANVAS_FLUSH) {}
 132
 133 class RecordedTextureLock final
 134     : public RecordedEventDerived<RecordedTextureLock> {
 135  public:
 136   RecordedTextureLock(int64_t aTextureId, const OpenMode aMode)
 137       : RecordedEventDerived(TEXTURE_LOCK),
 138         mTextureId(aTextureId),
 139         mMode(aMode) {}
 140
 141   template <class S>
 142   MOZ_IMPLICIT RecordedTextureLock(S& aStream);
 143
 144   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 145
 146   template <class S>
 147   void Record(S& aStream) const;
 148
 149   std::string GetName() const final { return "TextureLock"; }
 150
 151  private:
 152   int64_t mTextureId;
 153   OpenMode mMode;
 154 };
 155
 156 inline bool RecordedTextureLock::PlayCanvasEvent(
 157     CanvasTranslator* aTranslator) const {
 158   TextureData* textureData = aTranslator->LookupTextureData(mTextureId);
 159   if (!textureData) {
 160     return false;
 161   }
 162
 163   textureData->Lock(mMode);
 164   return true;
 165 }
 166
 167 template <class S>
 168 void RecordedTextureLock::Record(S& aStream) const {
 169   WriteElement(aStream, mTextureId);
 170   WriteElement(aStream, mMode);
 171 }
 172
 173 template <class S>
 174 RecordedTextureLock::RecordedTextureLock(S& aStream)
 175     : RecordedEventDerived(TEXTURE_LOCK) {
 176   ReadElement(aStream, mTextureId);
 177   ReadElementConstrained(aStream, mMode, OpenMode::OPEN_NONE,
 178                          OpenMode::OPEN_READ_WRITE_ASYNC);
 179 }
 180
 181 class RecordedTextureUnlock final
 182     : public RecordedEventDerived<RecordedTextureUnlock> {
 183  public:
 184   explicit RecordedTextureUnlock(int64_t aTextureId)
 185       : RecordedEventDerived(TEXTURE_UNLOCK), mTextureId(aTextureId) {}
 186
 187   template <class S>
 188   MOZ_IMPLICIT RecordedTextureUnlock(S& aStream);
 189
 190   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 191
 192   template <class S>
 193   void Record(S& aStream) const;
 194
 195   std::string GetName() const final { return "TextureUnlock"; }
 196
 197  private:
 198   int64_t mTextureId;
 199 };
 200
 201 inline bool RecordedTextureUnlock::PlayCanvasEvent(
 202     CanvasTranslator* aTranslator) const {
 203   TextureData* textureData = aTranslator->LookupTextureData(mTextureId);
 204   if (!textureData) {
 205     return false;
 206   }
 207
 208   textureData->Unlock();
 209   return true;
 210 }
 211
 212 template <class S>
 213 void RecordedTextureUnlock::Record(S& aStream) const {
 214   WriteElement(aStream, mTextureId);
 215 }
 216
 217 template <class S>
 218 RecordedTextureUnlock::RecordedTextureUnlock(S& aStream)
 219     : RecordedEventDerived(TEXTURE_UNLOCK) {
 220   ReadElement(aStream, mTextureId);
 221 }
 222
 223 class RecordedCacheDataSurface final
 224     : public RecordedEventDerived<RecordedCacheDataSurface> {
 225  public:
 226   explicit RecordedCacheDataSurface(gfx::SourceSurface* aSurface)
 227       : RecordedEventDerived(CACHE_DATA_SURFACE), mSurface(aSurface) {}
 228
 229   template <class S>
 230   MOZ_IMPLICIT RecordedCacheDataSurface(S& aStream);
 231
 232   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 233
 234   template <class S>
 235   void Record(S& aStream) const;
 236
 237   std::string GetName() const final { return "RecordedCacheDataSurface"; }
 238
 239  private:
 240   ReferencePtr mSurface;
 241 };
 242
 243 inline bool RecordedCacheDataSurface::PlayCanvasEvent(
 244     CanvasTranslator* aTranslator) const {
 245   gfx::SourceSurface* surface = aTranslator->LookupSourceSurface(mSurface);
 246   if (!surface) {
 247     return false;
 248   }
 249
 250   RefPtr<gfx::DataSourceSurface> dataSurface = surface->GetDataSurface();
 251
 252   aTranslator->AddDataSurface(mSurface, std::move(dataSurface));
 253   return true;
 254 }
 255
 256 template <class S>
 257 void RecordedCacheDataSurface::Record(S& aStream) const {
 258   WriteElement(aStream, mSurface);
 259 }
 260
 261 template <class S>
 262 RecordedCacheDataSurface::RecordedCacheDataSurface(S& aStream)
 263     : RecordedEventDerived(CACHE_DATA_SURFACE) {
 264   ReadElement(aStream, mSurface);
 265 }
 266
 267 class RecordedPrepareDataForSurface final
 268     : public RecordedEventDerived<RecordedPrepareDataForSurface> {
 269  public:
 270   explicit RecordedPrepareDataForSurface(const gfx::SourceSurface* aSurface)
 271       : RecordedEventDerived(PREPARE_DATA_FOR_SURFACE), mSurface(aSurface) {}
 272
 273   template <class S>
 274   MOZ_IMPLICIT RecordedPrepareDataForSurface(S& aStream);
 275
 276   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 277
 278   template <class S>
 279   void Record(S& aStream) const;
 280
 281   std::string GetName() const final { return "RecordedPrepareDataForSurface"; }
 282
 283  private:
 284   ReferencePtr mSurface;
 285 };
 286
 287 inline bool RecordedPrepareDataForSurface::PlayCanvasEvent(
 288     CanvasTranslator* aTranslator) const {
 289   RefPtr<gfx::DataSourceSurface> dataSurface =
 290       aTranslator->LookupDataSurface(mSurface);
 291   if (!dataSurface) {
 292     gfx::SourceSurface* surface = aTranslator->LookupSourceSurface(mSurface);
 293     if (!surface) {
 294       return false;
 295     }
 296
 297     dataSurface = surface->GetDataSurface();
 298     if (!dataSurface) {
 299       return false;
 300     }
 301   }
 302
 303   auto preparedMap = MakeUnique<gfx::DataSourceSurface::ScopedMap>(
 304       dataSurface, gfx::DataSourceSurface::READ);
 305   if (!preparedMap->IsMapped()) {
 306     return false;
 307   }
 308
 309   aTranslator->SetPreparedMap(mSurface, std::move(preparedMap));
 310
 311   return true;
 312 }
 313
 314 template <class S>
 315 void RecordedPrepareDataForSurface::Record(S& aStream) const {
 316   WriteElement(aStream, mSurface);
 317 }
 318
 319 template <class S>
 320 RecordedPrepareDataForSurface::RecordedPrepareDataForSurface(S& aStream)
 321     : RecordedEventDerived(PREPARE_DATA_FOR_SURFACE) {
 322   ReadElement(aStream, mSurface);
 323 }
 324
 325 class RecordedGetDataForSurface final
 326     : public RecordedEventDerived<RecordedGetDataForSurface> {
 327  public:
 328   explicit RecordedGetDataForSurface(const gfx::SourceSurface* aSurface)
 329       : RecordedEventDerived(GET_DATA_FOR_SURFACE), mSurface(aSurface) {}
 330
 331   template <class S>
 332   MOZ_IMPLICIT RecordedGetDataForSurface(S& aStream);
 333
 334   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 335
 336   template <class S>
 337   void Record(S& aStream) const;
 338
 339   std::string GetName() const final { return "RecordedGetDataForSurface"; }
 340
 341  private:
 342   ReferencePtr mSurface;
 343 };
 344
 345 inline bool RecordedGetDataForSurface::PlayCanvasEvent(
 346     CanvasTranslator* aTranslator) const {
 347   gfx::SourceSurface* surface = aTranslator->LookupSourceSurface(mSurface);
 348   if (!surface) {
 349     return false;
 350   }
 351
 352   UniquePtr<gfx::DataSourceSurface::ScopedMap> map =
 353       aTranslator->GetPreparedMap(mSurface);
 354   if (!map) {
 355     return false;
 356   }
 357
 358   int32_t dataFormatWidth =
 359       surface->GetSize().width * BytesPerPixel(surface->GetFormat());
 360   int32_t srcStride = map->GetStride();
 361   if (dataFormatWidth > srcStride) {
 362     return false;
 363   }
 364
 365   char* src = reinterpret_cast<char*>(map->GetData());
 366   char* endSrc = src + (map->GetSurface()->GetSize().height * srcStride);
 367   while (src < endSrc) {
 368     aTranslator->ReturnWrite(src, dataFormatWidth);
 369     src += srcStride;
 370   }
 371
 372   return true;
 373 }
 374
 375 template <class S>
 376 void RecordedGetDataForSurface::Record(S& aStream) const {
 377   WriteElement(aStream, mSurface);
 378 }
 379
 380 template <class S>
 381 RecordedGetDataForSurface::RecordedGetDataForSurface(S& aStream)
 382     : RecordedEventDerived(GET_DATA_FOR_SURFACE) {
 383   ReadElement(aStream, mSurface);
 384 }
 385
 386 class RecordedAddSurfaceAlias final
 387     : public RecordedEventDerived<RecordedAddSurfaceAlias> {
 388  public:
 389   RecordedAddSurfaceAlias(ReferencePtr aSurfaceAlias,
 390                           const RefPtr<gfx::SourceSurface>& aActualSurface)
 391       : RecordedEventDerived(ADD_SURFACE_ALIAS),
 392         mSurfaceAlias(aSurfaceAlias),
 393         mActualSurface(aActualSurface) {}
 394
 395   template <class S>
 396   MOZ_IMPLICIT RecordedAddSurfaceAlias(S& aStream);
 397
 398   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 399
 400   template <class S>
 401   void Record(S& aStream) const;
 402
 403   std::string GetName() const final { return "RecordedAddSurfaceAlias"; }
 404
 405  private:
 406   ReferencePtr mSurfaceAlias;
 407   ReferencePtr mActualSurface;
 408 };
 409
 410 inline bool RecordedAddSurfaceAlias::PlayCanvasEvent(
 411     CanvasTranslator* aTranslator) const {
 412   RefPtr<gfx::SourceSurface> surface =
 413       aTranslator->LookupSourceSurface(mActualSurface);
 414   if (!surface) {
 415     return false;
 416   }
 417
 418   aTranslator->AddSourceSurface(mSurfaceAlias, surface);
 419   return true;
 420 }
 421
 422 template <class S>
 423 void RecordedAddSurfaceAlias::Record(S& aStream) const {
 424   WriteElement(aStream, mSurfaceAlias);
 425   WriteElement(aStream, mActualSurface);
 426 }
 427
 428 template <class S>
 429 RecordedAddSurfaceAlias::RecordedAddSurfaceAlias(S& aStream)
 430     : RecordedEventDerived(ADD_SURFACE_ALIAS) {
 431   ReadElement(aStream, mSurfaceAlias);
 432   ReadElement(aStream, mActualSurface);
 433 }
 434
 435 class RecordedRemoveSurfaceAlias final
 436     : public RecordedEventDerived<RecordedRemoveSurfaceAlias> {
 437  public:
 438   explicit RecordedRemoveSurfaceAlias(ReferencePtr aSurfaceAlias)
 439       : RecordedEventDerived(REMOVE_SURFACE_ALIAS),
 440         mSurfaceAlias(aSurfaceAlias) {}
 441
 442   template <class S>
 443   MOZ_IMPLICIT RecordedRemoveSurfaceAlias(S& aStream);
 444
 445   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 446
 447   template <class S>
 448   void Record(S& aStream) const;
 449
 450   std::string GetName() const final { return "RecordedRemoveSurfaceAlias"; }
 451
 452  private:
 453   ReferencePtr mSurfaceAlias;
 454 };
 455
 456 inline bool RecordedRemoveSurfaceAlias::PlayCanvasEvent(
 457     CanvasTranslator* aTranslator) const {
 458   aTranslator->RemoveSourceSurface(mSurfaceAlias);
 459   return true;
 460 }
 461
 462 template <class S>
 463 void RecordedRemoveSurfaceAlias::Record(S& aStream) const {
 464   WriteElement(aStream, mSurfaceAlias);
 465 }
 466
 467 template <class S>
 468 RecordedRemoveSurfaceAlias::RecordedRemoveSurfaceAlias(S& aStream)
 469     : RecordedEventDerived(REMOVE_SURFACE_ALIAS) {
 470   ReadElement(aStream, mSurfaceAlias);
 471 }
 472
 473 class RecordedDeviceChangeAcknowledged final
 474     : public RecordedEventDerived<RecordedDeviceChangeAcknowledged> {
 475  public:
 476   RecordedDeviceChangeAcknowledged()
 477       : RecordedEventDerived(DEVICE_CHANGE_ACKNOWLEDGED) {}
 478
 479   template <class S>
 480   MOZ_IMPLICIT RecordedDeviceChangeAcknowledged(S& aStream);
 481
 482   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 483
 484   template <class S>
 485   void Record(S& aStream) const;
 486
 487   std::string GetName() const final {
 488     return "RecordedDeviceChangeAcknowledged";
 489   }
 490 };
 491
 492 inline bool RecordedDeviceChangeAcknowledged::PlayCanvasEvent(
 493     CanvasTranslator* aTranslator) const {
 494   aTranslator->DeviceChangeAcknowledged();
 495   return true;
 496 }
 497
 498 template <class S>
 499 void RecordedDeviceChangeAcknowledged::Record(S& aStream) const {}
 500
 501 template <class S>
 502 RecordedDeviceChangeAcknowledged::RecordedDeviceChangeAcknowledged(S& aStream)
 503     : RecordedEventDerived(DEVICE_CHANGE_ACKNOWLEDGED) {}
 504
 505 class RecordedNextTextureId final
 506     : public RecordedEventDerived<RecordedNextTextureId> {
 507  public:
 508   explicit RecordedNextTextureId(int64_t aNextTextureId)
 509       : RecordedEventDerived(NEXT_TEXTURE_ID), mNextTextureId(aNextTextureId) {}
 510
 511   template <class S>
 512   MOZ_IMPLICIT RecordedNextTextureId(S& aStream);
 513
 514   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 515
 516   template <class S>
 517   void Record(S& aStream) const;
 518
 519   std::string GetName() const final { return "RecordedNextTextureId"; }
 520
 521  private:
 522   int64_t mNextTextureId;
 523 };
 524
 525 inline bool RecordedNextTextureId::PlayCanvasEvent(
 526     CanvasTranslator* aTranslator) const {
 527   aTranslator->SetNextTextureId(mNextTextureId);
 528   return true;
 529 }
 530
 531 template <class S>
 532 void RecordedNextTextureId::Record(S& aStream) const {
 533   WriteElement(aStream, mNextTextureId);
 534 }
 535
 536 template <class S>
 537 RecordedNextTextureId::RecordedNextTextureId(S& aStream)
 538     : RecordedEventDerived(NEXT_TEXTURE_ID) {
 539   ReadElement(aStream, mNextTextureId);
 540 }
 541
 542 class RecordedTextureDestruction final
 543     : public RecordedEventDerived<RecordedTextureDestruction> {
 544  public:
 545   explicit RecordedTextureDestruction(int64_t aTextureId)
 546       : RecordedEventDerived(TEXTURE_DESTRUCTION), mTextureId(aTextureId) {}
 547
 548   template <class S>
 549   MOZ_IMPLICIT RecordedTextureDestruction(S& aStream);
 550
 551   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 552
 553   template <class S>
 554   void Record(S& aStream) const;
 555
 556   std::string GetName() const final { return "RecordedTextureDestruction"; }
 557
 558  private:
 559   int64_t mTextureId;
 560 };
 561
 562 inline bool RecordedTextureDestruction::PlayCanvasEvent(
 563     CanvasTranslator* aTranslator) const {
 564   aTranslator->RemoveTexture(mTextureId);
 565   return true;
 566 }
 567
 568 template <class S>
 569 void RecordedTextureDestruction::Record(S& aStream) const {
 570   WriteElement(aStream, mTextureId);
 571 }
 572
 573 template <class S>
 574 RecordedTextureDestruction::RecordedTextureDestruction(S& aStream)
 575     : RecordedEventDerived(TEXTURE_DESTRUCTION) {
 576   ReadElement(aStream, mTextureId);
 577 }
 578
 579 #define FOR_EACH_CANVAS_EVENT(f)                                   \
 580   f(CANVAS_BEGIN_TRANSACTION, RecordedCanvasBeginTransaction);     \
 581   f(CANVAS_END_TRANSACTION, RecordedCanvasEndTransaction);         \
 582   f(CANVAS_FLUSH, RecordedCanvasFlush);                            \
 583   f(TEXTURE_LOCK, RecordedTextureLock);                            \
 584   f(TEXTURE_UNLOCK, RecordedTextureUnlock);                        \
 585   f(CACHE_DATA_SURFACE, RecordedCacheDataSurface);                 \
 586   f(PREPARE_DATA_FOR_SURFACE, RecordedPrepareDataForSurface);      \
 587   f(GET_DATA_FOR_SURFACE, RecordedGetDataForSurface);              \
 588   f(ADD_SURFACE_ALIAS, RecordedAddSurfaceAlias);                   \
 589   f(REMOVE_SURFACE_ALIAS, RecordedRemoveSurfaceAlias);             \
 590   f(DEVICE_CHANGE_ACKNOWLEDGED, RecordedDeviceChangeAcknowledged); \
 591   f(NEXT_TEXTURE_ID, RecordedNextTextureId);                       \
 592   f(TEXTURE_DESTRUCTION, RecordedTextureDestruction);
 593
 594 }  // namespace layers
 595 }  // namespace mozilla
 596
 597 #endif  // mozilla_layers_RecordedCanvasEventImpl_h