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                            layers::TextureType aTextureType, bool aNeutered,
  52                            bool aIsWriteOnly, nsIPrincipal* aExpandedReader);
  53   ~OffscreenCanvasCloneData();
  54
  55   RefPtr<OffscreenCanvasDisplayHelper> mDisplay;
  56   uint32_t mWidth;
  57   uint32_t mHeight;
  58   layers::LayersBackend mCompositorBackendType;
  59   layers::TextureType mTextureType;
  60   bool mNeutered;
  61   bool mIsWriteOnly;
  62   RefPtr<nsIPrincipal> mExpandedReader;
  63 };
  64
  65 class OffscreenCanvas final : public DOMEventTargetHelper,
  66                               public CanvasRenderingContextHelper {
  67  public:
  68   NS_DECL_ISUPPORTS_INHERITED
  69   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(OffscreenCanvas,
  70                                            DOMEventTargetHelper)
  71
  72   IMPL_EVENT_HANDLER(contextlost);
  73   IMPL_EVENT_HANDLER(contextrestored);
  74
  75   OffscreenCanvas(nsIGlobalObject* aGlobal, uint32_t aWidth, uint32_t aHeight);
  76
  77   OffscreenCanvas(nsIGlobalObject* aGlobal, uint32_t aWidth, uint32_t aHeight,
  78                   layers::LayersBackend aCompositorBackend,
  79                   layers::TextureType aTextureType,
  80                   already_AddRefed<OffscreenCanvasDisplayHelper> aDisplay);
  81
  82   void Destroy();
  83
  84   nsIGlobalObject* GetParentObject() const { return GetOwnerGlobal(); }
  85
  86   virtual JSObject* WrapObject(JSContext* aCx,
  87                                JS::Handle<JSObject*> aGivenProto) override;
  88
  89   static already_AddRefed<OffscreenCanvas> Constructor(
  90       const GlobalObject& aGlobal, uint32_t aWidth, uint32_t aHeight,
  91       ErrorResult& aRv);
  92
  93   void ClearResources();
  94
  95   uint32_t Width() const { return mWidth; }
  96   uint32_t Height() const { return mHeight; }
  97   void SetWidth(uint32_t aWidth, ErrorResult& aRv);
  98   void SetHeight(uint32_t aHeight, ErrorResult& aRv);
  99
 100   void GetContext(JSContext* aCx, const OffscreenRenderingContextId& aContextId,
 101                   JS::Handle<JS::Value> aContextOptions,
 102                   Nullable<OwningOffscreenRenderingContext>& aResult,
 103                   ErrorResult& aRv);
 104
 105   already_AddRefed<ImageBitmap> TransferToImageBitmap(ErrorResult& aRv);
 106
 107   already_AddRefed<Promise> ConvertToBlob(const ImageEncodeOptions& aOptions,
 108                                           ErrorResult& aRv);
 109
 110   already_AddRefed<Promise> ToBlob(JSContext* aCx, const nsAString& aType,
 111                                    JS::Handle<JS::Value> aParams,
 112                                    ErrorResult& aRv);
 113
 114   Maybe<uint64_t> GetWindowID();
 115
 116   nsICanvasRenderingContextInternal* GetContext() const {
 117     return mCurrentContext;
 118   }
 119
 120   CanvasContextType GetContextType() const { return mCurrentContextType; }
 121
 122   already_AddRefed<gfx::SourceSurface> GetSurfaceSnapshot(
 123       gfxAlphaType* aOutAlphaType = nullptr);
 124
 125   static already_AddRefed<OffscreenCanvas> CreateFromCloneData(
 126       nsIGlobalObject* aGlobal, OffscreenCanvasCloneData* aData);
 127
 128   // Return true on main-thread, and return gfx.offscreencanvas.enabled
 129   // on worker thread.
 130   static bool PrefEnabledOnWorkerThread(JSContext* aCx, JSObject* aObj);
 131
 132   UniquePtr<OffscreenCanvasCloneData> ToCloneData(JSContext* aCx);
 133
 134   void UpdateDisplayData(const OffscreenCanvasDisplayData& aData);
 135
 136   void CommitFrameToCompositor();
 137   void DequeueCommitToCompositor();
 138   void QueueCommitToCompositor();
 139
 140   virtual bool GetOpaqueAttr() override { return false; }
 141
 142   virtual nsIntSize GetWidthHeight() override {
 143     return nsIntSize(mWidth, mHeight);
 144   }
 145
 146   virtual already_AddRefed<nsICanvasRenderingContextInternal> CreateContext(
 147       CanvasContextType aContextType) override;
 148
 149   void SetNeutered() {
 150     mWidth = 0;
 151     mHeight = 0;
 152     mNeutered = true;
 153   }
 154
 155   bool MayNeuter() const { return !mNeutered && !mCurrentContext; }
 156
 157   void SetSize(const nsIntSize& aSize, ErrorResult& aRv);
 158
 159   nsIPrincipal* GetExpandedReader() const { return mExpandedReader; }
 160
 161   void SetWriteOnly(RefPtr<nsIPrincipal>&& aExpandedReader);
 162
 163   void SetWriteOnly(nsIPrincipal* aExpandedReader = nullptr) {
 164     RefPtr<nsIPrincipal> expandedReader(aExpandedReader);
 165     SetWriteOnly(std::move(expandedReader));
 166   }
 167
 168   bool IsWriteOnly() const { return mIsWriteOnly; }
 169
 170   // Determines if the caller should be able to read the content.
 171   bool CallerCanRead(nsIPrincipal& aPrincipal) const;
 172
 173   layers::LayersBackend GetCompositorBackendType() const {
 174     return mCompositorBackendType;
 175   }
 176
 177   bool ShouldResistFingerprinting(mozilla::RFPTarget aTarget) const;
 178
 179   bool IsTransferredFromElement() const { return !!mDisplay; }
 180
 181  private:
 182   ~OffscreenCanvas();
 183
 184   already_AddRefed<EncodeCompleteCallback> CreateEncodeCompleteCallback(
 185       Promise* aPromise);
 186
 187   void CanvasAttrChanged() {
 188     ErrorResult dummy;
 189     UpdateContext(nullptr, JS::NullHandleValue, dummy);
 190   }
 191
 192   bool mNeutered = false;
 193   bool mIsWriteOnly = false;
 194
 195   uint32_t mWidth = 0;
 196   uint32_t mHeight = 0;
 197
 198   layers::LayersBackend mCompositorBackendType =
 199       layers::LayersBackend::LAYERS_NONE;
 200   layers::TextureType mTextureType = layers::TextureType::Unknown;
 201
 202   RefPtr<OffscreenCanvasDisplayHelper> mDisplay;
 203   RefPtr<CancelableRunnable> mPendingCommit;
 204   RefPtr<nsIPrincipal> mExpandedReader;
 205   Maybe<OffscreenCanvasDisplayData> mPendingUpdate;
 206 };
 207
 208 }  // namespace dom
 209 }  // namespace mozilla
 210
 211 #endif  // MOZILLA_DOM_OFFSCREENCANVAS_H_