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   gfx::AutoSerializeWithMoz2D serializeWithMoz2D(aTranslator->GetBackendType());
 164   textureData->Lock(mMode);
 165   return true;
 166 }
 167
 168 template <class S>
 169 void RecordedTextureLock::Record(S& aStream) const {
 170   WriteElement(aStream, mTextureId);
 171   WriteElement(aStream, mMode);
 172 }
 173
 174 template <class S>
 175 RecordedTextureLock::RecordedTextureLock(S& aStream)
 176     : RecordedEventDerived(TEXTURE_LOCK) {
 177   ReadElement(aStream, mTextureId);
 178   ReadElementConstrained(aStream, mMode, OpenMode::OPEN_NONE,
 179                          OpenMode::OPEN_READ_WRITE_ASYNC);
 180 }
 181
 182 class RecordedTextureUnlock final
 183     : public RecordedEventDerived<RecordedTextureUnlock> {
 184  public:
 185   explicit RecordedTextureUnlock(int64_t aTextureId)
 186       : RecordedEventDerived(TEXTURE_UNLOCK), mTextureId(aTextureId) {}
 187
 188   template <class S>
 189   MOZ_IMPLICIT RecordedTextureUnlock(S& aStream);
 190
 191   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 192
 193   template <class S>
 194   void Record(S& aStream) const;
 195
 196   std::string GetName() const final { return "TextureUnlock"; }
 197
 198  private:
 199   int64_t mTextureId;
 200 };
 201
 202 inline bool RecordedTextureUnlock::PlayCanvasEvent(
 203     CanvasTranslator* aTranslator) const {
 204   TextureData* textureData = aTranslator->LookupTextureData(mTextureId);
 205   if (!textureData) {
 206     return false;
 207   }
 208
 209   gfx::AutoSerializeWithMoz2D serializeWithMoz2D(aTranslator->GetBackendType());
 210   textureData->Unlock();
 211   return true;
 212 }
 213
 214 template <class S>
 215 void RecordedTextureUnlock::Record(S& aStream) const {
 216   WriteElement(aStream, mTextureId);
 217 }
 218
 219 template <class S>
 220 RecordedTextureUnlock::RecordedTextureUnlock(S& aStream)
 221     : RecordedEventDerived(TEXTURE_UNLOCK) {
 222   ReadElement(aStream, mTextureId);
 223 }
 224
 225 class RecordedCacheDataSurface final
 226     : public RecordedEventDerived<RecordedCacheDataSurface> {
 227  public:
 228   explicit RecordedCacheDataSurface(gfx::SourceSurface* aSurface)
 229       : RecordedEventDerived(CACHE_DATA_SURFACE), mSurface(aSurface) {}
 230
 231   template <class S>
 232   MOZ_IMPLICIT RecordedCacheDataSurface(S& aStream);
 233
 234   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 235
 236   template <class S>
 237   void Record(S& aStream) const;
 238
 239   std::string GetName() const final { return "RecordedCacheDataSurface"; }
 240
 241  private:
 242   ReferencePtr mSurface;
 243 };
 244
 245 inline bool RecordedCacheDataSurface::PlayCanvasEvent(
 246     CanvasTranslator* aTranslator) const {
 247   gfx::SourceSurface* surface = aTranslator->LookupSourceSurface(mSurface);
 248   if (!surface) {
 249     return false;
 250   }
 251
 252   RefPtr<gfx::DataSourceSurface> dataSurface = surface->GetDataSurface();
 253
 254   aTranslator->AddDataSurface(mSurface, std::move(dataSurface));
 255   return true;
 256 }
 257
 258 template <class S>
 259 void RecordedCacheDataSurface::Record(S& aStream) const {
 260   WriteElement(aStream, mSurface);
 261 }
 262
 263 template <class S>
 264 RecordedCacheDataSurface::RecordedCacheDataSurface(S& aStream)
 265     : RecordedEventDerived(CACHE_DATA_SURFACE) {
 266   ReadElement(aStream, mSurface);
 267 }
 268
 269 class RecordedPrepareDataForSurface final
 270     : public RecordedEventDerived<RecordedPrepareDataForSurface> {
 271  public:
 272   explicit RecordedPrepareDataForSurface(const gfx::SourceSurface* aSurface)
 273       : RecordedEventDerived(PREPARE_DATA_FOR_SURFACE), mSurface(aSurface) {}
 274
 275   template <class S>
 276   MOZ_IMPLICIT RecordedPrepareDataForSurface(S& aStream);
 277
 278   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 279
 280   template <class S>
 281   void Record(S& aStream) const;
 282
 283   std::string GetName() const final { return "RecordedPrepareDataForSurface"; }
 284
 285  private:
 286   ReferencePtr mSurface;
 287 };
 288
 289 inline bool RecordedPrepareDataForSurface::PlayCanvasEvent(
 290     CanvasTranslator* aTranslator) const {
 291   RefPtr<gfx::DataSourceSurface> dataSurface =
 292       aTranslator->LookupDataSurface(mSurface);
 293   if (!dataSurface) {
 294     gfx::SourceSurface* surface = aTranslator->LookupSourceSurface(mSurface);
 295     if (!surface) {
 296       return false;
 297     }
 298
 299     dataSurface = surface->GetDataSurface();
 300     if (!dataSurface) {
 301       return false;
 302     }
 303   }
 304
 305   auto preparedMap = MakeUnique<gfx::DataSourceSurface::ScopedMap>(
 306       dataSurface, gfx::DataSourceSurface::READ);
 307   if (!preparedMap->IsMapped()) {
 308     return false;
 309   }
 310
 311   aTranslator->SetPreparedMap(mSurface, std::move(preparedMap));
 312
 313   return true;
 314 }
 315
 316 template <class S>
 317 void RecordedPrepareDataForSurface::Record(S& aStream) const {
 318   WriteElement(aStream, mSurface);
 319 }
 320
 321 template <class S>
 322 RecordedPrepareDataForSurface::RecordedPrepareDataForSurface(S& aStream)
 323     : RecordedEventDerived(PREPARE_DATA_FOR_SURFACE) {
 324   ReadElement(aStream, mSurface);
 325 }
 326
 327 class RecordedGetDataForSurface final
 328     : public RecordedEventDerived<RecordedGetDataForSurface> {
 329  public:
 330   explicit RecordedGetDataForSurface(const gfx::SourceSurface* aSurface)
 331       : RecordedEventDerived(GET_DATA_FOR_SURFACE), mSurface(aSurface) {}
 332
 333   template <class S>
 334   MOZ_IMPLICIT RecordedGetDataForSurface(S& aStream);
 335
 336   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 337
 338   template <class S>
 339   void Record(S& aStream) const;
 340
 341   std::string GetName() const final { return "RecordedGetDataForSurface"; }
 342
 343  private:
 344   ReferencePtr mSurface;
 345 };
 346
 347 inline bool RecordedGetDataForSurface::PlayCanvasEvent(
 348     CanvasTranslator* aTranslator) const {
 349   gfx::SourceSurface* surface = aTranslator->LookupSourceSurface(mSurface);
 350   if (!surface) {
 351     return false;
 352   }
 353
 354   UniquePtr<gfx::DataSourceSurface::ScopedMap> map =
 355       aTranslator->GetPreparedMap(mSurface);
 356   if (!map) {
 357     return false;
 358   }
 359
 360   gfx::IntSize ssSize = surface->GetSize();
 361   size_t dataFormatWidth = ssSize.width * BytesPerPixel(surface->GetFormat());
 362   int32_t srcStride = map->GetStride();
 363   char* src = reinterpret_cast<char*>(map->GetData());
 364   char* endSrc = src + (ssSize.height * srcStride);
 365   while (src < endSrc) {
 366     aTranslator->ReturnWrite(src, dataFormatWidth);
 367     src += srcStride;
 368   }
 369
 370   return true;
 371 }
 372
 373 template <class S>
 374 void RecordedGetDataForSurface::Record(S& aStream) const {
 375   WriteElement(aStream, mSurface);
 376 }
 377
 378 template <class S>
 379 RecordedGetDataForSurface::RecordedGetDataForSurface(S& aStream)
 380     : RecordedEventDerived(GET_DATA_FOR_SURFACE) {
 381   ReadElement(aStream, mSurface);
 382 }
 383
 384 class RecordedAddSurfaceAlias final
 385     : public RecordedEventDerived<RecordedAddSurfaceAlias> {
 386  public:
 387   RecordedAddSurfaceAlias(ReferencePtr aSurfaceAlias,
 388                           const RefPtr<gfx::SourceSurface>& aActualSurface)
 389       : RecordedEventDerived(ADD_SURFACE_ALIAS),
 390         mSurfaceAlias(aSurfaceAlias),
 391         mActualSurface(aActualSurface) {}
 392
 393   template <class S>
 394   MOZ_IMPLICIT RecordedAddSurfaceAlias(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 "RecordedAddSurfaceAlias"; }
 402
 403  private:
 404   ReferencePtr mSurfaceAlias;
 405   ReferencePtr mActualSurface;
 406 };
 407
 408 inline bool RecordedAddSurfaceAlias::PlayCanvasEvent(
 409     CanvasTranslator* aTranslator) const {
 410   RefPtr<gfx::SourceSurface> surface =
 411       aTranslator->LookupSourceSurface(mActualSurface);
 412   if (!surface) {
 413     return false;
 414   }
 415
 416   aTranslator->AddSourceSurface(mSurfaceAlias, surface);
 417   return true;
 418 }
 419
 420 template <class S>
 421 void RecordedAddSurfaceAlias::Record(S& aStream) const {
 422   WriteElement(aStream, mSurfaceAlias);
 423   WriteElement(aStream, mActualSurface);
 424 }
 425
 426 template <class S>
 427 RecordedAddSurfaceAlias::RecordedAddSurfaceAlias(S& aStream)
 428     : RecordedEventDerived(ADD_SURFACE_ALIAS) {
 429   ReadElement(aStream, mSurfaceAlias);
 430   ReadElement(aStream, mActualSurface);
 431 }
 432
 433 class RecordedRemoveSurfaceAlias final
 434     : public RecordedEventDerived<RecordedRemoveSurfaceAlias> {
 435  public:
 436   explicit RecordedRemoveSurfaceAlias(ReferencePtr aSurfaceAlias)
 437       : RecordedEventDerived(REMOVE_SURFACE_ALIAS),
 438         mSurfaceAlias(aSurfaceAlias) {}
 439
 440   template <class S>
 441   MOZ_IMPLICIT RecordedRemoveSurfaceAlias(S& aStream);
 442
 443   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 444
 445   template <class S>
 446   void Record(S& aStream) const;
 447
 448   std::string GetName() const final { return "RecordedRemoveSurfaceAlias"; }
 449
 450  private:
 451   ReferencePtr mSurfaceAlias;
 452 };
 453
 454 inline bool RecordedRemoveSurfaceAlias::PlayCanvasEvent(
 455     CanvasTranslator* aTranslator) const {
 456   aTranslator->RemoveSourceSurface(mSurfaceAlias);
 457   return true;
 458 }
 459
 460 template <class S>
 461 void RecordedRemoveSurfaceAlias::Record(S& aStream) const {
 462   WriteElement(aStream, mSurfaceAlias);
 463 }
 464
 465 template <class S>
 466 RecordedRemoveSurfaceAlias::RecordedRemoveSurfaceAlias(S& aStream)
 467     : RecordedEventDerived(REMOVE_SURFACE_ALIAS) {
 468   ReadElement(aStream, mSurfaceAlias);
 469 }
 470
 471 class RecordedDeviceChangeAcknowledged final
 472     : public RecordedEventDerived<RecordedDeviceChangeAcknowledged> {
 473  public:
 474   RecordedDeviceChangeAcknowledged()
 475       : RecordedEventDerived(DEVICE_CHANGE_ACKNOWLEDGED) {}
 476
 477   template <class S>
 478   MOZ_IMPLICIT RecordedDeviceChangeAcknowledged(S& aStream);
 479
 480   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 481
 482   template <class S>
 483   void Record(S& aStream) const;
 484
 485   std::string GetName() const final {
 486     return "RecordedDeviceChangeAcknowledged";
 487   }
 488 };
 489
 490 inline bool RecordedDeviceChangeAcknowledged::PlayCanvasEvent(
 491     CanvasTranslator* aTranslator) const {
 492   aTranslator->DeviceChangeAcknowledged();
 493   return true;
 494 }
 495
 496 template <class S>
 497 void RecordedDeviceChangeAcknowledged::Record(S& aStream) const {}
 498
 499 template <class S>
 500 RecordedDeviceChangeAcknowledged::RecordedDeviceChangeAcknowledged(S& aStream)
 501     : RecordedEventDerived(DEVICE_CHANGE_ACKNOWLEDGED) {}
 502
 503 class RecordedNextTextureId final
 504     : public RecordedEventDerived<RecordedNextTextureId> {
 505  public:
 506   explicit RecordedNextTextureId(int64_t aNextTextureId)
 507       : RecordedEventDerived(NEXT_TEXTURE_ID), mNextTextureId(aNextTextureId) {}
 508
 509   template <class S>
 510   MOZ_IMPLICIT RecordedNextTextureId(S& aStream);
 511
 512   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 513
 514   template <class S>
 515   void Record(S& aStream) const;
 516
 517   std::string GetName() const final { return "RecordedNextTextureId"; }
 518
 519  private:
 520   int64_t mNextTextureId;
 521 };
 522
 523 inline bool RecordedNextTextureId::PlayCanvasEvent(
 524     CanvasTranslator* aTranslator) const {
 525   aTranslator->SetNextTextureId(mNextTextureId);
 526   return true;
 527 }
 528
 529 template <class S>
 530 void RecordedNextTextureId::Record(S& aStream) const {
 531   WriteElement(aStream, mNextTextureId);
 532 }
 533
 534 template <class S>
 535 RecordedNextTextureId::RecordedNextTextureId(S& aStream)
 536     : RecordedEventDerived(NEXT_TEXTURE_ID) {
 537   ReadElement(aStream, mNextTextureId);
 538 }
 539
 540 class RecordedTextureDestruction final
 541     : public RecordedEventDerived<RecordedTextureDestruction> {
 542  public:
 543   explicit RecordedTextureDestruction(int64_t aTextureId)
 544       : RecordedEventDerived(TEXTURE_DESTRUCTION), mTextureId(aTextureId) {}
 545
 546   template <class S>
 547   MOZ_IMPLICIT RecordedTextureDestruction(S& aStream);
 548
 549   bool PlayCanvasEvent(CanvasTranslator* aTranslator) const;
 550
 551   template <class S>
 552   void Record(S& aStream) const;
 553
 554   std::string GetName() const final { return "RecordedTextureDestruction"; }
 555
 556  private:
 557   int64_t mTextureId;
 558 };
 559
 560 inline bool RecordedTextureDestruction::PlayCanvasEvent(
 561     CanvasTranslator* aTranslator) const {
 562   aTranslator->RemoveTexture(mTextureId);
 563   return true;
 564 }
 565
 566 template <class S>
 567 void RecordedTextureDestruction::Record(S& aStream) const {
 568   WriteElement(aStream, mTextureId);
 569 }
 570
 571 template <class S>
 572 RecordedTextureDestruction::RecordedTextureDestruction(S& aStream)
 573     : RecordedEventDerived(TEXTURE_DESTRUCTION) {
 574   ReadElement(aStream, mTextureId);
 575 }
 576
 577 #define FOR_EACH_CANVAS_EVENT(f)                                   \
 578   f(CANVAS_BEGIN_TRANSACTION, RecordedCanvasBeginTransaction);     \
 579   f(CANVAS_END_TRANSACTION, RecordedCanvasEndTransaction);         \
 580   f(CANVAS_FLUSH, RecordedCanvasFlush);                            \
 581   f(TEXTURE_LOCK, RecordedTextureLock);                            \
 582   f(TEXTURE_UNLOCK, RecordedTextureUnlock);                        \
 583   f(CACHE_DATA_SURFACE, RecordedCacheDataSurface);                 \
 584   f(PREPARE_DATA_FOR_SURFACE, RecordedPrepareDataForSurface);      \
 585   f(GET_DATA_FOR_SURFACE, RecordedGetDataForSurface);              \
 586   f(ADD_SURFACE_ALIAS, RecordedAddSurfaceAlias);                   \
 587   f(REMOVE_SURFACE_ALIAS, RecordedRemoveSurfaceAlias);             \
 588   f(DEVICE_CHANGE_ACKNOWLEDGED, RecordedDeviceChangeAcknowledged); \
 589   f(NEXT_TEXTURE_ID, RecordedNextTextureId);                       \
 590   f(TEXTURE_DESTRUCTION, RecordedTextureDestruction);
 591
 592 }  // namespace layers
 593 }  // namespace mozilla
 594
 595 #endif  // mozilla_layers_RecordedCanvasEventImpl_h