The Tor Browser: layout/svg/nsSVGUtils.h@97036ab72558 (annotated)

layout/svg/nsSVGUtils.h@97036ab72558 (annotated)

layout/svg/nsSVGUtils.h

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

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.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef NS_SVGUTILS_H
 #define NS_SVGUTILS_H
 // include math.h to pick up definition of M_ maths defines e.g. M_PI
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include "DrawMode.h"
 #include "gfx2DGlue.h"
 #include "gfxMatrix.h"
 #include "gfxPoint.h"
 #include "gfxRect.h"
 #include "mozilla/gfx/Rect.h"
 #include "nsAlgorithm.h"
 #include "nsChangeHint.h"
 #include "nsColor.h"
 #include "nsCOMPtr.h"
 #include "nsID.h"
 #include "nsISupportsBase.h"
 #include "nsMathUtils.h"
 #include "nsStyleStruct.h"
 #include "mozilla/Constants.h"
 #include <algorithm>
 class gfxContext;
 class gfxPattern;
 class nsFrameList;
 class nsIContent;
 class nsIDocument;
 class nsIFrame;
 class nsPresContext;
 class nsRenderingContext;
 class nsStyleContext;
 class nsStyleCoord;
 class nsSVGDisplayContainerFrame;
 class nsSVGElement;
 class nsSVGEnum;
 class nsSVGLength2;
 class nsSVGOuterSVGFrame;
 class nsSVGPathGeometryFrame;
 class nsTextFrame;
 class gfxTextContextPaint;
 struct nsStyleSVG;
 struct nsStyleSVGPaint;
 struct nsRect;
 struct nsIntRect;
 struct nsPoint;
 namespace mozilla {
 class SVGAnimatedPreserveAspectRatio;
 class SVGPreserveAspectRatio;
 namespace dom {
 class Element;
 } // namespace dom
 namespace gfx {
 class SourceSurface;
 }
 } // namespace mozilla
 // maximum dimension of an offscreen surface - choose so that
 // the surface size doesn't overflow a 32-bit signed int using
 // 4 bytes per pixel; in line with gfxASurface::CheckSurfaceSize
 // In fact Macs can't even manage that
 #define NS_SVG_OFFSCREEN_MAX_DIMENSION 4096
 #define SVG_HIT_TEST_FILL        0x01
 #define SVG_HIT_TEST_STROKE      0x02
 #define SVG_HIT_TEST_CHECK_MRECT 0x04
 bool NS_SVGDisplayListHitTestingEnabled();
 bool NS_SVGDisplayListPaintingEnabled();
 /**
  * Sometimes we need to distinguish between an empty box and a box
  * that contains an element that has no size e.g. a point at the origin.
  */
 class SVGBBox {
   typedef mozilla::gfx::Rect Rect;
 public:
   SVGBBox()
     : mIsEmpty(true) {}
   SVGBBox(const Rect& aRect)
     : mBBox(aRect), mIsEmpty(false) {}
   SVGBBox(const gfxRect& aRect)
     : mBBox(ToRect(aRect)), mIsEmpty(false) {}
   gfxRect ToThebesRect() const {
     return ThebesRect(mBBox);
   }
   bool IsEmpty() const {
     return mIsEmpty;
   }
   void UnionEdges(const SVGBBox& aSVGBBox) {
     if (aSVGBBox.mIsEmpty) {
       return;
     }
     mBBox = mIsEmpty ? aSVGBBox.mBBox : mBBox.UnionEdges(aSVGBBox.mBBox);
     mIsEmpty = false;
   }
 private:
   Rect mBBox;
   bool mIsEmpty;
 };
 // GRRR WINDOWS HATE HATE HATE
 #undef CLIP_MASK
 class MOZ_STACK_CLASS SVGAutoRenderState
 {
 public:
   enum RenderMode {
     /**
      * Used to inform SVG frames that they should paint as normal.
      */
     NORMAL,
     /**
      * Used to inform SVG frames when they are painting as the child of a
      * simple clipPath. In this case they should only draw their basic geometry
      * as a path. They should not fill, stroke, or paint anything else.
      */
     CLIP,
     /**
      * Used to inform SVG frames when they are painting as the child of a
      * complex clipPath that requires the use of a clip mask. In this case they
      * should only draw their basic geometry as a path and then fill it using
      * fully opaque white. They should not stroke, or paint anything else.
      */
     CLIP_MASK
   };
   SVGAutoRenderState(nsRenderingContext *aContext, RenderMode aMode
                      MOZ_GUARD_OBJECT_NOTIFIER_PARAM);
   ~SVGAutoRenderState();
   void SetPaintingToWindow(bool aPaintingToWindow);
   static RenderMode GetRenderMode(nsRenderingContext *aContext);
   static bool IsPaintingToWindow(nsRenderingContext *aContext);
 private:
   nsRenderingContext *mContext;
   void *mOriginalRenderState;
   RenderMode mMode;
   bool mPaintingToWindow;
   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 #define NS_ISVGFILTERREFERENCE_IID \
 { 0x9744ee20, 0x1bcf, 0x4c62, \
  { 0x86, 0x7d, 0xd3, 0x7a, 0x91, 0x60, 0x3e, 0xef } }
 class nsISVGFilterReference : public nsISupports
 {
 public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ISVGFILTERREFERENCE_IID)
   virtual void Invalidate() = 0;
 };
 NS_DEFINE_STATIC_IID_ACCESSOR(nsISVGFilterReference, NS_ISVGFILTERREFERENCE_IID)
 /**
  * General functions used by all of SVG layout and possibly content code.
  * If a method is used by content and depends only on other content methods
  * it should go in SVGContentUtils instead.
  */
 class nsSVGUtils
 {
 public:
   typedef mozilla::dom::Element Element;
   static void Init();
   /**
    * Gets the nearest nsSVGInnerSVGFrame or nsSVGOuterSVGFrame frame. aFrame
    * must be an SVG frame. If aFrame is of type nsGkAtoms::svgOuterSVGFrame,
    * returns nullptr.
    */
   static nsSVGDisplayContainerFrame* GetNearestSVGViewport(nsIFrame *aFrame);
   /**
    * Returns the frame's post-filter visual overflow rect when passed the
    * frame's pre-filter visual overflow rect. If the frame is not currently
    * being filtered, this function simply returns aUnfilteredRect.
    */
   static nsRect GetPostFilterVisualOverflowRect(nsIFrame *aFrame,
                                                 const nsRect &aUnfilteredRect);
   /**
    * Schedules an update of the frame's bounds (which will in turn invalidate
    * the new area that the frame should paint to).
    *
    * This does nothing when passed an NS_FRAME_IS_NONDISPLAY frame.
    * In future we may want to allow ReflowSVG to be called on such frames,
    * but that would be better implemented as a ForceReflowSVG function to
    * be called synchronously while painting them without marking or paying
    * attention to dirty bits like this function.
    *
    * This is very similar to PresShell::FrameNeedsReflow. The main reason that
    * we have this function instead of using FrameNeedsReflow is because we need
    * to be able to call it under nsSVGOuterSVGFrame::NotifyViewportChange when
    * that function is called by nsSVGOuterSVGFrame::Reflow. FrameNeedsReflow
    * is not suitable for calling during reflow though, and it asserts as much.
    * The reason that we want to be callable under NotifyViewportChange is
    * because we want to synchronously notify and dirty the nsSVGOuterSVGFrame's
    * children so that when nsSVGOuterSVGFrame::DidReflow is called its children
    * will be updated for the new size as appropriate. Otherwise we'd have to
    * post an event to the event loop to mark dirty flags and request an update.
    *
    * Another reason that we don't currently want to call
    * PresShell::FrameNeedsReflow is because passing eRestyle to it to get it to
    * mark descendants dirty would cause it to descend through
    * nsSVGForeignObjectFrame frames to mark their children dirty, but we want to
    * handle nsSVGForeignObjectFrame specially. It would also do unnecessary work
    * descending into NS_FRAME_IS_NONDISPLAY frames.
    */
   static void ScheduleReflowSVG(nsIFrame *aFrame);
   /**
    * Returns true if the frame or any of its children need ReflowSVG
    * to be called on them.
    */
   static bool NeedsReflowSVG(nsIFrame *aFrame);
   /*
    * Update the filter invalidation region for ancestor frames, if relevant.
    */
   static void NotifyAncestorsOfFilterRegionChange(nsIFrame *aFrame);
   /* Computes the input length in terms of object space coordinates.
      Input: rect - bounding box
             length - length to be converted
   */
   static float ObjectSpace(const gfxRect &aRect, const nsSVGLength2 *aLength);
   /* Computes the input length in terms of user space coordinates.
      Input: content - object to be used for determining user space
      Input: length - length to be converted
   */
   static float UserSpace(nsSVGElement *aSVGElement, const nsSVGLength2 *aLength);
   /* Computes the input length in terms of user space coordinates.
      Input: aFrame - object to be used for determining user space
             length - length to be converted
   */
   static float UserSpace(nsIFrame *aFrame, const nsSVGLength2 *aLength);
   /* Find the outermost SVG frame of the passed frame */
   static nsSVGOuterSVGFrame *
   GetOuterSVGFrame(nsIFrame *aFrame);
   /**
    * Get the covered region for a frame. Return null if it's not an SVG frame.
    * @param aRect gets a rectangle in app units
    * @return the outer SVG frame which aRect is relative to
    */
   static nsIFrame*
   GetOuterSVGFrameAndCoveredRegion(nsIFrame* aFrame, nsRect* aRect);
   /* Paint SVG frame with SVG effects - aDirtyRect is the area being
    * redrawn, in device pixel coordinates relative to the outer svg */
   static void
   PaintFrameWithEffects(nsRenderingContext *aContext,
                         const nsIntRect *aDirtyRect,
                         nsIFrame *aFrame,
                         nsIFrame* aTransformRoot = nullptr);
   /* Hit testing - check if point hits the clipPath of indicated
    * frame.  Returns true if no clipPath set. */
   static bool
   HitTestClip(nsIFrame *aFrame, const nsPoint &aPoint);
   /* Hit testing - check if point hits any children of frame. */
   static nsIFrame *
   HitTestChildren(nsIFrame *aFrame, const nsPoint &aPoint);
   /*
    * Returns the CanvasTM of the indicated frame, whether it's a
    * child SVG frame, container SVG frame, or a regular frame.
    * For regular frames, we just return an identity matrix.
    */
   static gfxMatrix GetCanvasTM(nsIFrame* aFrame, uint32_t aFor,
                                nsIFrame* aTransformRoot = nullptr);
   /**
    * Returns the transform from aFrame's user space to canvas space. Only call
    * with SVG frames. This is like GetCanvasTM, except that it only includes
    * the transforms from aFrame's user space (i.e. the coordinate context
    * established by its 'transform' attribute, or else the coordinate context
    * that its _parent_ establishes for its children) to outer-<svg> device
    * space. Specifically, it does not include any other transforms introduced
    * by the frame such as x/y offsets and viewBox attributes.
    */
   static gfxMatrix GetUserToCanvasTM(nsIFrame* aFrame, uint32_t aFor);
   /**
    * Notify the descendants of aFrame of a change to one of their ancestors
    * that might affect them.
    */
   static void
   NotifyChildrenOfSVGChange(nsIFrame *aFrame, uint32_t aFlags);
   /*
    * Get frame's covered region by walking the children and doing union.
    */
   static nsRect
   GetCoveredRegion(const nsFrameList &aFrames);
   // Converts aPoint from an app unit point in outer-<svg> content rect space
   // to an app unit point in a frame's SVG userspace.
   // This is a temporary helper we should no longer need after bug 614732 is
   // fixed.
   static nsPoint
   TransformOuterSVGPointToChildFrame(nsPoint aPoint,
                                      const gfxMatrix& aFrameToCanvasTM,
                                      nsPresContext* aPresContext);
   static nsRect
   TransformFrameRectToOuterSVG(const nsRect& aRect,
                                const gfxMatrix& aMatrix,
                                nsPresContext* aPresContext);
   /*
    * Convert a surface size to an integer for use by thebes
    * possibly making it smaller in the process so the surface does not
    * use excessive memory.
    *
    * @param aSize the desired surface size
    * @param aResultOverflows true if the desired surface size is too big
    * @return the surface size to use
    */
   static gfxIntSize ConvertToSurfaceSize(const gfxSize& aSize,
                                          bool *aResultOverflows);
   /*
    * Hit test a given rectangle/matrix.
    */
   static bool
   HitTestRect(const mozilla::gfx::Matrix &aMatrix,
               float aRX, float aRY, float aRWidth, float aRHeight,
               float aX, float aY);
   /**
    * Get the clip rect for the given frame, taking into account the CSS 'clip'
    * property. See:
    * http://www.w3.org/TR/SVG11/masking.html#OverflowAndClipProperties
    * The arguments for aX, aY, aWidth and aHeight should be the dimensions of
    * the viewport established by aFrame.
    */
   static gfxRect
   GetClipRectForFrame(nsIFrame *aFrame,
                       float aX, float aY, float aWidth, float aHeight);
   static void SetClipRect(gfxContext *aContext,
                           const gfxMatrix &aCTM,
                           const gfxRect &aRect);
   /* Using group opacity instead of fill or stroke opacity on a
    * geometry object seems to be a common authoring mistake.  If we're
    * not applying filters and not both stroking and filling, we can
    * generate the same result without going through the overhead of a
    * push/pop group. */
   static bool
   CanOptimizeOpacity(nsIFrame *aFrame);
   /**
    * Take the CTM to userspace for an element, and adjust it to a CTM to its
    * object bounding box space if aUnits is SVG_UNIT_TYPE_OBJECTBOUNDINGBOX.
    * (I.e. so that [0,0] is at the top left of its bbox, and [1,1] is at the
    * bottom right of its bbox).
    *
    * If the bbox is empty, this will return a singular matrix.
    */
   static gfxMatrix
   AdjustMatrixForUnits(const gfxMatrix &aMatrix,
                        nsSVGEnum *aUnits,
                        nsIFrame *aFrame);
   enum BBoxFlags {
     eBBoxIncludeFill           = 1 << 0,
     eBBoxIncludeFillGeometry   = 1 << 1,
     eBBoxIncludeStroke         = 1 << 2,
     eBBoxIncludeStrokeGeometry = 1 << 3,
     eBBoxIncludeMarkers        = 1 << 4
   };
   /**
    * Get the SVG bbox (the SVG spec's simplified idea of bounds) of aFrame in
    * aFrame's userspace.
    */
   static gfxRect GetBBox(nsIFrame *aFrame,
                          uint32_t aFlags = eBBoxIncludeFillGeometry);
   /*
    * "User space" is the space that the frame's BBox (as calculated by
    * nsSVGUtils::GetBBox) is in. "Frame space" is the space that has its origin
    * at the top left of the union of the frame's border-box rects over all
    * continuations.
    * This function returns the offset one needs to add to something in frame
    * space in order to get its coordinates in user space.
    */
   static gfxPoint FrameSpaceInCSSPxToUserSpaceOffset(nsIFrame *aFrame);
   /**
    * Convert a userSpaceOnUse/objectBoundingBoxUnits rectangle that's specified
    * using four nsSVGLength2 values into a user unit rectangle in user space.
    *
    * @param aXYWH pointer to 4 consecutive nsSVGLength2 objects containing
    * the x, y, width and height values in that order
    * @param aBBox the bounding box of the object the rect is relative to;
    * may be null if aUnits is not SVG_UNIT_TYPE_OBJECTBOUNDINGBOX
    * @param aFrame the object in which to interpret user-space units;
    * may be null if aUnits is SVG_UNIT_TYPE_OBJECTBOUNDINGBOX
    */
   static gfxRect
   GetRelativeRect(uint16_t aUnits, const nsSVGLength2 *aXYWH,
                   const gfxRect &aBBox, nsIFrame *aFrame);
   /**
    * Find the first frame, starting with aStartFrame and going up its
    * parent chain, that is not an svgAFrame.
    */
   static nsIFrame* GetFirstNonAAncestorFrame(nsIFrame* aStartFrame);
   static bool OuterSVGIsCallingReflowSVG(nsIFrame *aFrame);
   static bool AnyOuterSVGIsCallingReflowSVG(nsIFrame *aFrame);
   /*
    * Get any additional transforms that apply only to stroking
    * e.g. non-scaling-stroke
    */
   static gfxMatrix GetStrokeTransform(nsIFrame *aFrame);
   /**
    * Compute the maximum possible device space stroke extents of a path given
    * the path's device space path extents, its stroke style and its ctm.
    *
    * This is a workaround for the lack of suitable cairo API for getting the
    * tight device space stroke extents of a path. This basically gives us the
    * tightest extents that we can guarantee fully enclose the inked stroke
    * without doing the calculations for the actual tight extents. We exploit
    * the fact that cairo does have an API for getting the tight device space
    * fill/path extents.
    *
    * This should die once bug 478152 is fixed.
    */
   static gfxRect PathExtentsToMaxStrokeExtents(const gfxRect& aPathExtents,
                                                nsTextFrame* aFrame,
                                                const gfxMatrix& aMatrix);
   static gfxRect PathExtentsToMaxStrokeExtents(const gfxRect& aPathExtents,
                                                nsSVGPathGeometryFrame* aFrame,
                                                const gfxMatrix& aMatrix);
   /**
    * Convert a floating-point value to a 32-bit integer value, clamping to
    * the range of valid integers.
    */
   static int32_t ClampToInt(double aVal)
   {
     return NS_lround(std::max(double(INT32_MIN),
                             std::min(double(INT32_MAX), aVal)));
   }
   static nscolor GetFallbackOrPaintColor(gfxContext *aContext,
                                          nsStyleContext *aStyleContext,
                                          nsStyleSVGPaint nsStyleSVG::*aFillOrStroke);
   /**
    * Set up cairo context with an object pattern
    */
   static bool SetupContextPaint(gfxContext *aContext,
                                 gfxTextContextPaint *aContextPaint,
                                 const nsStyleSVGPaint& aPaint,
                                 float aOpacity);
   /**
    * Sets the current paint on the specified gfxContent to be the SVG 'fill'
    * for the given frame.
    */
   static bool SetupCairoFillPaint(nsIFrame* aFrame, gfxContext* aContext,
                                   gfxTextContextPaint *aContextPaint = nullptr);
   /**
    * Sets the current paint on the specified gfxContent to be the SVG 'stroke'
    * for the given frame.
    */
   static bool SetupCairoStrokePaint(nsIFrame* aFrame, gfxContext* aContext,
                                     gfxTextContextPaint *aContextPaint = nullptr);
   static float GetOpacity(nsStyleSVGOpacitySource aOpacityType,
                           const float& aOpacity,
                           gfxTextContextPaint *aOuterContextPaint);
   /*
    * @return false if there is no stroke
    */
   static bool HasStroke(nsIFrame* aFrame,
                         gfxTextContextPaint *aContextPaint = nullptr);
   static float GetStrokeWidth(nsIFrame* aFrame,
                               gfxTextContextPaint *aContextPaint = nullptr);
   /*
    * Set up a cairo context for measuring the bounding box of a stroked path.
    */
   static void SetupCairoStrokeBBoxGeometry(nsIFrame* aFrame,
                                            gfxContext *aContext,
                                            gfxTextContextPaint *aContextPaint = nullptr);
   /*
    * Set up a cairo context for a stroked path (including any dashing that
    * applies).
    */
   static void SetupCairoStrokeGeometry(nsIFrame* aFrame, gfxContext *aContext,
                                        gfxTextContextPaint *aContextPaint = nullptr);
   /*
    * Set up a cairo context for stroking, including setting up any stroke-related
    * properties such as dashing and setting the current paint on the gfxContext.
    */
   static bool SetupCairoStroke(nsIFrame* aFrame, gfxContext *aContext,
                                gfxTextContextPaint *aContextPaint = nullptr);
   /**
    * This function returns a set of bit flags indicating which parts of the
    * element (fill, stroke, bounds) should intercept pointer events. It takes
    * into account the type of element and the value of the 'pointer-events'
    * property on the element.
    */
   static uint16_t GetGeometryHitTestFlags(nsIFrame* aFrame);
   /**
    * Render a SVG glyph.
    * @param aElement the SVG glyph element to render
    * @param aContext the thebes aContext to draw to
    * @param aDrawMode fill or stroke or both (see DrawMode)
    * @return true if rendering succeeded
    */
   static bool PaintSVGGlyph(Element* aElement, gfxContext* aContext,
                             DrawMode aDrawMode,
                             gfxTextContextPaint* aContextPaint);
   /**
    * Get the extents of a SVG glyph.
    * @param aElement the SVG glyph element
    * @param aSVGToAppSpace the matrix mapping the SVG glyph space to the
    *   target context space
    * @param aResult the result (valid when true is returned)
    * @return true if calculating the extents succeeded
    */
   static bool GetSVGGlyphExtents(Element* aElement,
                                  const gfxMatrix& aSVGToAppSpace,
                                  gfxRect* aResult);
   /**
    * Returns the app unit canvas bounds of a userspace rect.
    *
    * @param aToCanvas Transform from userspace to canvas device space.
    */
   static nsRect
   ToCanvasBounds(const gfxRect &aUserspaceRect,
                  const gfxMatrix &aToCanvas,
                  const nsPresContext *presContext);
 };
 #endif

The Tor Browser / annotate

layout/svg/nsSVGUtils.h@97036ab72558 (annotated)

layout/svg/nsSVGUtils.h