Add m-esr52 at 52.6.0

1 files changed, 1192 insertions, 0 deletions

diff --git a/dom/svg/SVGSVGElement.cpp b/dom/svg/SVGSVGElement.cpp
new file mode 100644
index 000000000..90c3c3fff
--- /dev/null
+++ b/dom/svg/SVGSVGElement.cpp
@@ -0,0 +1,1192 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include <stdint.h>
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/ContentEvents.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/Likely.h"
+
+#include "nsGkAtoms.h"
+#include "nsLayoutUtils.h"
+#include "nsLayoutStylesheetCache.h"
+#include "DOMSVGNumber.h"
+#include "DOMSVGLength.h"
+#include "nsSVGAngle.h"
+#include "nsCOMPtr.h"
+#include "nsIPresShell.h"
+#include "nsContentUtils.h"
+#include "nsIDocument.h"
+#include "mozilla/dom/SVGMatrix.h"
+#include "DOMSVGPoint.h"
+#include "nsIFrame.h"
+#include "nsFrameSelection.h"
+#include "nsISVGSVGFrame.h" //XXX
+#include "mozilla/dom/SVGRect.h"
+#include "nsError.h"
+#include "nsISVGChildFrame.h"
+#include "mozilla/dom/SVGSVGElement.h"
+#include "mozilla/dom/SVGSVGElementBinding.h"
+#include "nsSVGUtils.h"
+#include "mozilla/dom/SVGViewElement.h"
+#include "nsStyleUtil.h"
+#include "SVGContentUtils.h"
+
+#include "nsSMILTimeContainer.h"
+#include "nsSMILAnimationController.h"
+#include "nsSMILTypes.h"
+#include "SVGAngle.h"
+#include <algorithm>
+#include "prtime.h"
+
+NS_IMPL_NS_NEW_NAMESPACED_SVG_ELEMENT_CHECK_PARSER(SVG)
+
+using namespace mozilla::gfx;
+
+namespace mozilla {
+namespace dom {
+
+class SVGAnimatedLength;
+
+JSObject*
+SVGSVGElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
+{
+  return SVGSVGElementBinding::Wrap(aCx, this, aGivenProto);
+}
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(DOMSVGTranslatePoint, nsISVGPoint,
+                                   mElement)
+
+NS_IMPL_ADDREF_INHERITED(DOMSVGTranslatePoint, nsISVGPoint)
+NS_IMPL_RELEASE_INHERITED(DOMSVGTranslatePoint, nsISVGPoint)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMSVGTranslatePoint)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  // We have to qualify nsISVGPoint because NS_GET_IID looks for a class in the
+  // global namespace
+  NS_INTERFACE_MAP_ENTRY(mozilla::nsISVGPoint)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+SVGSVGElement::~SVGSVGElement()
+{
+}
+
+DOMSVGPoint*
+DOMSVGTranslatePoint::Copy()
+{
+  return new DOMSVGPoint(mPt.GetX(), mPt.GetY());
+}
+
+nsISupports*
+DOMSVGTranslatePoint::GetParentObject()
+{
+  return static_cast<nsIDOMSVGElement*>(mElement);
+}
+
+void
+DOMSVGTranslatePoint::SetX(float aValue, ErrorResult& rv)
+{
+  mElement->SetCurrentTranslate(aValue, mPt.GetY());
+}
+
+void
+DOMSVGTranslatePoint::SetY(float aValue, ErrorResult& rv)
+{
+  mElement->SetCurrentTranslate(mPt.GetX(), aValue);
+}
+
+already_AddRefed<nsISVGPoint>
+DOMSVGTranslatePoint::MatrixTransform(SVGMatrix& matrix)
+{
+  float a = matrix.A(), b = matrix.B(), c = matrix.C();
+  float d = matrix.D(), e = matrix.E(), f = matrix.F();
+  float x = mPt.GetX();
+  float y = mPt.GetY();
+
+  nsCOMPtr<nsISVGPoint> point = new DOMSVGPoint(a*x + c*y + e, b*x + d*y + f);
+  return point.forget();
+}
+
+SVGView::SVGView()
+{
+  mZoomAndPan.Init(SVGSVGElement::ZOOMANDPAN,
+                   SVG_ZOOMANDPAN_MAGNIFY);
+  mViewBox.Init();
+  mPreserveAspectRatio.Init();
+}
+
+nsSVGElement::LengthInfo SVGSVGElement::sLengthInfo[4] =
+{
+  { &nsGkAtoms::x, 0, nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+  { &nsGkAtoms::y, 0, nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+  { &nsGkAtoms::width, 100, nsIDOMSVGLength::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+  { &nsGkAtoms::height, 100, nsIDOMSVGLength::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+};
+
+nsSVGEnumMapping SVGSVGElement::sZoomAndPanMap[] = {
+  {&nsGkAtoms::disable, SVG_ZOOMANDPAN_DISABLE},
+  {&nsGkAtoms::magnify, SVG_ZOOMANDPAN_MAGNIFY},
+  {nullptr, 0}
+};
+
+nsSVGElement::EnumInfo SVGSVGElement::sEnumInfo[1] =
+{
+  { &nsGkAtoms::zoomAndPan,
+    sZoomAndPanMap,
+    SVG_ZOOMANDPAN_MAGNIFY
+  }
+};
+
+//----------------------------------------------------------------------
+// nsISupports methods
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(SVGSVGElement)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(SVGSVGElement,
+                                                SVGSVGElementBase)
+  if (tmp->mTimedDocumentRoot) {
+    tmp->mTimedDocumentRoot->Unlink();
+  }
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(SVGSVGElement,
+                                                  SVGSVGElementBase)
+  if (tmp->mTimedDocumentRoot) {
+    tmp->mTimedDocumentRoot->Traverse(&cb);
+  }
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_ADDREF_INHERITED(SVGSVGElement,SVGSVGElementBase)
+NS_IMPL_RELEASE_INHERITED(SVGSVGElement,SVGSVGElementBase)
+
+NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(SVGSVGElement)
+  NS_INTERFACE_TABLE_INHERITED(SVGSVGElement, nsIDOMNode, nsIDOMElement,
+                               nsIDOMSVGElement)
+NS_INTERFACE_TABLE_TAIL_INHERITING(SVGSVGElementBase)
+
+//----------------------------------------------------------------------
+// Implementation
+
+SVGSVGElement::SVGSVGElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo,
+                             FromParser aFromParser)
+  : SVGSVGElementBase(aNodeInfo),
+    mViewportWidth(0),
+    mViewportHeight(0),
+    mCurrentTranslate(0.0f, 0.0f),
+    mCurrentScale(1.0f),
+    mPreviousTranslate(0.0f, 0.0f),
+    mPreviousScale(1.0f),
+    mStartAnimationOnBindToTree(aFromParser == NOT_FROM_PARSER ||
+                                aFromParser == FROM_PARSER_FRAGMENT ||
+                                aFromParser == FROM_PARSER_XSLT),
+    mImageNeedsTransformInvalidation(false),
+    mIsPaintingSVGImageElement(false),
+    mHasChildrenOnlyTransform(false)
+{
+}
+
+//----------------------------------------------------------------------
+// nsIDOMNode methods
+
+// From NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGSVGElement)
+nsresult
+SVGSVGElement::Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const
+{
+  *aResult = nullptr;
+  already_AddRefed<mozilla::dom::NodeInfo> ni = RefPtr<mozilla::dom::NodeInfo>(aNodeInfo).forget();
+  SVGSVGElement *it = new SVGSVGElement(ni, NOT_FROM_PARSER);
+
+  nsCOMPtr<nsINode> kungFuDeathGrip = it;
+  nsresult rv1 = it->Init();
+  nsresult rv2 = const_cast<SVGSVGElement*>(this)->CopyInnerTo(it);
+  if (NS_SUCCEEDED(rv1) && NS_SUCCEEDED(rv2)) {
+    kungFuDeathGrip.swap(*aResult);
+  }
+
+  return NS_FAILED(rv1) ? rv1 : rv2;
+}
+
+
+//----------------------------------------------------------------------
+// nsIDOMSVGSVGElement methods:
+
+already_AddRefed<SVGAnimatedLength>
+SVGSVGElement::X()
+{
+  return mLengthAttributes[ATTR_X].ToDOMAnimatedLength(this);
+}
+
+already_AddRefed<SVGAnimatedLength>
+SVGSVGElement::Y()
+{
+  return mLengthAttributes[ATTR_Y].ToDOMAnimatedLength(this);
+}
+
+already_AddRefed<SVGAnimatedLength>
+SVGSVGElement::Width()
+{
+  return mLengthAttributes[ATTR_WIDTH].ToDOMAnimatedLength(this);
+}
+
+already_AddRefed<SVGAnimatedLength>
+SVGSVGElement::Height()
+{
+  return mLengthAttributes[ATTR_HEIGHT].ToDOMAnimatedLength(this);
+}
+
+float
+SVGSVGElement::PixelUnitToMillimeterX()
+{
+  return MM_PER_INCH_FLOAT / 96;
+}
+
+float
+SVGSVGElement::PixelUnitToMillimeterY()
+{
+  return PixelUnitToMillimeterX();
+}
+
+float
+SVGSVGElement::ScreenPixelToMillimeterX()
+{
+  return MM_PER_INCH_FLOAT / 96;
+}
+
+float
+SVGSVGElement::ScreenPixelToMillimeterY()
+{
+  return ScreenPixelToMillimeterX();
+}
+
+bool
+SVGSVGElement::UseCurrentView()
+{
+  return mSVGView || mCurrentViewID;
+}
+
+float
+SVGSVGElement::CurrentScale()
+{
+  return mCurrentScale;
+}
+
+#define CURRENT_SCALE_MAX 16.0f
+#define CURRENT_SCALE_MIN 0.0625f
+
+void
+SVGSVGElement::SetCurrentScale(float aCurrentScale)
+{
+  SetCurrentScaleTranslate(aCurrentScale,
+    mCurrentTranslate.GetX(), mCurrentTranslate.GetY());
+}
+
+already_AddRefed<nsISVGPoint>
+SVGSVGElement::CurrentTranslate()
+{
+  nsCOMPtr<nsISVGPoint> point = new DOMSVGTranslatePoint(&mCurrentTranslate, this);
+  return point.forget();
+}
+
+uint32_t
+SVGSVGElement::SuspendRedraw(uint32_t max_wait_milliseconds)
+{
+  // suspendRedraw is a no-op in Mozilla, so it doesn't matter what
+  // we return
+  return 1;
+}
+
+void
+SVGSVGElement::UnsuspendRedraw(uint32_t suspend_handle_id)
+{
+  // no-op
+}
+
+void
+SVGSVGElement::UnsuspendRedrawAll()
+{
+  // no-op
+}
+
+void
+SVGSVGElement::ForceRedraw()
+{
+  // no-op
+}
+
+void
+SVGSVGElement::PauseAnimations()
+{
+  if (mTimedDocumentRoot) {
+    mTimedDocumentRoot->Pause(nsSMILTimeContainer::PAUSE_SCRIPT);
+  }
+  // else we're not the outermost <svg> or not bound to a tree, so silently fail
+}
+
+void
+SVGSVGElement::UnpauseAnimations()
+{
+  if (mTimedDocumentRoot) {
+    mTimedDocumentRoot->Resume(nsSMILTimeContainer::PAUSE_SCRIPT);
+  }
+  // else we're not the outermost <svg> or not bound to a tree, so silently fail
+}
+
+bool
+SVGSVGElement::AnimationsPaused()
+{
+  nsSMILTimeContainer* root = GetTimedDocumentRoot();
+  return root && root->IsPausedByType(nsSMILTimeContainer::PAUSE_SCRIPT);
+}
+
+float
+SVGSVGElement::GetCurrentTime()
+{
+  nsSMILTimeContainer* root = GetTimedDocumentRoot();
+  if (root) {
+    double fCurrentTimeMs = double(root->GetCurrentTime());
+    return (float)(fCurrentTimeMs / PR_MSEC_PER_SEC);
+  } else {
+    return 0.f;
+  }
+}
+
+void
+SVGSVGElement::SetCurrentTime(float seconds)
+{
+  if (mTimedDocumentRoot) {
+    // Make sure the timegraph is up-to-date
+    FlushAnimations();
+    double fMilliseconds = double(seconds) * PR_MSEC_PER_SEC;
+    // Round to nearest whole number before converting, to avoid precision
+    // errors
+    nsSMILTime lMilliseconds = int64_t(NS_round(fMilliseconds));
+    mTimedDocumentRoot->SetCurrentTime(lMilliseconds);
+    AnimationNeedsResample();
+    // Trigger synchronous sample now, to:
+    //  - Make sure we get an up-to-date paint after this method
+    //  - re-enable event firing (it got disabled during seeking, and it
+    //  doesn't get re-enabled until the first sample after the seek -- so
+    //  let's make that happen now.)
+    FlushAnimations();
+  }
+  // else we're not the outermost <svg> or not bound to a tree, so silently fail
+}
+
+void
+SVGSVGElement::DeselectAll()
+{
+  nsIFrame* frame = GetPrimaryFrame();
+  if (frame) {
+    RefPtr<nsFrameSelection> frameSelection = frame->GetFrameSelection();
+    frameSelection->ClearNormalSelection();
+  }
+}
+
+already_AddRefed<DOMSVGNumber>
+SVGSVGElement::CreateSVGNumber()
+{
+  RefPtr<DOMSVGNumber> number = new DOMSVGNumber(ToSupports(this));
+  return number.forget();
+}
+
+already_AddRefed<DOMSVGLength>
+SVGSVGElement::CreateSVGLength()
+{
+  nsCOMPtr<DOMSVGLength> length = new DOMSVGLength();
+  return length.forget();
+}
+
+already_AddRefed<SVGAngle>
+SVGSVGElement::CreateSVGAngle()
+{
+  nsSVGAngle* angle = new nsSVGAngle();
+  angle->Init();
+  RefPtr<SVGAngle> svgangle = new SVGAngle(angle, this, SVGAngle::CreatedValue);
+  return svgangle.forget();
+}
+
+already_AddRefed<nsISVGPoint>
+SVGSVGElement::CreateSVGPoint()
+{
+  nsCOMPtr<nsISVGPoint> point = new DOMSVGPoint(0, 0);
+  return point.forget();
+}
+
+already_AddRefed<SVGMatrix>
+SVGSVGElement::CreateSVGMatrix()
+{
+  RefPtr<SVGMatrix> matrix = new SVGMatrix();
+  return matrix.forget();
+}
+
+already_AddRefed<SVGIRect>
+SVGSVGElement::CreateSVGRect()
+{
+  return NS_NewSVGRect(this);
+}
+
+already_AddRefed<SVGTransform>
+SVGSVGElement::CreateSVGTransform()
+{
+  RefPtr<SVGTransform> transform = new SVGTransform();
+  return transform.forget();
+}
+
+already_AddRefed<SVGTransform>
+SVGSVGElement::CreateSVGTransformFromMatrix(SVGMatrix& matrix)
+{
+  RefPtr<SVGTransform> transform = new SVGTransform(matrix.GetMatrix());
+  return transform.forget();
+}
+
+//----------------------------------------------------------------------
+
+already_AddRefed<SVGAnimatedRect>
+SVGSVGElement::ViewBox()
+{
+  return mViewBox.ToSVGAnimatedRect(this);
+}
+
+already_AddRefed<DOMSVGAnimatedPreserveAspectRatio>
+SVGSVGElement::PreserveAspectRatio()
+{
+  return mPreserveAspectRatio.ToDOMAnimatedPreserveAspectRatio(this);
+}
+
+uint16_t
+SVGSVGElement::ZoomAndPan()
+{
+  return mEnumAttributes[ZOOMANDPAN].GetAnimValue();
+}
+
+void
+SVGSVGElement::SetZoomAndPan(uint16_t aZoomAndPan, ErrorResult& rv)
+{
+  if (aZoomAndPan == SVG_ZOOMANDPAN_DISABLE ||
+      aZoomAndPan == SVG_ZOOMANDPAN_MAGNIFY) {
+    mEnumAttributes[ZOOMANDPAN].SetBaseValue(aZoomAndPan, this);
+    return;
+  }
+
+  rv.ThrowRangeError<MSG_INVALID_ZOOMANDPAN_VALUE_ERROR>();
+}
+
+//----------------------------------------------------------------------
+// helper methods for implementing SVGZoomEvent:
+
+void
+SVGSVGElement::SetCurrentScaleTranslate(float s, float x, float y)
+{
+  if (s == mCurrentScale &&
+      x == mCurrentTranslate.GetX() && y == mCurrentTranslate.GetY()) {
+    return;
+  }
+
+  // Prevent bizarre behaviour and maxing out of CPU and memory by clamping
+  if (s < CURRENT_SCALE_MIN)
+    s = CURRENT_SCALE_MIN;
+  else if (s > CURRENT_SCALE_MAX)
+    s = CURRENT_SCALE_MAX;
+  
+  // IMPORTANT: If either mCurrentTranslate *or* mCurrentScale is changed then
+  // mPreviousTranslate_x, mPreviousTranslate_y *and* mPreviousScale must all
+  // be updated otherwise SVGZoomEvents will end up with invalid data. I.e. an
+  // SVGZoomEvent's properties previousScale and previousTranslate must contain
+  // the state of currentScale and currentTranslate immediately before the
+  // change that caused the event's dispatch, which is *not* necessarily the
+  // same thing as the values of currentScale and currentTranslate prior to
+  // their own last change.
+  mPreviousScale = mCurrentScale;
+  mPreviousTranslate = mCurrentTranslate;
+  
+  mCurrentScale = s;
+  mCurrentTranslate = SVGPoint(x, y);
+
+  // now dispatch the appropriate event if we are the root element
+  nsIDocument* doc = GetUncomposedDoc();
+  if (doc) {
+    nsCOMPtr<nsIPresShell> presShell = doc->GetShell();
+    if (presShell && IsRoot()) {
+      nsEventStatus status = nsEventStatus_eIgnore;
+      if (mPreviousScale != mCurrentScale) {
+        InternalSVGZoomEvent svgZoomEvent(true, eSVGZoom);
+        presShell->HandleDOMEventWithTarget(this, &svgZoomEvent, &status);
+      } else {
+        WidgetEvent svgScrollEvent(true, eSVGScroll);
+        presShell->HandleDOMEventWithTarget(this, &svgScrollEvent, &status);
+      }
+      InvalidateTransformNotifyFrame();
+    }
+  }
+}
+
+void
+SVGSVGElement::SetCurrentTranslate(float x, float y)
+{
+  SetCurrentScaleTranslate(mCurrentScale, x, y);
+}
+
+nsSMILTimeContainer*
+SVGSVGElement::GetTimedDocumentRoot()
+{
+  if (mTimedDocumentRoot) {
+    return mTimedDocumentRoot;
+  }
+
+  // We must not be the outermost <svg> element, try to find it
+  SVGSVGElement *outerSVGElement =
+    SVGContentUtils::GetOuterSVGElement(this);
+
+  if (outerSVGElement) {
+    return outerSVGElement->GetTimedDocumentRoot();
+  }
+  // invalid structure
+  return nullptr;
+}
+
+//----------------------------------------------------------------------
+// nsIContent methods
+
+NS_IMETHODIMP_(bool)
+SVGSVGElement::IsAttributeMapped(const nsIAtom* name) const
+{
+  // We want to map the 'width' and 'height' attributes into style for
+  // outer-<svg>, except when the attributes aren't set (since their default
+  // values of '100%' can cause unexpected and undesirable behaviour for SVG
+  // inline in HTML). We rely on nsSVGElement::UpdateContentStyleRule() to
+  // prevent mapping of the default values into style (it only maps attributes
+  // that are set). We also rely on a check in nsSVGElement::
+  // UpdateContentStyleRule() to prevent us mapping the attributes when they're
+  // given a <length> value that is not currently recognized by the SVG
+  // specification.
+
+  if (!IsInner() && (name == nsGkAtoms::width || name == nsGkAtoms::height)) {
+    return true;
+  }
+
+  static const MappedAttributeEntry* const map[] = {
+    sColorMap,
+    sFEFloodMap,
+    sFillStrokeMap,
+    sFiltersMap,
+    sFontSpecificationMap,
+    sGradientStopMap,
+    sGraphicsMap,
+    sLightingEffectsMap,
+    sMarkersMap,
+    sTextContentElementsMap,
+    sViewportsMap
+  };
+
+  return FindAttributeDependence(name, map) ||
+    SVGSVGElementBase::IsAttributeMapped(name);
+}
+
+//----------------------------------------------------------------------
+// nsIContent methods:
+
+nsresult
+SVGSVGElement::PreHandleEvent(EventChainPreVisitor& aVisitor)
+{
+  if (aVisitor.mEvent->mMessage == eSVGLoad) {
+    if (mTimedDocumentRoot) {
+      mTimedDocumentRoot->Begin();
+      // Set 'resample needed' flag, so that if any script calls a DOM method
+      // that requires up-to-date animations before our first sample callback,
+      // we'll force a synchronous sample.
+      AnimationNeedsResample();
+    }
+  }
+  return SVGSVGElementBase::PreHandleEvent(aVisitor);
+}
+
+bool
+SVGSVGElement::IsEventAttributeName(nsIAtom* aName)
+{
+  /* The events in EventNameType_SVGSVG are for events that are only
+     applicable to outermost 'svg' elements. We don't check if we're an outer
+     'svg' element in case we're not inserted into the document yet, but since
+     the target of the events in question will always be the outermost 'svg'
+     element, this shouldn't cause any real problems.
+  */
+  return nsContentUtils::IsEventAttributeName(aName,
+         (EventNameType_SVGGraphic | EventNameType_SVGSVG));
+}
+
+//----------------------------------------------------------------------
+// nsSVGElement overrides
+
+// Helper for GetViewBoxTransform on root <svg> node
+// * aLength: internal value for our <svg> width or height attribute.
+// * aViewportLength: length of the corresponding dimension of the viewport.
+// * aSelf: the outermost <svg> node itself.
+// NOTE: aSelf is not an ancestor viewport element, so it can't be used to
+// resolve percentage lengths. (It can only be used to resolve
+// 'em'/'ex'-valued units).
+inline float
+ComputeSynthesizedViewBoxDimension(const nsSVGLength2& aLength,
+                                   float aViewportLength,
+                                   const SVGSVGElement* aSelf)
+{
+  if (aLength.IsPercentage()) {
+    return aViewportLength * aLength.GetAnimValInSpecifiedUnits() / 100.0f;
+  }
+
+  return aLength.GetAnimValue(const_cast<SVGSVGElement*>(aSelf));
+}
+
+//----------------------------------------------------------------------
+// public helpers:
+
+gfx::Matrix
+SVGSVGElement::GetViewBoxTransform() const
+{
+  float viewportWidth, viewportHeight;
+  if (IsInner()) {
+    SVGSVGElement *ctx = GetCtx();
+    viewportWidth = mLengthAttributes[ATTR_WIDTH].GetAnimValue(ctx);
+    viewportHeight = mLengthAttributes[ATTR_HEIGHT].GetAnimValue(ctx);
+  } else {
+    viewportWidth = mViewportWidth;
+    viewportHeight = mViewportHeight;
+  }
+
+  if (viewportWidth <= 0.0f || viewportHeight <= 0.0f) {
+    return gfx::Matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); // singular
+  }
+
+  nsSVGViewBoxRect viewBox =
+    GetViewBoxWithSynthesis(viewportWidth, viewportHeight);
+
+  if (viewBox.width <= 0.0f || viewBox.height <= 0.0f) {
+    return gfx::Matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); // singular
+  }
+
+  return SVGContentUtils::GetViewBoxTransform(viewportWidth, viewportHeight,
+                                              viewBox.x, viewBox.y,
+                                              viewBox.width, viewBox.height,
+                                              GetPreserveAspectRatioWithOverride());
+}
+
+void
+SVGSVGElement::UpdateHasChildrenOnlyTransform()
+{
+  bool hasChildrenOnlyTransform =
+    HasViewBoxOrSyntheticViewBox() ||
+    (IsRoot() && (mCurrentTranslate != SVGPoint(0.0f, 0.0f) ||
+                  mCurrentScale != 1.0f));
+  mHasChildrenOnlyTransform = hasChildrenOnlyTransform;
+}
+
+void
+SVGSVGElement::ChildrenOnlyTransformChanged(uint32_t aFlags)
+{
+  // Avoid wasteful calls:
+  MOZ_ASSERT(!(GetPrimaryFrame()->GetStateBits() & NS_FRAME_IS_NONDISPLAY),
+             "Non-display SVG frames don't maintain overflow rects");
+
+  nsChangeHint changeHint;
+
+  bool hadChildrenOnlyTransform = mHasChildrenOnlyTransform;
+
+  UpdateHasChildrenOnlyTransform();
+
+  if (hadChildrenOnlyTransform != mHasChildrenOnlyTransform) {
+    // Reconstruct the frame tree to handle stacking context changes:
+    // XXXjwatt don't do this for root-<svg> or even outer-<svg>?
+    changeHint = nsChangeHint_ReconstructFrame;
+  } else {
+    // We just assume the old and new transforms are different.
+    changeHint = nsChangeHint(nsChangeHint_UpdateOverflow |
+                              nsChangeHint_ChildrenOnlyTransform);
+  }
+
+  // If we're not reconstructing the frame tree, then we only call
+  // PostRestyleEvent if we're not being called under reflow to avoid recursing
+  // to death. See bug 767056 comments 10 and 12. Since our nsSVGOuterSVGFrame
+  // is being reflowed we're going to invalidate and repaint its entire area
+  // anyway (which will include our children).
+  if ((changeHint & nsChangeHint_ReconstructFrame) ||
+      !(aFlags & eDuringReflow)) {
+    nsLayoutUtils::PostRestyleEvent(this, nsRestyleHint(0), changeHint);
+  }
+}
+
+nsresult
+SVGSVGElement::BindToTree(nsIDocument* aDocument,
+                          nsIContent* aParent,
+                          nsIContent* aBindingParent,
+                          bool aCompileEventHandlers)
+{
+  nsSMILAnimationController* smilController = nullptr;
+
+  if (aDocument) {
+    smilController = aDocument->GetAnimationController();
+    if (smilController) {
+      // SMIL is enabled in this document
+      if (WillBeOutermostSVG(aParent, aBindingParent)) {
+        // We'll be the outermost <svg> element.  We'll need a time container.
+        if (!mTimedDocumentRoot) {
+          mTimedDocumentRoot = new nsSMILTimeContainer();
+        }
+      } else {
+        // We're a child of some other <svg> element, so we don't need our own
+        // time container. However, we need to make sure that we'll get a
+        // kick-start if we get promoted to be outermost later on.
+        mTimedDocumentRoot = nullptr;
+        mStartAnimationOnBindToTree = true;
+      }
+    }
+  }
+
+  nsresult rv = SVGSVGElementBase::BindToTree(aDocument, aParent,
+                                              aBindingParent,
+                                              aCompileEventHandlers);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsIDocument* doc = GetComposedDoc();
+  if (doc) {
+    // Setup the style sheet during binding, not element construction,
+    // because we could move the root SVG element from the document
+    // that created it to another document.
+    auto cache = nsLayoutStylesheetCache::For(doc->GetStyleBackendType());
+    doc->EnsureOnDemandBuiltInUASheet(cache->SVGSheet());
+  }
+
+  if (mTimedDocumentRoot && smilController) {
+    rv = mTimedDocumentRoot->SetParent(smilController);
+    if (mStartAnimationOnBindToTree) {
+      mTimedDocumentRoot->Begin();
+      mStartAnimationOnBindToTree = false;
+    }
+  }
+
+  return rv;
+}
+
+void
+SVGSVGElement::UnbindFromTree(bool aDeep, bool aNullParent)
+{
+  if (mTimedDocumentRoot) {
+    mTimedDocumentRoot->SetParent(nullptr);
+  }
+
+  SVGSVGElementBase::UnbindFromTree(aDeep, aNullParent);
+}
+
+//----------------------------------------------------------------------
+// implementation helpers
+
+bool
+SVGSVGElement::WillBeOutermostSVG(nsIContent* aParent,
+                                  nsIContent* aBindingParent) const
+{
+  nsIContent* parent = aBindingParent ? aBindingParent : aParent;
+
+  while (parent && parent->IsSVGElement()) {
+    if (parent->IsSVGElement(nsGkAtoms::foreignObject)) {
+      // SVG in a foreignObject must have its own <svg> (nsSVGOuterSVGFrame).
+      return false;
+    }
+    if (parent->IsSVGElement(nsGkAtoms::svg)) {
+      return false;
+    }
+    parent = parent->GetParent();
+  }
+
+  return true;
+}
+
+void
+SVGSVGElement::InvalidateTransformNotifyFrame()
+{
+  nsISVGSVGFrame* svgframe = do_QueryFrame(GetPrimaryFrame());
+  // might fail this check if we've failed conditional processing
+  if (svgframe) {
+    svgframe->NotifyViewportOrTransformChanged(
+                nsISVGChildFrame::TRANSFORM_CHANGED);
+  }
+}
+
+bool
+SVGSVGElement::HasPreserveAspectRatio()
+{
+  return HasAttr(kNameSpaceID_None, nsGkAtoms::preserveAspectRatio) ||
+    mPreserveAspectRatio.IsAnimated();
+}
+
+SVGViewElement*
+SVGSVGElement::GetCurrentViewElement() const
+{
+  if (mCurrentViewID) {
+    //XXXsmaug It is unclear how this should work in case we're in Shadow DOM.
+    nsIDocument* doc = GetUncomposedDoc();
+    if (doc) {
+      Element *element = doc->GetElementById(*mCurrentViewID);
+      if (element && element->IsSVGElement(nsGkAtoms::view)) {
+        return static_cast<SVGViewElement*>(element);
+      }
+    }
+  }
+  return nullptr;
+}
+
+nsSVGViewBoxRect
+SVGSVGElement::GetViewBoxWithSynthesis(
+  float aViewportWidth, float aViewportHeight) const
+{
+  // The logic here should match HasViewBoxRect().
+  SVGViewElement* viewElement = GetCurrentViewElement();
+  if (viewElement && viewElement->mViewBox.HasRect()) {
+    return viewElement->mViewBox.GetAnimValue();
+  }
+  if (mSVGView && mSVGView->mViewBox.HasRect()) {
+    return mSVGView->mViewBox.GetAnimValue();
+  }
+  if (mViewBox.HasRect()) {
+    return mViewBox.GetAnimValue();
+  }
+
+  if (ShouldSynthesizeViewBox()) {
+    // Special case -- fake a viewBox, using height & width attrs.
+    // (Use |this| as context, since if we get here, we're outermost <svg>.)
+    return nsSVGViewBoxRect(0, 0,
+              ComputeSynthesizedViewBoxDimension(mLengthAttributes[ATTR_WIDTH],
+                                                 mViewportWidth, this),
+              ComputeSynthesizedViewBoxDimension(mLengthAttributes[ATTR_HEIGHT],
+                                                 mViewportHeight, this));
+
+  }
+
+  // No viewBox attribute, so we shouldn't auto-scale. This is equivalent
+  // to having a viewBox that exactly matches our viewport size.
+  return nsSVGViewBoxRect(0, 0, aViewportWidth, aViewportHeight);
+}
+
+SVGPreserveAspectRatio
+SVGSVGElement::GetPreserveAspectRatioWithOverride() const
+{
+  nsIDocument* doc = GetUncomposedDoc();
+  if (doc && doc->IsBeingUsedAsImage()) {
+    const SVGPreserveAspectRatio *pAROverridePtr = GetPreserveAspectRatioProperty();
+    if (pAROverridePtr) {
+      return *pAROverridePtr;
+    }
+  }
+
+  SVGViewElement* viewElement = GetCurrentViewElement();
+
+  // This check is equivalent to "!HasViewBoxRect() && ShouldSynthesizeViewBox()".
+  // We're just holding onto the viewElement that HasViewBoxRect() would look up,
+  // so that we don't have to look it up again later.
+  if (!((viewElement && viewElement->mViewBox.HasRect()) ||
+        (mSVGView && mSVGView->mViewBox.HasRect()) ||
+        mViewBox.HasRect()) &&
+      ShouldSynthesizeViewBox()) {
+    // If we're synthesizing a viewBox, use preserveAspectRatio="none";
+    return SVGPreserveAspectRatio(SVG_PRESERVEASPECTRATIO_NONE, SVG_MEETORSLICE_SLICE);
+  }
+
+  if (viewElement && viewElement->mPreserveAspectRatio.IsExplicitlySet()) {
+    return viewElement->mPreserveAspectRatio.GetAnimValue();
+  }
+  if (mSVGView && mSVGView->mPreserveAspectRatio.IsExplicitlySet()) {
+    return mSVGView->mPreserveAspectRatio.GetAnimValue();
+  }
+  return mPreserveAspectRatio.GetAnimValue();
+}
+
+//----------------------------------------------------------------------
+// SVGSVGElement
+
+float
+SVGSVGElement::GetLength(uint8_t aCtxType)
+{
+  float h, w;
+
+  SVGViewElement* viewElement = GetCurrentViewElement();
+  const nsSVGViewBoxRect* viewbox = nullptr;
+
+  // The logic here should match HasViewBoxRect().
+  if (viewElement && viewElement->mViewBox.HasRect()) {
+    viewbox = &viewElement->mViewBox.GetAnimValue();
+  } else if (mSVGView && mSVGView->mViewBox.HasRect()) {
+    viewbox = &mSVGView->mViewBox.GetAnimValue();
+  } else if (mViewBox.HasRect()) {
+    viewbox = &mViewBox.GetAnimValue();
+  }
+
+  if (viewbox) {
+    w = viewbox->width;
+    h = viewbox->height;
+  } else if (IsInner()) {
+    SVGSVGElement *ctx = GetCtx();
+    w = mLengthAttributes[ATTR_WIDTH].GetAnimValue(ctx);
+    h = mLengthAttributes[ATTR_HEIGHT].GetAnimValue(ctx);
+  } else if (ShouldSynthesizeViewBox()) {
+    w = ComputeSynthesizedViewBoxDimension(mLengthAttributes[ATTR_WIDTH],
+                                           mViewportWidth, this);
+    h = ComputeSynthesizedViewBoxDimension(mLengthAttributes[ATTR_HEIGHT],
+                                           mViewportHeight, this);
+  } else {
+    w = mViewportWidth;
+    h = mViewportHeight;
+  }
+
+  w = std::max(w, 0.0f);
+  h = std::max(h, 0.0f);
+
+  switch (aCtxType) {
+  case SVGContentUtils::X:
+    return w;
+  case SVGContentUtils::Y:
+    return h;
+  case SVGContentUtils::XY:
+    return float(SVGContentUtils::ComputeNormalizedHypotenuse(w, h));
+  }
+  return 0;
+}
+
+//----------------------------------------------------------------------
+// nsSVGElement methods
+
+/* virtual */ gfxMatrix
+SVGSVGElement::PrependLocalTransformsTo(
+  const gfxMatrix &aMatrix, SVGTransformTypes aWhich) const
+{
+  // 'transform' attribute (or an override from a fragment identifier):
+  gfxMatrix fromUserSpace =
+    SVGContentUtils::PrependLocalTransformsTo(
+      aMatrix, aWhich, mAnimateMotionTransform,
+      mSVGView && mSVGView->mTransforms ? mSVGView->mTransforms : mTransforms);
+
+  if (aWhich == eUserSpaceToParent) {
+    return fromUserSpace;
+  }
+
+  if (IsInner()) {
+    float x, y;
+    const_cast<SVGSVGElement*>(this)->GetAnimatedLengthValues(&x, &y, nullptr);
+    if (aWhich == eAllTransforms) {
+      // the common case
+      return ThebesMatrix(GetViewBoxTransform()) * gfxMatrix::Translation(x, y) * fromUserSpace;
+    }
+    MOZ_ASSERT(aWhich == eChildToUserSpace, "Unknown TransformTypes");
+    return ThebesMatrix(GetViewBoxTransform()) * gfxMatrix::Translation(x, y) * aMatrix;
+  }
+
+  if (IsRoot()) {
+    gfxMatrix zoomPanTM;
+    zoomPanTM.Translate(gfxPoint(mCurrentTranslate.GetX(), mCurrentTranslate.GetY()));
+    zoomPanTM.Scale(mCurrentScale, mCurrentScale);
+    return ThebesMatrix(GetViewBoxTransform()) * zoomPanTM * fromUserSpace;
+  }
+
+  // outer-<svg>, but inline in some other content:
+  return ThebesMatrix(GetViewBoxTransform()) * fromUserSpace;
+}
+
+nsSVGAnimatedTransformList*
+SVGSVGElement::GetAnimatedTransformList(uint32_t aFlags)
+{
+  if (!(aFlags & DO_ALLOCATE) && mSVGView && mSVGView->mTransforms) {
+    return mSVGView->mTransforms;
+  }
+  return SVGSVGElementBase::GetAnimatedTransformList(aFlags);
+}
+
+/* virtual */ bool
+SVGSVGElement::HasValidDimensions() const
+{
+  return !IsInner() ||
+    ((!mLengthAttributes[ATTR_WIDTH].IsExplicitlySet() ||
+       mLengthAttributes[ATTR_WIDTH].GetAnimValInSpecifiedUnits() > 0) &&
+     (!mLengthAttributes[ATTR_HEIGHT].IsExplicitlySet() ||
+       mLengthAttributes[ATTR_HEIGHT].GetAnimValInSpecifiedUnits() > 0));
+}
+
+nsSVGElement::LengthAttributesInfo
+SVGSVGElement::GetLengthInfo()
+{
+  return LengthAttributesInfo(mLengthAttributes, sLengthInfo,
+                              ArrayLength(sLengthInfo));
+}
+
+nsSVGElement::EnumAttributesInfo
+SVGSVGElement::GetEnumInfo()
+{
+  return EnumAttributesInfo(mEnumAttributes, sEnumInfo,
+                            ArrayLength(sEnumInfo));
+}
+
+nsSVGViewBox*
+SVGSVGElement::GetViewBox()
+{
+  return &mViewBox;
+}
+
+SVGAnimatedPreserveAspectRatio *
+SVGSVGElement::GetPreserveAspectRatio()
+{
+  return &mPreserveAspectRatio;
+}
+
+bool
+SVGSVGElement::HasViewBoxRect() const
+{
+  SVGViewElement* viewElement = GetCurrentViewElement();
+  if ((viewElement && viewElement->mViewBox.HasRect()) ||
+      (mSVGView && mSVGView->mViewBox.HasRect())) {
+    return true;
+  }
+  return mViewBox.HasRect();
+}
+
+bool
+SVGSVGElement::ShouldSynthesizeViewBox() const
+{
+  MOZ_ASSERT(!HasViewBoxRect(),
+             "Should only be called if we lack a viewBox");
+
+  nsIDocument* doc = GetUncomposedDoc();
+  return doc &&
+    doc->IsBeingUsedAsImage() &&
+    !mIsPaintingSVGImageElement &&
+    !GetParent();
+}
+
+bool
+SVGSVGElement::SetPreserveAspectRatioProperty(const SVGPreserveAspectRatio& aPAR)
+{
+  SVGPreserveAspectRatio* pAROverridePtr = new SVGPreserveAspectRatio(aPAR);
+  nsresult rv = SetProperty(nsGkAtoms::overridePreserveAspectRatio,
+                            pAROverridePtr,
+                            nsINode::DeleteProperty<SVGPreserveAspectRatio>,
+                            true);
+  MOZ_ASSERT(rv != NS_PROPTABLE_PROP_OVERWRITTEN,
+             "Setting override value when it's already set...?");
+
+  if (MOZ_UNLIKELY(NS_FAILED(rv))) {
+    // property-insertion failed (e.g. OOM in property-table code)
+    delete pAROverridePtr;
+    return false;
+  }
+  return true;
+}
+
+const SVGPreserveAspectRatio*
+SVGSVGElement::GetPreserveAspectRatioProperty() const
+{
+  void* valPtr = GetProperty(nsGkAtoms::overridePreserveAspectRatio);
+  if (valPtr) {
+    return static_cast<SVGPreserveAspectRatio*>(valPtr);
+  }
+  return nullptr;
+}
+
+bool
+SVGSVGElement::ClearPreserveAspectRatioProperty()
+{
+  void* valPtr = UnsetProperty(nsGkAtoms::overridePreserveAspectRatio);
+  delete static_cast<SVGPreserveAspectRatio*>(valPtr);
+  return valPtr;
+}
+
+void
+SVGSVGElement::SetIsPaintingForSVGImageElement(bool aIsPaintingSVGImageElement)
+{
+  mIsPaintingSVGImageElement = aIsPaintingSVGImageElement;
+}
+
+void
+SVGSVGElement::
+  SetImageOverridePreserveAspectRatio(const SVGPreserveAspectRatio& aPAR)
+{
+#ifdef DEBUG
+  MOZ_ASSERT(OwnerDoc()->IsBeingUsedAsImage(),
+             "should only override preserveAspectRatio in images");
+#endif
+
+  bool hasViewBoxRect = HasViewBoxRect();
+  if (!hasViewBoxRect && ShouldSynthesizeViewBox()) {
+    // My non-<svg:image> clients will have been painting me with a synthesized
+    // viewBox, but my <svg:image> client that's about to paint me now does NOT
+    // want that.  Need to tell ourselves to flush our transform.
+    mImageNeedsTransformInvalidation = true;
+  }
+
+  if (!hasViewBoxRect) {
+    return; // preserveAspectRatio irrelevant (only matters if we have viewBox)
+  }
+
+  if (SetPreserveAspectRatioProperty(aPAR)) {
+    mImageNeedsTransformInvalidation = true;
+  }
+}
+
+void
+SVGSVGElement::ClearImageOverridePreserveAspectRatio()
+{
+#ifdef DEBUG
+  MOZ_ASSERT(OwnerDoc()->IsBeingUsedAsImage(),
+             "should only override image preserveAspectRatio in images");
+#endif
+
+  if (!HasViewBoxRect() && ShouldSynthesizeViewBox()) {
+    // My non-<svg:image> clients will want to paint me with a synthesized
+    // viewBox, but my <svg:image> client that just painted me did NOT
+    // use that.  Need to tell ourselves to flush our transform.
+    mImageNeedsTransformInvalidation = true;
+  }
+
+  if (ClearPreserveAspectRatioProperty()) {
+    mImageNeedsTransformInvalidation = true;
+  }
+}
+
+void
+SVGSVGElement::FlushImageTransformInvalidation()
+{
+  MOZ_ASSERT(!GetParent(), "Should only be called on root node");
+  MOZ_ASSERT(OwnerDoc()->IsBeingUsedAsImage(),
+             "Should only be called on image documents");
+
+  if (mImageNeedsTransformInvalidation) {
+    InvalidateTransformNotifyFrame();
+    mImageNeedsTransformInvalidation = false;
+  }
+}
+
+int32_t
+SVGSVGElement::GetIntrinsicWidth()
+{
+  if (mLengthAttributes[ATTR_WIDTH].IsPercentage()) {
+    return -1;
+  }
+  // Passing |this| as a SVGSVGElement* invokes the variant of GetAnimValue
+  // that uses the passed argument as the context, but that's fine since we
+  // know the length isn't a percentage so the context won't be used (and we
+  // need to pass the element to be able to resolve em/ex units).
+  float width = mLengthAttributes[ATTR_WIDTH].GetAnimValue(this);
+  return nsSVGUtils::ClampToInt(width);
+}
+
+int32_t
+SVGSVGElement::GetIntrinsicHeight()
+{
+  if (mLengthAttributes[ATTR_HEIGHT].IsPercentage()) {
+    return -1;
+  }
+  // Passing |this| as a SVGSVGElement* invokes the variant of GetAnimValue
+  // that uses the passed argument as the context, but that's fine since we
+  // know the length isn't a percentage so the context won't be used (and we
+  // need to pass the element to be able to resolve em/ex units).
+  float height = mLengthAttributes[ATTR_HEIGHT].GetAnimValue(this);
+  return nsSVGUtils::ClampToInt(height);
+}
+
+} // namespace dom
+} // namespace mozilla