gfx/2d/DrawEventRecorder.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_GFX_DRAWEVENTRECORDER_H_
   8 #define MOZILLA_GFX_DRAWEVENTRECORDER_H_
   9
  10 #include "2D.h"
  11 #include "RecordedEvent.h"
  12 #include "RecordingTypes.h"
  13
  14 #include <deque>
  15 #include <functional>
  16 #include <vector>
  17
  18 #include "ImageContainer.h"
  19 #include "mozilla/DataMutex.h"
  20 #include "mozilla/ThreadSafeWeakPtr.h"
  21 #include "nsTHashMap.h"
  22 #include "nsTHashSet.h"
  23 #include "nsISupportsImpl.h"
  24
  25 namespace mozilla {
  26 namespace gfx {
  27
  28 class DrawTargetRecording;
  29 class PathRecording;
  30
  31 class DrawEventRecorderPrivate : public DrawEventRecorder {
  32  public:
  33   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawEventRecorderPrivate, override)
  34
  35   DrawEventRecorderPrivate();
  36   virtual ~DrawEventRecorderPrivate();
  37   RecorderType GetRecorderType() const override {
  38     return RecorderType::PRIVATE;
  39   }
  40   bool Finish() override {
  41     ClearResources();
  42     return true;
  43   }
  44   virtual void FlushItem(IntRect) {}
  45   virtual void DetachResources() {
  46     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
  47
  48     nsTHashSet<ScaledFont*> fonts = std::move(mStoredFonts);
  49     for (const auto& font : fonts) {
  50       font->RemoveUserData(reinterpret_cast<UserDataKey*>(this));
  51     }
  52
  53     // SourceSurfaces can be deleted off the main thread, so we use
  54     // ThreadSafeWeakPtrs to allow for this. RemoveUserData is thread safe.
  55     nsTHashMap<void*, ThreadSafeWeakPtr<SourceSurface>> surfaces =
  56         std::move(mStoredSurfaces);
  57     for (const auto& entry : surfaces) {
  58       RefPtr<SourceSurface> strongRef(entry.GetData());
  59       if (strongRef) {
  60         strongRef->RemoveUserData(reinterpret_cast<UserDataKey*>(this));
  61       }
  62     }
  63
  64     // Now that we've detached we can't get any more pending deletions, so
  65     // processing now should mean we include all clean up operations.
  66     ProcessPendingDeletions();
  67   }
  68
  69   void ClearResources() {
  70     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
  71     mStoredObjects.Clear();
  72     mStoredFontData.Clear();
  73     mScaledFonts.clear();
  74     mCurrentDT = nullptr;
  75   }
  76
  77   template <class S>
  78   void WriteHeader(S& aStream) {
  79     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
  80     WriteElement(aStream, kMagicInt);
  81     WriteElement(aStream, kMajorRevision);
  82     WriteElement(aStream, kMinorRevision);
  83   }
  84
  85   virtual void RecordEvent(const RecordedEvent& aEvent) = 0;
  86
  87   void RecordEvent(const DrawTargetRecording* aDT,
  88                    const RecordedEvent& aEvent) {
  89     ReferencePtr dt = aDT;
  90     if (mCurrentDT != dt) {
  91       SetDrawTarget(dt);
  92     }
  93     RecordEvent(aEvent);
  94   }
  95
  96   void SetDrawTarget(ReferencePtr aDT);
  97
  98   void ClearDrawTarget(const DrawTargetRecording* aDT) {
  99     ReferencePtr dt = aDT;
 100     if (mCurrentDT == dt) {
 101       mCurrentDT = nullptr;
 102     }
 103   }
 104
 105   void AddStoredObject(const ReferencePtr aObject) {
 106     ProcessPendingDeletions();
 107     mStoredObjects.Insert(aObject);
 108   }
 109
 110   /**
 111    * This is a combination of HasStoredObject and AddStoredObject, so that we
 112    * only have to call ProcessPendingDeletions once, which involves locking.
 113    * @param aObject the object to store if not already stored
 114    * @return true if the object was not already stored, false if it was
 115    */
 116   bool TryAddStoredObject(const ReferencePtr aObject) {
 117     ProcessPendingDeletions();
 118     return mStoredObjects.EnsureInserted(aObject);
 119   }
 120
 121   virtual void AddPendingDeletion(std::function<void()>&& aPendingDeletion) {
 122     auto lockedPendingDeletions = mPendingDeletions.Lock();
 123     lockedPendingDeletions->emplace_back(std::move(aPendingDeletion));
 124   }
 125
 126   void RemoveStoredObject(const ReferencePtr aObject) {
 127     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
 128     mStoredObjects.Remove(aObject);
 129   }
 130
 131   /**
 132    * @param aUnscaledFont the UnscaledFont to increment the reference count for
 133    * @return the previous reference count
 134    */
 135   int32_t IncrementUnscaledFontRefCount(const ReferencePtr aUnscaledFont) {
 136     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
 137     int32_t& count = mUnscaledFontRefs.LookupOrInsert(aUnscaledFont, 0);
 138     return count++;
 139   }
 140
 141   /**
 142    * Decrements the reference count for aUnscaledFont and, if count is now zero,
 143    * records its destruction.
 144    * @param aUnscaledFont the UnscaledFont to decrement the reference count for
 145    */
 146   void DecrementUnscaledFontRefCount(const ReferencePtr aUnscaledFont);
 147
 148   void AddScaledFont(ScaledFont* aFont) {
 149     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
 150     if (mStoredFonts.EnsureInserted(aFont) && WantsExternalFonts()) {
 151       mScaledFonts.push_back(aFont);
 152     }
 153   }
 154
 155   void RemoveScaledFont(ScaledFont* aFont) { mStoredFonts.Remove(aFont); }
 156
 157   void AddSourceSurface(SourceSurface* aSurface) {
 158     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
 159     mStoredSurfaces.InsertOrUpdate(aSurface, aSurface);
 160   }
 161
 162   void RemoveSourceSurface(SourceSurface* aSurface) {
 163     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
 164     mStoredSurfaces.Remove(aSurface);
 165   }
 166
 167 #if defined(DEBUG)
 168   // Only used within debug assertions.
 169   bool HasStoredObject(const ReferencePtr aObject) {
 170     ProcessPendingDeletions();
 171     return mStoredObjects.Contains(aObject);
 172   }
 173 #endif
 174
 175   void AddStoredFontData(const uint64_t aFontDataKey) {
 176     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
 177     mStoredFontData.Insert(aFontDataKey);
 178   }
 179
 180   bool HasStoredFontData(const uint64_t aFontDataKey) {
 181     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
 182     return mStoredFontData.Contains(aFontDataKey);
 183   }
 184
 185   bool WantsExternalFonts() const { return mExternalFonts; }
 186
 187   virtual void StoreSourceSurfaceRecording(SourceSurface* aSurface,
 188                                            const char* aReason);
 189
 190   virtual void StoreImageRecording(
 191       const RefPtr<layers::Image>& aImageOfSurfaceDescriptor,
 192       const char* aReasony) {
 193     MOZ_ASSERT_UNREACHABLE("unexpected to be called");
 194   }
 195
 196   /**
 197    * Used when a source surface is destroyed, aSurface is a void* instead of a
 198    * SourceSurface* because this is called during the SourceSurface destructor,
 199    * so it is partially destructed and should not be accessed.
 200    * @param aSurface the surface whose destruction is being recorded
 201    */
 202   void RecordSourceSurfaceDestruction(void* aSurface);
 203
 204   virtual void AddDependentSurface(uint64_t aDependencyId) {
 205     MOZ_CRASH("GFX: AddDependentSurface");
 206   }
 207
 208   struct ExternalSurfaceEntry {
 209     RefPtr<SourceSurface> mSurface;
 210     int64_t mEventCount = -1;
 211   };
 212
 213   using ExternalSurfacesHolder = std::deque<ExternalSurfaceEntry>;
 214
 215   void TakeExternalSurfaces(ExternalSurfacesHolder& aSurfaces) {
 216     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
 217     aSurfaces = std::move(mExternalSurfaces);
 218   }
 219
 220   struct ExternalImageEntry {
 221     RefPtr<layers::Image> mImage;
 222     int64_t mEventCount = -1;
 223   };
 224
 225   using ExternalImagesHolder = std::deque<ExternalImageEntry>;
 226
 227  protected:
 228   NS_DECL_OWNINGTHREAD
 229
 230   void StoreExternalSurfaceRecording(SourceSurface* aSurface, uint64_t aKey);
 231
 232   void StoreExternalImageRecording(
 233       const RefPtr<layers::Image>& aImageOfSurfaceDescriptor);
 234
 235   void ProcessPendingDeletions() {
 236     NS_ASSERT_OWNINGTHREAD(DrawEventRecorderPrivate);
 237
 238     PendingDeletionsVector pendingDeletions;
 239     {
 240       auto lockedPendingDeletions = mPendingDeletions.Lock();
 241       pendingDeletions.swap(*lockedPendingDeletions);
 242     }
 243     for (const auto& pendingDeletion : pendingDeletions) {
 244       pendingDeletion();
 245     }
 246   }
 247
 248   virtual void Flush() = 0;
 249
 250   nsTHashSet<const void*> mStoredObjects;
 251
 252   using PendingDeletionsVector = std::vector<std::function<void()>>;
 253   DataMutex<PendingDeletionsVector> mPendingDeletions{
 254       "DrawEventRecorderPrivate::mPendingDeletions"};
 255
 256   // It's difficult to track the lifetimes of UnscaledFonts directly, so we
 257   // instead track the number of recorded ScaledFonts that hold a reference to
 258   // an Unscaled font and use that as a proxy to the real lifetime. An
 259   // UnscaledFonts lifetime could be longer than this, but we only use the
 260   // ScaledFonts directly and if another uses an UnscaledFont we have destroyed
 261   // on the translation side, it will be recreated.
 262   nsTHashMap<const void*, int32_t> mUnscaledFontRefs;
 263
 264   nsTHashSet<uint64_t> mStoredFontData;
 265   nsTHashSet<ScaledFont*> mStoredFonts;
 266   std::vector<RefPtr<ScaledFont>> mScaledFonts;
 267
 268   // SourceSurfaces can get deleted off the main thread, so we hold a map of the
 269   // raw pointer to a ThreadSafeWeakPtr to protect against this.
 270   nsTHashMap<void*, ThreadSafeWeakPtr<SourceSurface>> mStoredSurfaces;
 271
 272   ReferencePtr mCurrentDT;
 273   ExternalSurfacesHolder mExternalSurfaces;
 274   ExternalImagesHolder mExternalImages;
 275   bool mExternalFonts;
 276 };
 277
 278 typedef std::function<void(MemStream& aStream,
 279                            std::vector<RefPtr<ScaledFont>>& aScaledFonts)>
 280     SerializeResourcesFn;
 281
 282 // WARNING: This should not be used in its existing state because
 283 // it is likely to OOM because of large continguous allocations.
 284 class DrawEventRecorderMemory : public DrawEventRecorderPrivate {
 285  public:
 286   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawEventRecorderMemory, override)
 287
 288   /**
 289    * Constructs a DrawEventRecorder that stores the recording in memory.
 290    */
 291   DrawEventRecorderMemory();
 292   explicit DrawEventRecorderMemory(const SerializeResourcesFn& aSerialize);
 293
 294   RecorderType GetRecorderType() const override { return RecorderType::MEMORY; }
 295
 296   void RecordEvent(const RecordedEvent& aEvent) override;
 297
 298   void AddDependentSurface(uint64_t aDependencyId) override;
 299
 300   nsTHashSet<uint64_t>&& TakeDependentSurfaces();
 301
 302   /**
 303    * @return the current size of the recording (in chars).
 304    */
 305   size_t RecordingSize();
 306
 307   /**
 308    * Wipes the internal recording buffer, but the recorder does NOT forget which
 309    * objects it has recorded. This can be used so that a recording can be copied
 310    * and processed in chunks, releasing memory as it goes.
 311    */
 312   void WipeRecording();
 313   bool Finish() override;
 314   void FlushItem(IntRect) override;
 315
 316   MemStream mOutputStream;
 317   /* The index stream is of the form:
 318    * ItemIndex { size_t dataEnd; size_t extraDataEnd; }
 319    * It gets concatenated to the end of mOutputStream in Finish()
 320    * The last size_t in the stream is offset of the begining of the
 321    * index.
 322    */
 323   MemStream mIndex;
 324
 325  protected:
 326   virtual ~DrawEventRecorderMemory() = default;
 327
 328  private:
 329   SerializeResourcesFn mSerializeCallback;
 330   nsTHashSet<uint64_t> mDependentSurfaces;
 331
 332   void Flush() override;
 333 };
 334
 335 }  // namespace gfx
 336 }  // namespace mozilla
 337
 338 #endif /* MOZILLA_GFX_DRAWEVENTRECORDER_H_ */