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   // Return true on main-thread, and return gfx.offscreencanvas.enabled
 127   // on worker thread.
 128   static bool PrefEnabledOnWorkerThread(JSContext* aCx, JSObject* aObj);
 129
 130   UniquePtr<OffscreenCanvasCloneData> ToCloneData(JSContext* aCx);
 131
 132   void UpdateDisplayData(const OffscreenCanvasDisplayData& aData);
 133
 134   void CommitFrameToCompositor();
 135   void DequeueCommitToCompositor();
 136   void QueueCommitToCompositor();
 137
 138   virtual bool GetOpaqueAttr() override { return false; }
 139
 140   CSSIntSize GetWidthHeight() override { return CSSIntSize(mWidth, mHeight); }
 141
 142   virtual already_AddRefed<nsICanvasRenderingContextInternal> CreateContext(
 143       CanvasContextType aContextType) override;
 144
 145   void SetNeutered() {
 146     mWidth = 0;
 147     mHeight = 0;
 148     mNeutered = true;
 149   }
 150
 151   bool MayNeuter() const { return !mNeutered && !mCurrentContext; }
 152
 153   void SetSize(const nsIntSize& aSize, ErrorResult& aRv);
 154
 155   nsIPrincipal* GetExpandedReader() const { return mExpandedReader; }
 156
 157   void SetWriteOnly(RefPtr<nsIPrincipal>&& aExpandedReader);
 158
 159   void SetWriteOnly(nsIPrincipal* aExpandedReader = nullptr) {
 160     RefPtr<nsIPrincipal> expandedReader(aExpandedReader);
 161     SetWriteOnly(std::move(expandedReader));
 162   }
 163
 164   bool IsWriteOnly() const { return mIsWriteOnly; }
 165
 166   // Determines if the caller should be able to read the content.
 167   bool CallerCanRead(nsIPrincipal& aPrincipal) const;
 168
 169   layers::LayersBackend GetCompositorBackendType() const {
 170     return mCompositorBackendType;
 171   }
 172
 173   bool ShouldResistFingerprinting(mozilla::RFPTarget aTarget) const;
 174
 175   bool IsTransferredFromElement() const { return !!mDisplay; }
 176
 177  private:
 178   ~OffscreenCanvas();
 179
 180   already_AddRefed<EncodeCompleteCallback> CreateEncodeCompleteCallback(
 181       Promise* aPromise);
 182
 183   void CanvasAttrChanged() {
 184     ErrorResult dummy;
 185     UpdateContext(nullptr, JS::NullHandleValue, dummy);
 186   }
 187
 188   bool mNeutered = false;
 189   bool mIsWriteOnly = false;
 190
 191   uint32_t mWidth = 0;
 192   uint32_t mHeight = 0;
 193
 194   layers::LayersBackend mCompositorBackendType =
 195       layers::LayersBackend::LAYERS_NONE;
 196
 197   RefPtr<OffscreenCanvasDisplayHelper> mDisplay;
 198   RefPtr<CancelableRunnable> mPendingCommit;
 199   RefPtr<nsIPrincipal> mExpandedReader;
 200   Maybe<OffscreenCanvasDisplayData> mPendingUpdate;
 201 };
 202
 203 }  // namespace dom
 204 }  // namespace mozilla
 205
 206 #endif  // MOZILLA_DOM_OFFSCREENCANVAS_H_