Bug 1863914: Use multiple shmem buffers for remote canvas recording. r=aosmond

This replaces the use of a single large ring buffer.
The buffers are still processed in parallel and are recycled to reduce
allocation. Events that do not fit in the default sized buffer have a separate
buffer created to fit them. These large buffers are not recycled.
Separate shared memory is used for readback, with a single shmem cached for this
purpose. Generally only one cached shmem should be required, because the
operations that usually readback the data do it straight away.

Differential Revision: https://phabricator.services.mozilla.com/D193207

Author: bobowen

gfx/2d/InlineTranslator.cpp

@@ -19,26 +19,6 @@ InlineTranslator::InlineTranslator(DrawTarget* aDT, void* aFontContext)
     : mBaseDT(aDT), mFontContext(aFontContext) {}
 
 bool InlineTranslator::TranslateRecording(char* aData, size_t aLen) {
-  // an istream like class for reading from memory
-  struct MemReader {
-    MemReader(char* aData, size_t aLen) : mData(aData), mEnd(aData + aLen) {}
-    void read(char* s, std::streamsize n) {
-      if (n <= (mEnd - mData)) {
-        memcpy(s, mData, n);
-        mData += n;
-      } else {
-        // We've requested more data than is available
-        // set the Reader into an eof state
-        SetIsBad();
-      }
-    }
-    bool eof() { return mData > mEnd; }
-    bool good() { return !eof(); }
-    void SetIsBad() { mData = mEnd + 1; }
-
-    char* mData;
-    char* mEnd;
-  };
   MemReader reader(aData, aLen);
 
   uint32_t magicInt;

gfx/2d/RecordedEvent.cpp

@@ -26,10 +26,10 @@ bool RecordedEvent::DoWithEventFromStream(
 }
 
 /* static */
-bool RecordedEvent::DoWithEventFromStream(
-    EventRingBuffer& aStream, EventType aType,
+bool RecordedEvent::DoWithEventFromReader(
+    MemReader& aReader, EventType aType,
     const std::function<bool(RecordedEvent*)>& aAction) {
-  return DoWithEvent(aStream, aType, aAction);
+  return DoWithEvent(aReader, aType, aAction);
 }
 
 std::string RecordedEvent::GetEventName(EventType aType) {

gfx/2d/RecordedEvent.h

@@ -214,21 +214,60 @@ struct SizeCollector {
 };
 
 struct MemWriter {
-  explicit MemWriter(char* aPtr) : mPtr(aPtr) {}
+  constexpr explicit MemWriter(char* aPtr) : mPtr(aPtr) {}
   void write(const char* aData, size_t aSize) {
     memcpy(mPtr, aData, aSize);
     mPtr += aSize;
   }
   char* mPtr;
 };
 
-// This is a simple interface for an EventRingBuffer, so we can use it in the
-// RecordedEvent reading and writing machinery.
-class EventRingBuffer {
+// An istream like class for reading from memory
+struct MemReader {
+  constexpr MemReader(char* aData, size_t aLen)
+      : mData(aData), mEnd(aData + aLen) {}
+  void read(char* s, std::streamsize n) {
+    if (n <= (mEnd - mData)) {
+      memcpy(s, mData, n);
+      mData += n;
+    } else {
+      // We've requested more data than is available
+      // set the Reader into an eof state
+      SetIsBad();
+    }
+  }
+  bool eof() { return mData > mEnd; }
+  bool good() { return !eof(); }
+  void SetIsBad() { mData = mEnd + 1; }
+
+  char* mData;
+  char* mEnd;
+};
+
+class ContiguousBuffer {
+ public:
+  ContiguousBuffer(char* aStart, size_t aSize)
+      : mWriter(aStart), mEnd(aStart + aSize) {}
+
+  constexpr MOZ_IMPLICIT ContiguousBuffer(std::nullptr_t) : mWriter(nullptr) {}
+
+  MemWriter& Writer() { return mWriter; }
+
+  size_t SizeRemaining() { return mWriter.mPtr ? mEnd - mWriter.mPtr : 0; }
+
+  bool IsValid() { return !!mWriter.mPtr; }
+
+ private:
+  MemWriter mWriter;
+  char* mEnd = nullptr;
+};
+
+// Allows a derived class to provide guaranteed contiguous buffer.
+class ContiguousBufferStream {
  public:
   /**
-   * Templated RecordEvent function so that when we have enough contiguous
-   * space we can record into the buffer quickly using MemWriter.
+   * Templated RecordEvent function so that we can record into the buffer
+   * quickly using MemWriter.
    *
    * @param aRecordedEvent the event to record
    */
@@ -237,56 +276,25 @@ class EventRingBuffer {
     SizeCollector size;
     WriteElement(size, aRecordedEvent->GetType());
     aRecordedEvent->Record(size);
-    if (size.mTotalSize > mAvailable) {
-      WaitForAndRecalculateAvailableSpace();
-    }
-    if (size.mTotalSize <= mAvailable) {
-      MemWriter writer(mBufPos);
-      WriteElement(writer, aRecordedEvent->GetType());
-      aRecordedEvent->Record(writer);
-      UpdateWriteTotalsBy(size.mTotalSize);
-    } else {
-      WriteElement(*this, aRecordedEvent->GetType());
-      aRecordedEvent->Record(*this);
+    auto& buffer = GetContiguousBuffer(size.mTotalSize);
+    if (!buffer.IsValid()) {
+      return;
     }
-  }
 
-  /**
-   * Simple write function required by WriteElement.
-   *
-   * @param aData the data to be written to the buffer
-   * @param aSize the number of chars to write
-   */
-  virtual void write(const char* const aData, const size_t aSize) = 0;
-
-  /**
-   * Simple read function required by ReadElement.
-   *
-   * @param aOut the pointer to read into
-   * @param aSize the number of chars to read
-   */
-  virtual void read(char* const aOut, const size_t aSize) = 0;
+    MOZ_ASSERT(size.mTotalSize <= buffer.SizeRemaining());
 
-  virtual bool good() const = 0;
-
-  virtual void SetIsBad() = 0;
+    WriteElement(buffer.Writer(), aRecordedEvent->GetType());
+    aRecordedEvent->Record(buffer.Writer());
+    IncrementEventCount();
+  }
 
  protected:
   /**
-   * Wait until space is available for writing and then set mBufPos and
-   * mAvailable.
-   */
-  virtual bool WaitForAndRecalculateAvailableSpace() = 0;
-
-  /**
-   * Update write count, mBufPos and mAvailable.
-   *
-   * @param aCount number of bytes written
+   * Provide a contiguous buffer with at least aSize remaining.
    */
-  virtual void UpdateWriteTotalsBy(uint32_t aCount) = 0;
+  virtual ContiguousBuffer& GetContiguousBuffer(size_t aSize) = 0;
 
-  char* mBufPos = nullptr;
-  uint32_t mAvailable = 0;
+  virtual void IncrementEventCount() = 0;
 };
 
 struct MemStream {
@@ -430,7 +438,7 @@ class RecordedEvent {
 
   virtual void RecordToStream(std::ostream& aStream) const = 0;
   virtual void RecordToStream(EventStream& aStream) const = 0;
-  virtual void RecordToStream(EventRingBuffer& aStream) const = 0;
+  virtual void RecordToStream(ContiguousBufferStream& aStream) const = 0;
   virtual void RecordToStream(MemStream& aStream) const = 0;
 
   virtual void OutputSimpleEventInfo(std::stringstream& aStringStream) const {}
@@ -460,8 +468,8 @@ class RecordedEvent {
   static bool DoWithEventFromStream(
       EventStream& aStream, EventType aType,
       const std::function<bool(RecordedEvent*)>& aAction);
-  static bool DoWithEventFromStream(
-      EventRingBuffer& aStream, EventType aType,
+  static bool DoWithEventFromReader(
+      MemReader& aReader, EventType aType,
       const std::function<bool(RecordedEvent*)>& aAction);
 
   EventType GetType() const { return (EventType)mType; }
@@ -495,7 +503,7 @@ class RecordedEventDerived : public RecordedEvent {
     WriteElement(aStream, this->mType);
     static_cast<const Derived*>(this)->Record(aStream);
   }
-  void RecordToStream(EventRingBuffer& aStream) const final {
+  void RecordToStream(ContiguousBufferStream& aStream) const final {
     aStream.RecordEvent(static_cast<const Derived*>(this));
   }
   void RecordToStream(MemStream& aStream) const override {

gfx/ipc/CanvasManagerChild.cpp

@@ -151,6 +151,12 @@ void CanvasManagerChild::EndCanvasTransaction() {
   }
 }
 
+void CanvasManagerChild::ClearCachedResources() {
+  if (mCanvasChild) {
+    mCanvasChild->ClearCachedResources();
+  }
+}
+
 void CanvasManagerChild::DeactivateCanvas() {
   mActive = false;
   if (mCanvasChild) {

gfx/ipc/CanvasManagerChild.h

@@ -47,6 +47,7 @@ class CanvasManagerChild final : public PCanvasManagerChild {
 
   bool IsCanvasActive() { return mActive; }
   void EndCanvasTransaction();
+  void ClearCachedResources();
   void DeactivateCanvas();
 
   RefPtr<layers::CanvasChild> GetCanvasChild();