gfx/layers/CanvasDrawEventRecorder.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_CanvasDrawEventRecorder_h
   8 #define mozilla_layers_CanvasDrawEventRecorder_h
   9
  10 #include "mozilla/gfx/DrawEventRecorder.h"
  11 #include "mozilla/ipc/CrossProcessSemaphore.h"
  12 #include "mozilla/ipc/SharedMemoryBasic.h"
  13
  14 namespace mozilla {
  15 namespace layers {
  16
  17 static const uint8_t kCheckpointEventType = -1;
  18 static const uint8_t kDropBufferEventType = -2;
  19
  20 class CanvasEventRingBuffer final : public gfx::EventRingBuffer {
  21  public:
  22   /**
  23    * WriterServices allows consumers of CanvasEventRingBuffer to provide
  24    * functions required by the write side of a CanvasEventRingBuffer without
  25    * introducing unnecessary dependencies on IPC code.
  26    */
  27   class WriterServices {
  28    public:
  29     virtual ~WriterServices() = default;
  30
  31     /**
  32      * @returns true if the reader of the CanvasEventRingBuffer has permanently
  33      *          stopped processing, otherwise returns false.
  34      */
  35     virtual bool ReaderClosed() = 0;
  36
  37     /**
  38      * Causes the reader to resume processing when it is in a stopped state.
  39      */
  40     virtual void ResumeReader() = 0;
  41   };
  42
  43   /**
  44    * ReaderServices allows consumers of CanvasEventRingBuffer to provide
  45    * functions required by the read side of a CanvasEventRingBuffer without
  46    * introducing unnecessary dependencies on IPC code.
  47    */
  48   class ReaderServices {
  49    public:
  50     virtual ~ReaderServices() = default;
  51
  52     /**
  53      * @returns true if the writer of the CanvasEventRingBuffer has permanently
  54      *          stopped processing, otherwise returns false.
  55      */
  56     virtual bool WriterClosed() = 0;
  57   };
  58
  59   CanvasEventRingBuffer() {}
  60
  61   /**
  62    * Initializes the shared memory used for the ringbuffer and footers.
  63    * @param aOtherPid process ID to share the handles to
  64    * @param aReadHandle handle to the shared memory for the buffer
  65    */
  66   bool InitBuffer(base::ProcessId aOtherPid,
  67                   ipc::SharedMemoryBasic::Handle* aReadHandle);
  68
  69   /**
  70    * Initialize the write side of a CanvasEventRingBuffer returning handles to
  71    * the shared memory for the buffer and the two semaphores for waiting in the
  72    * reader and the writer.
  73    *
  74    * @param aOtherPid process ID to share the handles to
  75    * @param aReadHandle handle to the shared memory for the buffer
  76    * @param aReaderSem reading blocked semaphore
  77    * @param aWriterSem writing blocked semaphore
  78    * @param aWriterServices provides functions required by the writer
  79    * @returns true if initialization succeeds
  80    */
  81   bool InitWriter(base::ProcessId aOtherPid,
  82                   ipc::SharedMemoryBasic::Handle* aReadHandle,
  83                   CrossProcessSemaphoreHandle* aReaderSem,
  84                   CrossProcessSemaphoreHandle* aWriterSem,
  85                   UniquePtr<WriterServices> aWriterServices);
  86
  87   /**
  88    * Initialize the read side of a CanvasEventRingBuffer.
  89    *
  90    * @param aReadHandle handle to the shared memory for the buffer
  91    * @param aReaderSem reading blocked semaphore
  92    * @param aWriterSem writing blocked semaphore
  93    * @param aReaderServices provides functions required by the reader
  94    * @returns true if initialization succeeds
  95    */
  96   bool InitReader(ipc::SharedMemoryBasic::Handle aReadHandle,
  97                   CrossProcessSemaphoreHandle aReaderSem,
  98                   CrossProcessSemaphoreHandle aWriterSem,
  99                   UniquePtr<ReaderServices> aReaderServices);
 100
 101   /**
 102    * Set a new buffer to resume after we have been stopped by the writer.
 103    *
 104    * @param aReadHandle handle to the shared memory for the buffer
 105    * @returns true if initialization succeeds
 106    */
 107   bool SetNewBuffer(ipc::SharedMemoryBasic::Handle aReadHandle);
 108
 109   bool IsValid() const { return mSharedMemory; }
 110
 111   bool good() const final { return mGood; }
 112
 113   bool WriterFailed() const { return mWrite && mWrite->state == State::Failed; }
 114
 115   void SetIsBad() final {
 116     mGood = false;
 117     mRead->state = State::Failed;
 118   }
 119
 120   void write(const char* const aData, const size_t aSize) final;
 121
 122   bool HasDataToRead();
 123
 124   /*
 125    * This will put the reader into a stopped state if there is no more data to
 126    * read. If this returns false the caller is responsible for continuing
 127    * translation at a later point. If it returns false the writer will start the
 128    * translation again when more data is written.
 129    *
 130    * @returns true if stopped
 131    */
 132   bool StopIfEmpty();
 133
 134   /*
 135    * Waits for data to become available. This will wait for aTimeout duration
 136    * aRetryCount number of times, checking to see if the other side is closed in
 137    * between each one.
 138    *
 139    * @param aTimeout duration to wait
 140    * @param aRetryCount number of times to retry
 141    * @returns true if data is available to read.
 142    */
 143   bool WaitForDataToRead(TimeDuration aTimeout, int32_t aRetryCount);
 144
 145   uint8_t ReadNextEvent();
 146
 147   void read(char* const aOut, const size_t aSize) final;
 148
 149   /**
 150    * Writes a checkpoint event to the buffer.
 151    *
 152    * @returns the write count after the checkpoint has been written
 153    */
 154   uint32_t CreateCheckpoint();
 155
 156   /**
 157    * Waits until the given checkpoint has been read from the buffer.
 158    *
 159    * @params aCheckpoint the checkpoint to wait for
 160    * @params aTimeout duration to wait while reader is not active
 161    * @returns true if the checkpoint was reached, false if the reader is closed
 162    *          or we timeout.
 163    */
 164   bool WaitForCheckpoint(uint32_t aCheckpoint);
 165
 166   /**
 167    * Switch to a different sized buffer.
 168    */
 169   bool SwitchBuffer(base::ProcessId aOtherPid,
 170                     ipc::SharedMemoryBasic::Handle* aHandle);
 171
 172   /**
 173    * Used to send data back to the writer. This is done through the same shared
 174    * memory so the writer must wait and read the response after it has submitted
 175    * the event that uses this.
 176    *
 177    * @param aData the data to be written back to the writer
 178    * @param aSize the number of chars to write
 179    */
 180   void ReturnWrite(const char* aData, size_t aSize);
 181
 182   /**
 183    * Used to read data sent back from the reader via ReturnWrite. This is done
 184    * through the same shared memory so the writer must wait until all expected
 185    * data is read before writing new events to the buffer.
 186    *
 187    * @param aOut the pointer to read into
 188    * @param aSize the number of chars to read
 189    */
 190   void ReturnRead(char* aOut, size_t aSize);
 191
 192   bool UsingLargeStream() { return mLargeStream; }
 193
 194  protected:
 195   bool WaitForAndRecalculateAvailableSpace() final;
 196   void UpdateWriteTotalsBy(uint32_t aCount) final;
 197
 198  private:
 199   enum class State : uint32_t {
 200     Processing,
 201
 202     /**
 203      * This is the important state to make sure the other side signals or starts
 204      * us as soon as data or space is available. We set AboutToWait first and
 205      * then re-check the condition. If we went straight to Waiting or Stopped
 206      * then in between the last check and setting the state, the other side
 207      * could have used all available data or space and never have signaled us
 208      * because it didn't know we were about to wait, causing a deadlock.
 209      * While we are in this state, the other side must wait until we resolve the
 210      * AboutToWait state to one of the other states and then signal or start us
 211      * if it needs to.
 212      */
 213     AboutToWait,
 214     Waiting,
 215     Stopped,
 216     Failed,
 217   };
 218
 219   struct ReadFooter {
 220     Atomic<uint32_t> count;
 221     Atomic<uint32_t> returnCount;
 222     Atomic<State> state;
 223   };
 224
 225   struct WriteFooter {
 226     Atomic<uint32_t> count;
 227     Atomic<uint32_t> returnCount;
 228     Atomic<uint32_t> requiredDifference;
 229     Atomic<State> state;
 230   };
 231
 232   CanvasEventRingBuffer(const CanvasEventRingBuffer&) = delete;
 233   void operator=(const CanvasEventRingBuffer&) = delete;
 234
 235   void IncrementWriteCountBy(uint32_t aCount);
 236
 237   bool WaitForReadCount(uint32_t aReadCount, TimeDuration aTimeout);
 238
 239   bool WaitForAndRecalculateAvailableData();
 240
 241   void UpdateReadTotalsBy(uint32_t aCount);
 242   void IncrementReadCountBy(uint32_t aCount);
 243
 244   void CheckAndSignalReader();
 245
 246   void CheckAndSignalWriter();
 247
 248   uint32_t WaitForBytesToWrite();
 249
 250   uint32_t WaitForBytesToRead();
 251
 252   uint32_t StreamSize();
 253
 254   RefPtr<ipc::SharedMemoryBasic> mSharedMemory;
 255   UniquePtr<CrossProcessSemaphore> mReaderSemaphore;
 256   UniquePtr<CrossProcessSemaphore> mWriterSemaphore;
 257   UniquePtr<WriterServices> mWriterServices;
 258   UniquePtr<ReaderServices> mReaderServices;
 259   char* mBuf = nullptr;
 260   uint32_t mOurCount = 0;
 261   WriteFooter* mWrite = nullptr;
 262   ReadFooter* mRead = nullptr;
 263   bool mGood = false;
 264   bool mLargeStream = true;
 265 };
 266
 267 class CanvasDrawEventRecorder final : public gfx::DrawEventRecorderPrivate {
 268  public:
 269   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(CanvasDrawEventRecorder, final)
 270   explicit CanvasDrawEventRecorder(){};
 271
 272   bool Init(base::ProcessId aOtherPid, ipc::SharedMemoryBasic::Handle* aHandle,
 273             CrossProcessSemaphoreHandle* aReaderSem,
 274             CrossProcessSemaphoreHandle* aWriterSem,
 275             UniquePtr<CanvasEventRingBuffer::WriterServices> aWriterServices) {
 276     return mOutputStream.InitWriter(aOtherPid, aHandle, aReaderSem, aWriterSem,
 277                                     std::move(aWriterServices));
 278   }
 279
 280   void RecordEvent(const gfx::RecordedEvent& aEvent) final {
 281     if (!mOutputStream.good()) {
 282       return;
 283     }
 284
 285     aEvent.RecordToStream(mOutputStream);
 286   }
 287
 288   void StoreSourceSurfaceRecording(gfx::SourceSurface* aSurface,
 289                                    const char* aReason) final;
 290
 291   void Flush() final {}
 292
 293   void ReturnRead(char* aOut, size_t aSize) {
 294     mOutputStream.ReturnRead(aOut, aSize);
 295   }
 296
 297   uint32_t CreateCheckpoint() { return mOutputStream.CreateCheckpoint(); }
 298
 299   /**
 300    * Waits until the given checkpoint has been read by the translator.
 301    *
 302    * @params aCheckpoint the checkpoint to wait for
 303    * @returns true if the checkpoint was reached, false if the reader is closed
 304    *          or we timeout.
 305    */
 306   bool WaitForCheckpoint(uint32_t aCheckpoint) {
 307     return mOutputStream.WaitForCheckpoint(aCheckpoint);
 308   }
 309
 310   bool UsingLargeStream() { return mOutputStream.UsingLargeStream(); }
 311
 312   bool SwitchBuffer(base::ProcessId aOtherPid,
 313                     ipc::SharedMemoryBasic::Handle* aHandle) {
 314     return mOutputStream.SwitchBuffer(aOtherPid, aHandle);
 315   }
 316
 317  private:
 318   CanvasEventRingBuffer mOutputStream;
 319 };
 320
 321 }  // namespace layers
 322 }  // namespace mozilla
 323
 324 #endif  // mozilla_layers_CanvasDrawEventRecorder_h