dom/svg/SVGSVGElement.cpp

   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 #include "mozilla/dom/SVGSVGElement.h"
   8
   9 #include "mozilla/ContentEvents.h"
  10 #include "mozilla/dom/BindContext.h"
  11 #include "mozilla/dom/DOMMatrix.h"
  12 #include "mozilla/dom/SVGSVGElementBinding.h"
  13 #include "mozilla/dom/SVGMatrix.h"
  14 #include "mozilla/dom/SVGRect.h"
  15 #include "mozilla/dom/SVGViewElement.h"
  16 #include "mozilla/EventDispatcher.h"
  17 #include "mozilla/ISVGDisplayableFrame.h"
  18 #include "mozilla/PresShell.h"
  19 #include "mozilla/SMILAnimationController.h"
  20 #include "mozilla/SMILTimeContainer.h"
  21 #include "mozilla/SVGUtils.h"
  22
  23 #include "DOMSVGAngle.h"
  24 #include "DOMSVGLength.h"
  25 #include "DOMSVGNumber.h"
  26 #include "DOMSVGPoint.h"
  27 #include "nsFrameSelection.h"
  28 #include "nsIFrame.h"
  29 #include "ISVGSVGFrame.h"
  30
  31 NS_IMPL_NS_NEW_SVG_ELEMENT_CHECK_PARSER(SVG)
  32
  33 using namespace mozilla::gfx;
  34
  35 namespace mozilla::dom {
  36
  37 using namespace SVGPreserveAspectRatio_Binding;
  38 using namespace SVGSVGElement_Binding;
  39
  40 SVGEnumMapping SVGSVGElement::sZoomAndPanMap[] = {
  41     {nsGkAtoms::disable, SVG_ZOOMANDPAN_DISABLE},
  42     {nsGkAtoms::magnify, SVG_ZOOMANDPAN_MAGNIFY},
  43     {nullptr, 0}};
  44
  45 SVGElement::EnumInfo SVGSVGElement::sEnumInfo[1] = {
  46     {nsGkAtoms::zoomAndPan, sZoomAndPanMap, SVG_ZOOMANDPAN_MAGNIFY}};
  47
  48 JSObject* SVGSVGElement::WrapNode(JSContext* aCx,
  49                                   JS::Handle<JSObject*> aGivenProto) {
  50   return SVGSVGElement_Binding::Wrap(aCx, this, aGivenProto);
  51 }
  52
  53 //----------------------------------------------------------------------
  54 // nsISupports methods
  55
  56 NS_IMPL_CYCLE_COLLECTION_CLASS(SVGSVGElement)
  57
  58 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(SVGSVGElement,
  59                                                 SVGSVGElementBase)
  60   if (tmp->mTimedDocumentRoot) {
  61     tmp->mTimedDocumentRoot->Unlink();
  62   }
  63 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  64 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(SVGSVGElement,
  65                                                   SVGSVGElementBase)
  66   if (tmp->mTimedDocumentRoot) {
  67     tmp->mTimedDocumentRoot->Traverse(&cb);
  68   }
  69 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  70
  71 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SVGSVGElement)
  72   NS_INTERFACE_MAP_ENTRY_CONCRETE(SVGSVGElement)
  73 NS_INTERFACE_MAP_END_INHERITING(SVGSVGElementBase);
  74
  75 NS_IMPL_ADDREF_INHERITED(SVGSVGElement, SVGSVGElementBase)
  76 NS_IMPL_RELEASE_INHERITED(SVGSVGElement, SVGSVGElementBase)
  77
  78 SVGView::SVGView() {
  79   mZoomAndPan.Init(SVGSVGElement::ZOOMANDPAN, SVG_ZOOMANDPAN_MAGNIFY);
  80   mViewBox.Init();
  81   mPreserveAspectRatio.Init();
  82 }
  83
  84 //----------------------------------------------------------------------
  85 // Implementation
  86
  87 SVGSVGElement::SVGSVGElement(
  88     already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
  89     FromParser aFromParser)
  90     : SVGSVGElementBase(std::move(aNodeInfo)),
  91       mCurrentTranslate(0.0f, 0.0f),
  92       mCurrentScale(1.0f),
  93       mStartAnimationOnBindToTree(aFromParser == NOT_FROM_PARSER ||
  94                                   aFromParser == FROM_PARSER_FRAGMENT ||
  95                                   aFromParser == FROM_PARSER_XSLT),
  96       mImageNeedsTransformInvalidation(false) {}
  97
  98 //----------------------------------------------------------------------
  99 // nsINode methods
 100
 101 NS_IMPL_ELEMENT_CLONE_WITH_INIT_AND_PARSER(SVGSVGElement)
 102
 103 //----------------------------------------------------------------------
 104 // nsIDOMSVGSVGElement methods:
 105
 106 already_AddRefed<DOMSVGAnimatedLength> SVGSVGElement::X() {
 107   return mLengthAttributes[ATTR_X].ToDOMAnimatedLength(this);
 108 }
 109
 110 already_AddRefed<DOMSVGAnimatedLength> SVGSVGElement::Y() {
 111   return mLengthAttributes[ATTR_Y].ToDOMAnimatedLength(this);
 112 }
 113
 114 already_AddRefed<DOMSVGAnimatedLength> SVGSVGElement::Width() {
 115   return mLengthAttributes[ATTR_WIDTH].ToDOMAnimatedLength(this);
 116 }
 117
 118 already_AddRefed<DOMSVGAnimatedLength> SVGSVGElement::Height() {
 119   return mLengthAttributes[ATTR_HEIGHT].ToDOMAnimatedLength(this);
 120 }
 121
 122 bool SVGSVGElement::UseCurrentView() const {
 123   return mSVGView || mCurrentViewID;
 124 }
 125
 126 float SVGSVGElement::CurrentScale() const { return mCurrentScale; }
 127
 128 #define CURRENT_SCALE_MAX 16.0f
 129 #define CURRENT_SCALE_MIN 0.0625f
 130
 131 void SVGSVGElement::SetCurrentScale(float aCurrentScale) {
 132   // Prevent bizarre behaviour and maxing out of CPU and memory by clamping
 133   aCurrentScale = clamped(aCurrentScale, CURRENT_SCALE_MIN, CURRENT_SCALE_MAX);
 134
 135   if (aCurrentScale == mCurrentScale) {
 136     return;
 137   }
 138   mCurrentScale = aCurrentScale;
 139
 140   if (IsRootSVGSVGElement()) {
 141     InvalidateTransformNotifyFrame();
 142   }
 143 }
 144
 145 already_AddRefed<DOMSVGPoint> SVGSVGElement::CurrentTranslate() {
 146   return DOMSVGPoint::GetTranslateTearOff(&mCurrentTranslate, this);
 147 }
 148
 149 uint32_t SVGSVGElement::SuspendRedraw(uint32_t max_wait_milliseconds) {
 150   // suspendRedraw is a no-op in Mozilla, so it doesn't matter what
 151   // we return
 152   return 1;
 153 }
 154
 155 void SVGSVGElement::UnsuspendRedraw(uint32_t suspend_handle_id) {
 156   // no-op
 157 }
 158
 159 void SVGSVGElement::UnsuspendRedrawAll() {
 160   // no-op
 161 }
 162
 163 void SVGSVGElement::ForceRedraw() {
 164   // no-op
 165 }
 166
 167 void SVGSVGElement::PauseAnimations() {
 168   if (mTimedDocumentRoot) {
 169     mTimedDocumentRoot->Pause(SMILTimeContainer::PAUSE_SCRIPT);
 170   }
 171   // else we're not the outermost <svg> or not bound to a tree, so silently fail
 172 }
 173
 174 void SVGSVGElement::UnpauseAnimations() {
 175   if (mTimedDocumentRoot) {
 176     mTimedDocumentRoot->Resume(SMILTimeContainer::PAUSE_SCRIPT);
 177   }
 178   // else we're not the outermost <svg> or not bound to a tree, so silently fail
 179 }
 180
 181 bool SVGSVGElement::AnimationsPaused() {
 182   SMILTimeContainer* root = GetTimedDocumentRoot();
 183   return root && root->IsPausedByType(SMILTimeContainer::PAUSE_SCRIPT);
 184 }
 185
 186 float SVGSVGElement::GetCurrentTimeAsFloat() {
 187   SMILTimeContainer* root = GetTimedDocumentRoot();
 188   if (root) {
 189     double fCurrentTimeMs = double(root->GetCurrentTimeAsSMILTime());
 190     return (float)(fCurrentTimeMs / PR_MSEC_PER_SEC);
 191   }
 192   return 0.f;
 193 }
 194
 195 void SVGSVGElement::SetCurrentTime(float seconds) {
 196   if (mTimedDocumentRoot) {
 197     // Make sure the timegraph is up-to-date
 198     FlushAnimations();
 199     double fMilliseconds = double(seconds) * PR_MSEC_PER_SEC;
 200     // Round to nearest whole number before converting, to avoid precision
 201     // errors
 202     SMILTime lMilliseconds = SVGUtils::ClampToInt64(NS_round(fMilliseconds));
 203     mTimedDocumentRoot->SetCurrentTime(lMilliseconds);
 204     AnimationNeedsResample();
 205     // Trigger synchronous sample now, to:
 206     //  - Make sure we get an up-to-date paint after this method
 207     //  - re-enable event firing (it got disabled during seeking, and it
 208     //  doesn't get re-enabled until the first sample after the seek -- so
 209     //  let's make that happen now.)
 210     FlushAnimations();
 211   }
 212   // else we're not the outermost <svg> or not bound to a tree, so silently fail
 213 }
 214
 215 void SVGSVGElement::DeselectAll() {
 216   nsIFrame* frame = GetPrimaryFrame();
 217   if (frame) {
 218     RefPtr<nsFrameSelection> frameSelection = frame->GetFrameSelection();
 219     frameSelection->ClearNormalSelection();
 220   }
 221 }
 222
 223 already_AddRefed<DOMSVGNumber> SVGSVGElement::CreateSVGNumber() {
 224   return do_AddRef(new DOMSVGNumber(this));
 225 }
 226
 227 already_AddRefed<DOMSVGLength> SVGSVGElement::CreateSVGLength() {
 228   return do_AddRef(new DOMSVGLength());
 229 }
 230
 231 already_AddRefed<DOMSVGAngle> SVGSVGElement::CreateSVGAngle() {
 232   return do_AddRef(new DOMSVGAngle(this));
 233 }
 234
 235 already_AddRefed<DOMSVGPoint> SVGSVGElement::CreateSVGPoint() {
 236   return do_AddRef(new DOMSVGPoint(Point(0, 0)));
 237 }
 238
 239 already_AddRefed<SVGMatrix> SVGSVGElement::CreateSVGMatrix() {
 240   return do_AddRef(new SVGMatrix());
 241 }
 242
 243 already_AddRefed<SVGRect> SVGSVGElement::CreateSVGRect() {
 244   return do_AddRef(new SVGRect(this));
 245 }
 246
 247 already_AddRefed<DOMSVGTransform> SVGSVGElement::CreateSVGTransform() {
 248   return do_AddRef(new DOMSVGTransform());
 249 }
 250
 251 already_AddRefed<DOMSVGTransform> SVGSVGElement::CreateSVGTransformFromMatrix(
 252     const DOMMatrix2DInit& matrix, ErrorResult& rv) {
 253   return do_AddRef(new DOMSVGTransform(matrix, rv));
 254 }
 255
 256 void SVGSVGElement::DidChangeTranslate() {
 257   if (Document* doc = GetUncomposedDoc()) {
 258     RefPtr<PresShell> presShell = doc->GetPresShell();
 259     // now dispatch the appropriate event if we are the root element
 260     if (presShell && IsRootSVGSVGElement()) {
 261       nsEventStatus status = nsEventStatus_eIgnore;
 262       WidgetEvent svgScrollEvent(true, eSVGScroll);
 263       presShell->HandleDOMEventWithTarget(this, &svgScrollEvent, &status);
 264       InvalidateTransformNotifyFrame();
 265     }
 266   }
 267 }
 268
 269 //----------------------------------------------------------------------
 270 // SVGZoomAndPanValues
 271 uint16_t SVGSVGElement::ZoomAndPan() const {
 272   return mEnumAttributes[ZOOMANDPAN].GetAnimValue();
 273 }
 274
 275 void SVGSVGElement::SetZoomAndPan(uint16_t aZoomAndPan, ErrorResult& rv) {
 276   if (aZoomAndPan == SVG_ZOOMANDPAN_DISABLE ||
 277       aZoomAndPan == SVG_ZOOMANDPAN_MAGNIFY) {
 278     ErrorResult nestedRv;
 279     mEnumAttributes[ZOOMANDPAN].SetBaseValue(aZoomAndPan, this, nestedRv);
 280     MOZ_ASSERT(!nestedRv.Failed(),
 281                "We already validated our aZoomAndPan value!");
 282     return;
 283   }
 284
 285   rv.ThrowRangeError<MSG_INVALID_ZOOMANDPAN_VALUE_ERROR>();
 286 }
 287
 288 //----------------------------------------------------------------------
 289 SMILTimeContainer* SVGSVGElement::GetTimedDocumentRoot() {
 290   if (mTimedDocumentRoot) {
 291     return mTimedDocumentRoot.get();
 292   }
 293
 294   // We must not be the outermost <svg> element, try to find it
 295   SVGSVGElement* outerSVGElement = SVGContentUtils::GetOuterSVGElement(this);
 296
 297   if (outerSVGElement) {
 298     return outerSVGElement->GetTimedDocumentRoot();
 299   }
 300   // invalid structure
 301   return nullptr;
 302 }
 303 //----------------------------------------------------------------------
 304 // SVGElement
 305 nsresult SVGSVGElement::BindToTree(BindContext& aContext, nsINode& aParent) {
 306   SMILAnimationController* smilController = nullptr;
 307
 308   if (Document* doc = aContext.GetComposedDoc()) {
 309     if ((smilController = doc->GetAnimationController())) {
 310       // SMIL is enabled in this document
 311       if (WillBeOutermostSVG(aParent)) {
 312         // We'll be the outermost <svg> element.  We'll need a time container.
 313         if (!mTimedDocumentRoot) {
 314           mTimedDocumentRoot = MakeUnique<SMILTimeContainer>();
 315         }
 316       } else {
 317         // We're a child of some other <svg> element, so we don't need our own
 318         // time container. However, we need to make sure that we'll get a
 319         // kick-start if we get promoted to be outermost later on.
 320         mTimedDocumentRoot = nullptr;
 321         mStartAnimationOnBindToTree = true;
 322       }
 323     }
 324   }
 325
 326   nsresult rv = SVGGraphicsElement::BindToTree(aContext, aParent);
 327   NS_ENSURE_SUCCESS(rv, rv);
 328
 329   if (mTimedDocumentRoot && smilController) {
 330     rv = mTimedDocumentRoot->SetParent(smilController);
 331     if (mStartAnimationOnBindToTree) {
 332       mTimedDocumentRoot->Begin();
 333       mStartAnimationOnBindToTree = false;
 334     }
 335   }
 336
 337   return rv;
 338 }
 339
 340 void SVGSVGElement::UnbindFromTree(bool aNullParent) {
 341   if (mTimedDocumentRoot) {
 342     mTimedDocumentRoot->SetParent(nullptr);
 343   }
 344
 345   SVGGraphicsElement::UnbindFromTree(aNullParent);
 346 }
 347
 348 SVGAnimatedTransformList* SVGSVGElement::GetAnimatedTransformList(
 349     uint32_t aFlags) {
 350   if (!(aFlags & DO_ALLOCATE) && mSVGView && mSVGView->mTransforms) {
 351     return mSVGView->mTransforms.get();
 352   }
 353   return SVGGraphicsElement::GetAnimatedTransformList(aFlags);
 354 }
 355
 356 void SVGSVGElement::GetEventTargetParent(EventChainPreVisitor& aVisitor) {
 357   if (aVisitor.mEvent->mMessage == eSVGLoad) {
 358     if (mTimedDocumentRoot) {
 359       mTimedDocumentRoot->Begin();
 360       // Set 'resample needed' flag, so that if any script calls a DOM method
 361       // that requires up-to-date animations before our first sample callback,
 362       // we'll force a synchronous sample.
 363       AnimationNeedsResample();
 364     }
 365   }
 366   SVGSVGElementBase::GetEventTargetParent(aVisitor);
 367 }
 368
 369 bool SVGSVGElement::IsEventAttributeNameInternal(nsAtom* aName) {
 370   /* The events in EventNameType_SVGSVG are for events that are only
 371      applicable to outermost 'svg' elements. We don't check if we're an outer
 372      'svg' element in case we're not inserted into the document yet, but since
 373      the target of the events in question will always be the outermost 'svg'
 374      element, this shouldn't cause any real problems.
 375   */
 376   return nsContentUtils::IsEventAttributeName(
 377       aName, (EventNameType_SVGGraphic | EventNameType_SVGSVG));
 378 }
 379
 380 //----------------------------------------------------------------------
 381 // public helpers:
 382
 383 int32_t SVGSVGElement::GetIntrinsicWidth() {
 384   if (mLengthAttributes[ATTR_WIDTH].IsPercentage()) {
 385     return -1;
 386   }
 387   // Passing |this| as a SVGViewportElement* invokes the variant of GetAnimValue
 388   // that uses the passed argument as the context, but that's fine since we
 389   // know the length isn't a percentage so the context won't be used (and we
 390   // need to pass the element to be able to resolve em/ex units).
 391   float width = mLengthAttributes[ATTR_WIDTH].GetAnimValue(this);
 392   return SVGUtils::ClampToInt(width);
 393 }
 394
 395 int32_t SVGSVGElement::GetIntrinsicHeight() {
 396   if (mLengthAttributes[ATTR_HEIGHT].IsPercentage()) {
 397     return -1;
 398   }
 399   // Passing |this| as a SVGViewportElement* invokes the variant of GetAnimValue
 400   // that uses the passed argument as the context, but that's fine since we
 401   // know the length isn't a percentage so the context won't be used (and we
 402   // need to pass the element to be able to resolve em/ex units).
 403   float height = mLengthAttributes[ATTR_HEIGHT].GetAnimValue(this);
 404   return SVGUtils::ClampToInt(height);
 405 }
 406
 407 void SVGSVGElement::FlushImageTransformInvalidation() {
 408   MOZ_ASSERT(!GetParent(), "Should only be called on root node");
 409   MOZ_ASSERT(OwnerDoc()->IsBeingUsedAsImage(),
 410              "Should only be called on image documents");
 411
 412   if (mImageNeedsTransformInvalidation) {
 413     InvalidateTransformNotifyFrame();
 414     mImageNeedsTransformInvalidation = false;
 415   }
 416 }
 417
 418 //----------------------------------------------------------------------
 419 // implementation helpers
 420
 421 bool SVGSVGElement::WillBeOutermostSVG(nsINode& aParent) const {
 422   nsINode* parent = &aParent;
 423   while (parent && parent->IsSVGElement()) {
 424     if (parent->IsSVGElement(nsGkAtoms::foreignObject)) {
 425       // SVG in a foreignObject must have its own <svg> (SVGOuterSVGFrame).
 426       return false;
 427     }
 428     if (parent->IsSVGElement(nsGkAtoms::svg)) {
 429       return false;
 430     }
 431     parent = parent->GetParentOrShadowHostNode();
 432   }
 433
 434   return true;
 435 }
 436
 437 void SVGSVGElement::InvalidateTransformNotifyFrame() {
 438   ISVGSVGFrame* svgframe = do_QueryFrame(GetPrimaryFrame());
 439   // might fail this check if we've failed conditional processing
 440   if (svgframe) {
 441     svgframe->NotifyViewportOrTransformChanged(
 442         ISVGDisplayableFrame::TRANSFORM_CHANGED);
 443   }
 444 }
 445
 446 SVGElement::EnumAttributesInfo SVGSVGElement::GetEnumInfo() {
 447   return EnumAttributesInfo(mEnumAttributes, sEnumInfo, ArrayLength(sEnumInfo));
 448 }
 449
 450 void SVGSVGElement::SetImageOverridePreserveAspectRatio(
 451     const SVGPreserveAspectRatio& aPAR) {
 452   MOZ_ASSERT(OwnerDoc()->IsBeingUsedAsImage(),
 453              "should only override preserveAspectRatio in images");
 454
 455   bool hasViewBox = HasViewBox();
 456   if (!hasViewBox && ShouldSynthesizeViewBox()) {
 457     // My non-<svg:image> clients will have been painting me with a synthesized
 458     // viewBox, but my <svg:image> client that's about to paint me now does NOT
 459     // want that.  Need to tell ourselves to flush our transform.
 460     mImageNeedsTransformInvalidation = true;
 461   }
 462
 463   if (!hasViewBox) {
 464     return;  // preserveAspectRatio irrelevant (only matters if we have viewBox)
 465   }
 466
 467   if (SetPreserveAspectRatioProperty(aPAR)) {
 468     mImageNeedsTransformInvalidation = true;
 469   }
 470 }
 471
 472 void SVGSVGElement::ClearImageOverridePreserveAspectRatio() {
 473   MOZ_ASSERT(OwnerDoc()->IsBeingUsedAsImage(),
 474              "should only override image preserveAspectRatio in images");
 475
 476   if (!HasViewBox() && ShouldSynthesizeViewBox()) {
 477     // My non-<svg:image> clients will want to paint me with a synthesized
 478     // viewBox, but my <svg:image> client that just painted me did NOT
 479     // use that.  Need to tell ourselves to flush our transform.
 480     mImageNeedsTransformInvalidation = true;
 481   }
 482
 483   if (ClearPreserveAspectRatioProperty()) {
 484     mImageNeedsTransformInvalidation = true;
 485   }
 486 }
 487
 488 bool SVGSVGElement::SetPreserveAspectRatioProperty(
 489     const SVGPreserveAspectRatio& aPAR) {
 490   SVGPreserveAspectRatio* pAROverridePtr = new SVGPreserveAspectRatio(aPAR);
 491   nsresult rv =
 492       SetProperty(nsGkAtoms::overridePreserveAspectRatio, pAROverridePtr,
 493                   nsINode::DeleteProperty<SVGPreserveAspectRatio>, true);
 494   MOZ_ASSERT(rv != NS_PROPTABLE_PROP_OVERWRITTEN,
 495              "Setting override value when it's already set...?");
 496
 497   if (MOZ_UNLIKELY(NS_FAILED(rv))) {
 498     // property-insertion failed (e.g. OOM in property-table code)
 499     delete pAROverridePtr;
 500     return false;
 501   }
 502   return true;
 503 }
 504
 505 const SVGPreserveAspectRatio* SVGSVGElement::GetPreserveAspectRatioProperty()
 506     const {
 507   void* valPtr = GetProperty(nsGkAtoms::overridePreserveAspectRatio);
 508   if (valPtr) {
 509     return static_cast<SVGPreserveAspectRatio*>(valPtr);
 510   }
 511   return nullptr;
 512 }
 513
 514 bool SVGSVGElement::ClearPreserveAspectRatioProperty() {
 515   void* valPtr = TakeProperty(nsGkAtoms::overridePreserveAspectRatio);
 516   bool didHaveProperty = !!valPtr;
 517   delete static_cast<SVGPreserveAspectRatio*>(valPtr);
 518   return didHaveProperty;
 519 }
 520
 521 SVGPreserveAspectRatio SVGSVGElement::GetPreserveAspectRatioWithOverride()
 522     const {
 523   Document* doc = GetUncomposedDoc();
 524   if (doc && doc->IsBeingUsedAsImage()) {
 525     const SVGPreserveAspectRatio* pAROverridePtr =
 526         GetPreserveAspectRatioProperty();
 527     if (pAROverridePtr) {
 528       return *pAROverridePtr;
 529     }
 530   }
 531
 532   SVGViewElement* viewElement = GetCurrentViewElement();
 533
 534   // This check is equivalent to "!HasViewBox() &&
 535   // ShouldSynthesizeViewBox()". We're just holding onto the viewElement that
 536   // HasViewBox() would look up, so that we don't have to look it up again
 537   // later.
 538   if (!((viewElement && viewElement->mViewBox.HasRect()) ||
 539         (mSVGView && mSVGView->mViewBox.HasRect()) || mViewBox.HasRect()) &&
 540       ShouldSynthesizeViewBox()) {
 541     // If we're synthesizing a viewBox, use preserveAspectRatio="none";
 542     return SVGPreserveAspectRatio(SVG_PRESERVEASPECTRATIO_NONE,
 543                                   SVG_MEETORSLICE_SLICE);
 544   }
 545
 546   if (viewElement && viewElement->mPreserveAspectRatio.IsExplicitlySet()) {
 547     return viewElement->mPreserveAspectRatio.GetAnimValue();
 548   }
 549   if (mSVGView && mSVGView->mPreserveAspectRatio.IsExplicitlySet()) {
 550     return mSVGView->mPreserveAspectRatio.GetAnimValue();
 551   }
 552   return mPreserveAspectRatio.GetAnimValue();
 553 }
 554
 555 SVGViewElement* SVGSVGElement::GetCurrentViewElement() const {
 556   if (mCurrentViewID) {
 557     // XXXsmaug It is unclear how this should work in case we're in Shadow DOM.
 558     Document* doc = GetUncomposedDoc();
 559     if (doc) {
 560       Element* element = doc->GetElementById(*mCurrentViewID);
 561       if (element && element->IsSVGElement(nsGkAtoms::view)) {
 562         return static_cast<SVGViewElement*>(element);
 563       }
 564     }
 565   }
 566   return nullptr;
 567 }
 568
 569 const SVGAnimatedViewBox& SVGSVGElement::GetViewBoxInternal() const {
 570   SVGViewElement* viewElement = GetCurrentViewElement();
 571
 572   if (viewElement && viewElement->mViewBox.HasRect()) {
 573     return viewElement->mViewBox;
 574   }
 575   if (mSVGView && mSVGView->mViewBox.HasRect()) {
 576     return mSVGView->mViewBox;
 577   }
 578
 579   return mViewBox;
 580 }
 581
 582 SVGAnimatedTransformList* SVGSVGElement::GetTransformInternal() const {
 583   return (mSVGView && mSVGView->mTransforms) ? mSVGView->mTransforms.get()
 584                                              : mTransforms.get();
 585 }
 586
 587 }  // namespace mozilla::dom