dom/canvas/OffscreenCanvas.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent: */
   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_DOM_OFFSCREENCANVAS_H_
   8 #define MOZILLA_DOM_OFFSCREENCANVAS_H_
   9
  10 #include "gfxTypes.h"
  11 #include "mozilla/dom/CanvasRenderingContextHelper.h"
  12 #include "mozilla/dom/ImageEncoder.h"
  13 #include "mozilla/dom/OffscreenCanvasDisplayHelper.h"
  14 #include "mozilla/DOMEventTargetHelper.h"
  15 #include "mozilla/layers/LayersTypes.h"
  16 #include "mozilla/Maybe.h"
  17 #include "mozilla/RefPtr.h"
  18 #include "mozilla/UniquePtr.h"
  19 #include "nsCycleCollectionParticipant.h"
  20
  21 struct JSContext;
  22
  23 namespace mozilla {
  24 class CancelableRunnable;
  25 class ErrorResult;
  26 enum class RFPTarget : uint64_t;
  27
  28 namespace gfx {
  29 class SourceSurface;
  30 }
  31
  32 namespace dom {
  33 enum class OffscreenRenderingContextId : uint8_t;
  34 class Blob;
  35 class EncodeCompleteCallback;
  36 class OffscreenCanvasDisplayHelper;
  37 class ImageBitmap;
  38 struct ImageEncodeOptions;
  39
  40 using OwningOffscreenRenderingContext = class
  41     OwningOffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext;
  42
  43 // This is helper class for transferring OffscreenCanvas to worker thread.
  44 // Because OffscreenCanvas is not thread-safe. So we cannot pass Offscreen-
  45 // Canvas to worker thread directly. Thus, we create this helper class and
  46 // store necessary data in it then pass it to worker thread.
  47 struct OffscreenCanvasCloneData final {
  48   OffscreenCanvasCloneData(OffscreenCanvasDisplayHelper* aDisplay,
  49                            uint32_t aWidth, uint32_t aHeight,
  50                            layers::LayersBackend aCompositorBackend,
  51                            bool aNeutered, bool aIsWriteOnly,
  52                            nsIPrincipal* aExpandedReader);
  53   ~OffscreenCanvasCloneData();
  54
  55   RefPtr<OffscreenCanvasDisplayHelper> mDisplay;
  56   uint32_t mWidth;
  57   uint32_t mHeight;
  58   layers::LayersBackend mCompositorBackendType;
  59   bool mNeutered;
  60   bool mIsWriteOnly;
  61   RefPtr<nsIPrincipal> mExpandedReader;
  62 };
  63
  64 class OffscreenCanvas final : public DOMEventTargetHelper,
  65                               public CanvasRenderingContextHelper {
  66  public:
  67   NS_DECL_ISUPPORTS_INHERITED
  68   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(OffscreenCanvas,
  69                                            DOMEventTargetHelper)
  70
  71   IMPL_EVENT_HANDLER(contextlost);
  72   IMPL_EVENT_HANDLER(contextrestored);
  73
  74   OffscreenCanvas(nsIGlobalObject* aGlobal, uint32_t aWidth, uint32_t aHeight);
  75
  76   OffscreenCanvas(nsIGlobalObject* aGlobal, uint32_t aWidth, uint32_t aHeight,
  77                   layers::LayersBackend aCompositorBackend,
  78                   already_AddRefed<OffscreenCanvasDisplayHelper> aDisplay);
  79
  80   void Destroy();
  81
  82   nsIGlobalObject* GetParentObject() const { return GetOwnerGlobal(); }
  83
  84   virtual JSObject* WrapObject(JSContext* aCx,
  85                                JS::Handle<JSObject*> aGivenProto) override;
  86
  87   static already_AddRefed<OffscreenCanvas> Constructor(
  88       const GlobalObject& aGlobal, uint32_t aWidth, uint32_t aHeight,
  89       ErrorResult& aRv);
  90
  91   void ClearResources();
  92
  93   uint32_t Width() const { return mWidth; }
  94   uint32_t Height() const { return mHeight; }
  95   void SetWidth(uint32_t aWidth, ErrorResult& aRv);
  96   void SetHeight(uint32_t aHeight, ErrorResult& aRv);
  97
  98   void GetContext(JSContext* aCx, const OffscreenRenderingContextId& aContextId,
  99                   JS::Handle<JS::Value> aContextOptions,
 100                   Nullable<OwningOffscreenRenderingContext>& aResult,
 101                   ErrorResult& aRv);
 102
 103   already_AddRefed<ImageBitmap> TransferToImageBitmap(ErrorResult& aRv);
 104
 105   already_AddRefed<Promise> ConvertToBlob(const ImageEncodeOptions& aOptions,
 106                                           ErrorResult& aRv);
 107
 108   already_AddRefed<Promise> ToBlob(JSContext* aCx, const nsAString& aType,
 109                                    JS::Handle<JS::Value> aParams,
 110                                    ErrorResult& aRv);
 111
 112   Maybe<uint64_t> GetWindowID();
 113
 114   nsICanvasRenderingContextInternal* GetContext() const {
 115     return mCurrentContext;
 116   }
 117
 118   CanvasContextType GetContextType() const { return mCurrentContextType; }
 119
 120   already_AddRefed<gfx::SourceSurface> GetSurfaceSnapshot(
 121       gfxAlphaType* aOutAlphaType = nullptr);
 122
 123   static already_AddRefed<OffscreenCanvas> CreateFromCloneData(
 124       nsIGlobalObject* aGlobal, OffscreenCanvasCloneData* aData);
 125
 126   UniquePtr<OffscreenCanvasCloneData> ToCloneData(JSContext* aCx);
 127
 128   void UpdateDisplayData(const OffscreenCanvasDisplayData& aData);
 129
 130   void CommitFrameToCompositor();
 131   void DequeueCommitToCompositor();
 132   void QueueCommitToCompositor();
 133
 134   virtual bool GetOpaqueAttr() override { return false; }
 135
 136   CSSIntSize GetWidthHeight() override { return CSSIntSize(mWidth, mHeight); }
 137
 138   virtual already_AddRefed<nsICanvasRenderingContextInternal> CreateContext(
 139       CanvasContextType aContextType) override;
 140
 141   void SetNeutered() {
 142     mWidth = 0;
 143     mHeight = 0;
 144     mNeutered = true;
 145   }
 146
 147   bool MayNeuter() const { return !mNeutered && !mCurrentContext; }
 148
 149   void SetSize(const nsIntSize& aSize, ErrorResult& aRv);
 150
 151   nsIPrincipal* GetExpandedReader() const { return mExpandedReader; }
 152
 153   void SetWriteOnly(RefPtr<nsIPrincipal>&& aExpandedReader);
 154
 155   void SetWriteOnly(nsIPrincipal* aExpandedReader = nullptr) {
 156     RefPtr<nsIPrincipal> expandedReader(aExpandedReader);
 157     SetWriteOnly(std::move(expandedReader));
 158   }
 159
 160   bool IsWriteOnly() const { return mIsWriteOnly; }
 161
 162   // Determines if the caller should be able to read the content.
 163   bool CallerCanRead(nsIPrincipal& aPrincipal) const;
 164
 165   layers::LayersBackend GetCompositorBackendType() const {
 166     return mCompositorBackendType;
 167   }
 168
 169   bool ShouldResistFingerprinting(mozilla::RFPTarget aTarget) const;
 170
 171   bool IsTransferredFromElement() const { return !!mDisplay; }
 172
 173  private:
 174   ~OffscreenCanvas();
 175
 176   already_AddRefed<EncodeCompleteCallback> CreateEncodeCompleteCallback(
 177       Promise* aPromise);
 178
 179   void CanvasAttrChanged() {
 180     ErrorResult dummy;
 181     UpdateContext(nullptr, JS::NullHandleValue, dummy);
 182   }
 183
 184   bool mNeutered = false;
 185   bool mIsWriteOnly = false;
 186
 187   uint32_t mWidth = 0;
 188   uint32_t mHeight = 0;
 189
 190   layers::LayersBackend mCompositorBackendType =
 191       layers::LayersBackend::LAYERS_NONE;
 192
 193   RefPtr<OffscreenCanvasDisplayHelper> mDisplay;
 194   RefPtr<CancelableRunnable> mPendingCommit;
 195   RefPtr<nsIPrincipal> mExpandedReader;
 196   Maybe<OffscreenCanvasDisplayData> mPendingUpdate;
 197 };
 198
 199 }  // namespace dom
 200 }  // namespace mozilla
 201
 202 #endif  // MOZILLA_DOM_OFFSCREENCANVAS_H_