tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

CanvasRenderer.h (4808B)

      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 GFX_CANVASRENDERER_H
      8 #define GFX_CANVASRENDERER_H
      9 
     10 #include <memory>            // for weak_ptr
     11 #include <stdint.h>          // for uint32_t
     12 #include "GLContextTypes.h"  // for GLContext
     13 #include "gfxContext.h"      // for gfxContext, etc
     14 #include "gfxTypes.h"
     15 #include "gfxPlatform.h"          // for gfxImageFormat
     16 #include "mozilla/Assertions.h"   // for MOZ_ASSERT, etc
     17 #include "mozilla/Preferences.h"  // for Preferences
     18 #include "mozilla/RefPtr.h"       // for RefPtr
     19 #include "mozilla/gfx/2D.h"       // for DrawTarget
     20 #include "mozilla/Maybe.h"
     21 #include "mozilla/mozalloc.h"  // for operator delete, etc
     22 #include "mozilla/WeakPtr.h"   // for WeakPtr
     23 #include "nsISupportsImpl.h"   // for MOZ_COUNT_CTOR, etc
     24 #include "nsICanvasRenderingContextInternal.h"
     25 
     26 namespace mozilla {
     27 namespace layers {
     28 
     29 class KnowsCompositor;
     30 class PersistentBufferProvider;
     31 class WebRenderCanvasRendererAsync;
     32 
     33 TextureType TexTypeForWebgl(KnowsCompositor*, bool aIsWebglOop);
     34 
     35 struct CanvasRendererData final {
     36  CanvasRendererData();
     37  ~CanvasRendererData();
     38 
     39  WeakPtr<nsICanvasRenderingContextInternal> mContext;
     40 
     41  // The size of the canvas content
     42  gfx::IntSize mSize = {0, 0};
     43 
     44  bool mDoPaintCallbacks = false;
     45  bool mIsOpaque = true;
     46  bool mIsAlphaPremult = true;
     47 
     48  gl::OriginPos mOriginPos = gl::OriginPos::TopLeft;
     49 
     50  // Used in remote texture push callback
     51  Maybe<RemoteTextureOwnerId> mRemoteTextureOwnerId = Nothing();
     52 
     53  nsICanvasRenderingContextInternal* GetContext() const {
     54    return mContext.get();
     55  }
     56 };
     57 
     58 // Based class which used for canvas rendering. There are many derived classes
     59 // for different purposes. such as:
     60 //
     61 // ShareableCanvasRenderer provides IPC capabilities that allow sending canvas
     62 // content over IPC. This is pure virtual class because the IPC handling is
     63 // different in different LayerManager. So that we have following classes
     64 // inherit ShareableCanvasRenderer.
     65 //
     66 // WebRenderCanvasRenderer inherits ShareableCanvasRenderer and provides all
     67 // functionality that WebRender uses.
     68 // WebRenderCanvasRendererAsync inherits WebRenderCanvasRenderer and be used in
     69 // layers-free mode of WebRender.
     70 //
     71 // class diagram:
     72 //
     73 //                       +--------------+
     74 //                       |CanvasRenderer|
     75 //                       +-------+------+
     76 //                               ^
     77 //                               |
     78 //                   +-----------+-----------+
     79 //                   |ShareableCanvasRenderer|
     80 //                   +-----+-----------------+
     81 //                               ^
     82 //                               |
     83 //                   +-----------+-----------+
     84 //                   |WebRenderCanvasRenderer|
     85 //                   +-----------+-----------+
     86 //                               ^
     87 //                               |
     88 //                 +-------------+--------------+
     89 //                 |WebRenderCanvasRendererAsync|
     90 //                 +----------------------------+
     91 
     92 class BorrowedSourceSurface final {
     93 public:
     94  const WeakPtr<PersistentBufferProvider> mReturnTo;
     95  const RefPtr<gfx::SourceSurface> mSurf;  /// non-null
     96 
     97  BorrowedSourceSurface(PersistentBufferProvider*, RefPtr<gfx::SourceSurface>);
     98  ~BorrowedSourceSurface();
     99 };
    100 
    101 // -
    102 
    103 class CanvasRenderer : public RefCounted<CanvasRenderer> {
    104  friend class CanvasRendererSourceSurface;
    105 
    106 public:
    107  MOZ_DECLARE_REFCOUNTED_TYPENAME(CanvasRenderer)
    108 
    109 private:
    110  bool mDirty = false;
    111 
    112 protected:
    113  CanvasRendererData mData;
    114 
    115 public:
    116  explicit CanvasRenderer();
    117  virtual ~CanvasRenderer();
    118 
    119 public:
    120  virtual void Initialize(const CanvasRendererData&);
    121  virtual bool IsDataValid(const CanvasRendererData&) const;
    122 
    123  virtual void ClearCachedResources() {}
    124  virtual void DisconnectClient() {}
    125 
    126  const gfx::IntSize& GetSize() const { return mData.mSize; }
    127  bool IsOpaque() const { return mData.mIsOpaque; }
    128  bool YIsDown() const { return mData.mOriginPos == gl::OriginPos::TopLeft; }
    129  Maybe<RemoteTextureOwnerId> GetRemoteTextureOwnerId() {
    130    return mData.mRemoteTextureOwnerId;
    131  }
    132 
    133  void SetDirty() { mDirty = true; }
    134  void ResetDirty() { mDirty = false; }
    135  bool IsDirty() const { return mDirty; }
    136 
    137  virtual WebRenderCanvasRendererAsync* AsWebRenderCanvasRendererAsync() {
    138    return nullptr;
    139  }
    140 
    141  std::shared_ptr<BorrowedSourceSurface> BorrowSnapshot(
    142      bool requireAlphaPremult = true) const;
    143 
    144  void FirePreTransactionCallback() const;
    145  void FireDidTransactionCallback() const;
    146 };
    147 
    148 }  // namespace layers
    149 }  // namespace mozilla
    150 
    151 #endif