The Tor Browser: layout/svg/nsSVGIntegrationUtils.h@97036ab72558

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

     1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 #ifndef NSSVGINTEGRATIONUTILS_H_

     7 #define NSSVGINTEGRATIONUTILS_H_

     9 #include "gfxMatrix.h"

    10 #include "GraphicsFilter.h"

    11 #include "gfxRect.h"

    12 #include "nsAutoPtr.h"

    14 class gfxDrawable;

    15 class nsDisplayList;

    16 class nsDisplayListBuilder;

    17 class nsIFrame;

    18 class nsRenderingContext;

    19 class nsIntRegion;

    21 struct nsRect;

    22 struct nsIntRect;

    24 namespace mozilla {

    25 namespace layers {

    26 class LayerManager;

    27 }

    28 }

    30 struct nsPoint;

    31 struct nsSize;

    33 /**

    34  * Integration of SVG effects (clipPath clipping, masking and filters) into

    35  * regular display list based painting and hit-testing.

    36  */

    37 class nsSVGIntegrationUtils MOZ_FINAL

    38 {

    39 public:

    40   /**

    41    * Returns true if SVG effects are currently applied to this frame.

    42    */

    43   static bool

    44   UsingEffectsForFrame(const nsIFrame* aFrame);

    46   /**

    47    * Returns the size of the union of the border-box rects of all of

    48    * aNonSVGFrame's continuations.

    49    */

    50   static nsSize

    51   GetContinuationUnionSize(nsIFrame* aNonSVGFrame);

    53   /**

    54    * When SVG effects need to resolve percentage, userSpaceOnUse lengths, they

    55    * need a coordinate context to resolve them against. This method provides

    56    * that coordinate context for non-SVG frames with SVG effects applied to

    57    * them. The gfxSize returned is the size of the union of all of the given

    58    * frame's continuations' border boxes, converted to SVG user units (equal to

    59    * CSS px units), as required by the SVG code.

    60    */

    61   static mozilla::gfx::Size

    62   GetSVGCoordContextForNonSVGFrame(nsIFrame* aNonSVGFrame);

    64   /**

    65    * SVG effects such as SVG filters, masking and clipPath may require an SVG

    66    * "bbox" for the element they're being applied to in order to make decisions

    67    * about positioning, and to resolve various lengths against. This method

    68    * provides the "bbox" for non-SVG frames. The bbox returned is in CSS px

    69    * units, and is the union of all aNonSVGFrame's continuations' overflow

    70    * areas, relative to the top-left of the union of all aNonSVGFrame's

    71    * continuations' border box rects.

    72    */

    73   static gfxRect

    74   GetSVGBBoxForNonSVGFrame(nsIFrame* aNonSVGFrame);

    76   /**

    77    * Used to adjust a frame's pre-effects visual overflow rect to take account

    78    * of SVG effects.

    79    *

    80    * XXX This method will not do the right thing for frames with continuations.

    81    * It really needs all the continuations to have been reflowed before being

    82    * called, but we currently call it on each continuation as its overflow

    83    * rects are set during the reflow of each particular continuation. Gecko's

    84    * current reflow architecture does not allow us to set the overflow rects

    85    * for a whole chain of continuations for a given element at the point when

    86    * the last continuation is reflowed. See:

    87    * http://groups.google.com/group/mozilla.dev.tech.layout/msg/6b179066f3051f65

    88    */

    89   static nsRect

    90   ComputePostEffectsVisualOverflowRect(nsIFrame* aFrame,

    91                                        const nsRect& aPreEffectsOverflowRect);

    93   /**

    94    * Used to adjust the area of a frame that needs to be invalidated to take

    95    * account of SVG effects.

    96    *

    97    * @param aFrame The effects frame.

    98    * @param aToReferenceFrame The offset (in app units) from aFrame to its

    99    * reference display item.

   100    * @param aInvalidRegion The pre-effects invalid region in pixels relative to

   101    * the reference display item.

   102    * @return The post-effects invalid rect in pixels relative to the reference

   103    * display item.

   104    */

   105   static nsIntRegion

   106   AdjustInvalidAreaForSVGEffects(nsIFrame* aFrame, const nsPoint& aToReferenceFrame,

   107                                  const nsIntRegion& aInvalidRegion);

   109   /**

   110    * Figure out which area of the source is needed given an area to

   111    * repaint

   112    */

   113   static nsRect

   114   GetRequiredSourceForInvalidArea(nsIFrame* aFrame, const nsRect& aDamageRect);

   116   /**

   117    * Returns true if the given point is not clipped out by effects.

   118    * @param aPt in appunits relative to aFrame

   119    */

   120   static bool

   121   HitTestFrameForEffects(nsIFrame* aFrame, const nsPoint& aPt);

   123   /**

   124    * Paint non-SVG frame with SVG effects.

   125    */

   126   static void

   127   PaintFramesWithEffects(nsRenderingContext* aCtx,

   128                          nsIFrame* aFrame, const nsRect& aDirtyRect,

   129                          nsDisplayListBuilder* aBuilder,

   130                          mozilla::layers::LayerManager* aManager);

   132   /**

   133    * SVG frames expect to paint in SVG user units, which are equal to CSS px

   134    * units. This method provides a transform matrix to multiply onto a

   135    * gfxContext's current transform to convert the context's current units from

   136    * its usual dev pixels to SVG user units/CSS px to keep the SVG code happy.

   137    */

   138   static gfxMatrix

   139   GetCSSPxToDevPxMatrix(nsIFrame* aNonSVGFrame);

   141   /**

   142    * @param aRenderingContext the target rendering context in which the paint

   143    * server will be rendered

   144    * @param aTarget the target frame onto which the paint server will be

   145    * rendered

   146    * @param aPaintServer a first-continuation frame to use as the source

   147    * @param aFilter a filter to be applied when scaling

   148    * @param aDest the area the paint server image should be mapped to

   149    * @param aFill the area to be filled with copies of the paint server image

   150    * @param aAnchor a point in aFill which we will ensure is pixel-aligned in

   151    * the output

   152    * @param aDirty pixels outside this area may be skipped

   153    * @param aPaintServerSize the size that would be filled when using

   154    * background-repeat:no-repeat and background-size:auto. For normal background

   155    * images, this would be the intrinsic size of the image; for gradients and

   156    * patterns this would be the whole target frame fill area.

   157    * @param aFlags pass FLAG_SYNC_DECODE_IMAGES and any images in the paint

   158    * server will be decoding synchronously if they are not decoded already.

   159    */

   160   enum {

   161     FLAG_SYNC_DECODE_IMAGES = 0x01,

   162   };

   164   static already_AddRefed<gfxDrawable>

   165   DrawableFromPaintServer(nsIFrame*         aFrame,

   166                           nsIFrame*         aTarget,

   167                           const nsSize&     aPaintServerSize,

   168                           const gfxIntSize& aRenderSize,

   169                           const gfxMatrix&  aContextMatrix,

   170                           uint32_t          aFlags);

   171 };

   173 #endif /*NSSVGINTEGRATIONUTILS_H_*/

The Tor Browser / file revision

layout/svg/nsSVGIntegrationUtils.h@97036ab72558

layout/svg/nsSVGIntegrationUtils.h