The Tor Browser: layout/svg/nsSVGClipPathFrame.cpp@97036ab72558 (annotated)

layout/svg/nsSVGClipPathFrame.cpp@97036ab72558 (annotated)

layout/svg/nsSVGClipPathFrame.cpp

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/. */
 // Main header first:
 #include "nsSVGClipPathFrame.h"
 // Keep others in (case-insensitive) order:
 #include "gfxContext.h"
 #include "nsGkAtoms.h"
 #include "nsRenderingContext.h"
 #include "mozilla/dom/SVGClipPathElement.h"
 #include "nsSVGEffects.h"
 #include "nsSVGUtils.h"
 using namespace mozilla::dom;
 //----------------------------------------------------------------------
 // Implementation
 nsIFrame*
 NS_NewSVGClipPathFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
 {
   return new (aPresShell) nsSVGClipPathFrame(aContext);
 }
 NS_IMPL_FRAMEARENA_HELPERS(nsSVGClipPathFrame)
 nsresult
 nsSVGClipPathFrame::ClipPaint(nsRenderingContext* aContext,
                               nsIFrame* aParent,
                               const gfxMatrix &aMatrix)
 {
   // If the flag is set when we get here, it means this clipPath frame
   // has already been used painting the current clip, and the document
   // has a clip reference loop.
   if (mInUse) {
     NS_WARNING("Clip loop detected!");
     return NS_OK;
   }
   AutoClipPathReferencer clipRef(this);
   mClipParent = aParent;
   if (mClipParentMatrix) {
     *mClipParentMatrix = aMatrix;
   } else {
     mClipParentMatrix = new gfxMatrix(aMatrix);
   }
   gfxContext *gfx = aContext->ThebesContext();
   nsISVGChildFrame *singleClipPathChild = nullptr;
   if (IsTrivial(&singleClipPathChild)) {
     // Notify our child that it's painting as part of a clipPath, and that
     // we only require it to draw its path (it should skip filling, etc.):
     SVGAutoRenderState mode(aContext, SVGAutoRenderState::CLIP);
     if (!singleClipPathChild) {
       // We have no children - the spec says clip away everything:
       gfx->Rectangle(gfxRect());
     } else {
       singleClipPathChild->NotifySVGChanged(
                              nsISVGChildFrame::TRANSFORM_CHANGED);
       singleClipPathChild->PaintSVG(aContext, nullptr);
     }
     gfx->Clip();
     gfx->NewPath();
     return NS_OK;
   }
   // Seems like this is a non-trivial clipPath, so we need to use a clip mask.
   // Notify our children that they're painting into a clip mask:
   SVGAutoRenderState mode(aContext, SVGAutoRenderState::CLIP_MASK);
   // Check if this clipPath is itself clipped by another clipPath:
   nsSVGClipPathFrame *clipPathFrame =
     nsSVGEffects::GetEffectProperties(this).GetClipPathFrame(nullptr);
   bool referencedClipIsTrivial;
   if (clipPathFrame) {
     referencedClipIsTrivial = clipPathFrame->IsTrivial();
     gfx->Save();
     if (referencedClipIsTrivial) {
       clipPathFrame->ClipPaint(aContext, aParent, aMatrix);
     } else {
       gfx->PushGroup(gfxContentType::ALPHA);
     }
   }
   for (nsIFrame* kid = mFrames.FirstChild(); kid;
        kid = kid->GetNextSibling()) {
     nsISVGChildFrame* SVGFrame = do_QueryFrame(kid);
     if (SVGFrame) {
       // The CTM of each frame referencing us can be different.
       SVGFrame->NotifySVGChanged(nsISVGChildFrame::TRANSFORM_CHANGED);
       bool isOK = true;
       nsSVGClipPathFrame *clipPathFrame =
         nsSVGEffects::GetEffectProperties(kid).GetClipPathFrame(&isOK);
       if (!isOK) {
         continue;
       }
       bool isTrivial;
       if (clipPathFrame) {
         isTrivial = clipPathFrame->IsTrivial();
         gfx->Save();
         if (isTrivial) {
           clipPathFrame->ClipPaint(aContext, aParent, aMatrix);
         } else {
           gfx->PushGroup(gfxContentType::ALPHA);
         }
       }
       SVGFrame->PaintSVG(aContext, nullptr);
       if (clipPathFrame) {
         if (!isTrivial) {
           gfx->PopGroupToSource();
           nsRefPtr<gfxPattern> clipMaskSurface;
           gfx->PushGroup(gfxContentType::ALPHA);
           clipPathFrame->ClipPaint(aContext, aParent, aMatrix);
           clipMaskSurface = gfx->PopGroup();
           if (clipMaskSurface) {
             gfx->Mask(clipMaskSurface);
           }
         }
         gfx->Restore();
       }
     }
   }
   if (clipPathFrame) {
     if (!referencedClipIsTrivial) {
       gfx->PopGroupToSource();
       nsRefPtr<gfxPattern> clipMaskSurface;
       gfx->PushGroup(gfxContentType::ALPHA);
       clipPathFrame->ClipPaint(aContext, aParent, aMatrix);
       clipMaskSurface = gfx->PopGroup();
       if (clipMaskSurface) {
         gfx->Mask(clipMaskSurface);
       }
     }
     gfx->Restore();
   }
   return NS_OK;
 }
 bool
 nsSVGClipPathFrame::ClipHitTest(nsIFrame* aParent,
                                 const gfxMatrix &aMatrix,
                                 const nsPoint &aPoint)
 {
   // If the flag is set when we get here, it means this clipPath frame
   // has already been used in hit testing against the current clip,
   // and the document has a clip reference loop.
   if (mInUse) {
     NS_WARNING("Clip loop detected!");
     return false;
   }
   AutoClipPathReferencer clipRef(this);
   mClipParent = aParent;
   if (mClipParentMatrix) {
     *mClipParentMatrix = aMatrix;
   } else {
     mClipParentMatrix = new gfxMatrix(aMatrix);
   }
   nsSVGClipPathFrame *clipPathFrame =
     nsSVGEffects::GetEffectProperties(this).GetClipPathFrame(nullptr);
   if (clipPathFrame && !clipPathFrame->ClipHitTest(aParent, aMatrix, aPoint))
     return false;
   for (nsIFrame* kid = mFrames.FirstChild(); kid;
        kid = kid->GetNextSibling()) {
     nsISVGChildFrame* SVGFrame = do_QueryFrame(kid);
     if (SVGFrame) {
       // Notify the child frame that we may be working with a
       // different transform, so it can update its covered region
       // (used to shortcut hit testing).
       SVGFrame->NotifySVGChanged(nsISVGChildFrame::TRANSFORM_CHANGED);
       if (SVGFrame->GetFrameForPoint(aPoint))
         return true;
     }
   }
   return false;
 }
 bool
 nsSVGClipPathFrame::IsTrivial(nsISVGChildFrame **aSingleChild)
 {
   // If the clip path is clipped then it's non-trivial
   if (nsSVGEffects::GetEffectProperties(this).GetClipPathFrame(nullptr))
     return false;
   if (aSingleChild) {
     *aSingleChild = nullptr;
   }
   nsISVGChildFrame *foundChild = nullptr;
   for (nsIFrame* kid = mFrames.FirstChild(); kid;
        kid = kid->GetNextSibling()) {
     nsISVGChildFrame *svgChild = do_QueryFrame(kid);
     if (svgChild) {
       // We consider a non-trivial clipPath to be one containing
       // either more than one svg child and/or a svg container
       if (foundChild || svgChild->IsDisplayContainer())
         return false;
       // or where the child is itself clipped
       if (nsSVGEffects::GetEffectProperties(kid).GetClipPathFrame(nullptr))
         return false;
       foundChild = svgChild;
     }
   }
   if (aSingleChild) {
     *aSingleChild = foundChild;
   }
   return true;
 }
 bool
 nsSVGClipPathFrame::IsValid()
 {
   if (mInUse) {
     NS_WARNING("Clip loop detected!");
     return false;
   }
   AutoClipPathReferencer clipRef(this);
   bool isOK = true;
   nsSVGEffects::GetEffectProperties(this).GetClipPathFrame(&isOK);
   if (!isOK) {
     return false;
   }
   for (nsIFrame* kid = mFrames.FirstChild(); kid;
        kid = kid->GetNextSibling()) {
     nsIAtom *type = kid->GetType();
     if (type == nsGkAtoms::svgUseFrame) {
       for (nsIFrame* grandKid = kid->GetFirstPrincipalChild(); grandKid;
            grandKid = grandKid->GetNextSibling()) {
         nsIAtom *type = grandKid->GetType();
         if (type != nsGkAtoms::svgPathGeometryFrame &&
             type != nsGkAtoms::svgTextFrame) {
           return false;
         }
       }
       continue;
     }
     if (type != nsGkAtoms::svgPathGeometryFrame &&
         type != nsGkAtoms::svgTextFrame) {
       return false;
     }
   }
   return true;
 }
 nsresult
 nsSVGClipPathFrame::AttributeChanged(int32_t         aNameSpaceID,
                                      nsIAtom*        aAttribute,
                                      int32_t         aModType)
 {
   if (aNameSpaceID == kNameSpaceID_None) {
     if (aAttribute == nsGkAtoms::transform) {
       nsSVGEffects::InvalidateDirectRenderingObservers(this);
       nsSVGUtils::NotifyChildrenOfSVGChange(this,
                                             nsISVGChildFrame::TRANSFORM_CHANGED);
     }
     if (aAttribute == nsGkAtoms::clipPathUnits) {
       nsSVGEffects::InvalidateRenderingObservers(this);
     }
   }
   return nsSVGClipPathFrameBase::AttributeChanged(aNameSpaceID,
                                                   aAttribute, aModType);
 }
 void
 nsSVGClipPathFrame::Init(nsIContent* aContent,
                          nsIFrame* aParent,
                          nsIFrame* aPrevInFlow)
 {
   NS_ASSERTION(aContent->IsSVG(nsGkAtoms::clipPath),
                "Content is not an SVG clipPath!");
   AddStateBits(NS_STATE_SVG_CLIPPATH_CHILD);
   nsSVGClipPathFrameBase::Init(aContent, aParent, aPrevInFlow);
 }
 nsIAtom *
 nsSVGClipPathFrame::GetType() const
 {
   return nsGkAtoms::svgClipPathFrame;
 }
 gfxMatrix
 nsSVGClipPathFrame::GetCanvasTM(uint32_t aFor, nsIFrame* aTransformRoot)
 {
   SVGClipPathElement *content = static_cast<SVGClipPathElement*>(mContent);
   gfxMatrix tm =
     content->PrependLocalTransformsTo(mClipParentMatrix ?
                                       *mClipParentMatrix : gfxMatrix());
   return nsSVGUtils::AdjustMatrixForUnits(tm,
                                           &content->mEnumAttributes[SVGClipPathElement::CLIPPATHUNITS],
                                           mClipParent);
 }

The Tor Browser / annotate

layout/svg/nsSVGClipPathFrame.cpp@97036ab72558 (annotated)

layout/svg/nsSVGClipPathFrame.cpp