Rework SVGViewSpec<->SVGSVGElement integration

third_party/WebKit/Source/core/svg/SVGSVGElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Google, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 21 matching lines @@
 #include "core/dom/StyleChangeReason.h"
 #include "core/editing/FrameSelection.h"
 #include "core/events/EventListener.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/svg/LayoutSVGModelObject.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/layout/svg/LayoutSVGViewportContainer.h"
-#include "core/page/FrameTree.h"
 #include "core/svg/SVGAngleTearOff.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGLengthTearOff.h"
 #include "core/svg/SVGMatrixTearOff.h"
 #include "core/svg/SVGNumberTearOff.h"
 #include "core/svg/SVGPointTearOff.h"
 #include "core/svg/SVGPreserveAspectRatio.h"
 #include "core/svg/SVGRectTearOff.h"
 #include "core/svg/SVGTransform.h"
 #include "core/svg/SVGTransformList.h"
@@ skipping 22 matching lines @@
                                     CSSPropertyY)),
       m_width(SVGAnimatedLength::create(this,
                                         SVGNames::widthAttr,
                                         SVGLength::create(SVGLengthMode::Width),
                                         CSSPropertyWidth)),
       m_height(
           SVGAnimatedLength::create(this,
                                     SVGNames::heightAttr,
                                     SVGLength::create(SVGLengthMode::Height),
                                     CSSPropertyHeight)),
-      m_useCurrentView(false),
       m_timeContainer(SMILTimeContainer::create(*this)),
       m_translation(SVGPoint::create()),
       m_currentScale(1) {
   m_width->setDefaultValueAsString("100%");
   m_height->setDefaultValueAsString("100%");
 
   addToPropertyMap(m_x);
   addToPropertyMap(m_y);
   addToPropertyMap(m_width);
   addToPropertyMap(m_height);
 
   UseCounter::count(doc, UseCounter::SVGSVGElement);
 }
 
 DEFINE_NODE_FACTORY(SVGSVGElement)
 
 SVGSVGElement::~SVGSVGElement() {}
 
-SVGViewSpec& SVGSVGElement::ensureViewSpec() {
-  if (!m_viewSpec)
-    m_viewSpec = SVGViewSpec::create();
-  return *m_viewSpec;
-}
-
 float SVGSVGElement::currentScale() const {
   if (!isConnected() || !isOutermostSVGSVGElement())
     return 1;
 
   return m_currentScale;
 }
 
 void SVGSVGElement::setCurrentScale(float scale) {
   ASSERT(std::isfinite(scale));
   if (!isConnected() || !isOutermostSVGSVGElement())
@@ skipping 31 matching lines @@
 }
 
 void SVGSVGElement::updateUserTransform() {
   if (LayoutObject* object = layoutObject())
     object->setNeedsLayoutAndFullPaintInvalidation(
         LayoutInvalidationReason::Unknown);
 }
 
 bool SVGSVGElement::zoomAndPanEnabled() const {
   SVGZoomAndPanType zoomAndPan = this->zoomAndPan();
-  if (m_useCurrentView)
+  if (m_viewSpec)
     zoomAndPan = m_viewSpec->zoomAndPan();
   return zoomAndPan == SVGZoomAndPanMagnify;
 }
 
 void SVGSVGElement::parseAttribute(const QualifiedName& name,
                                    const AtomicString& oldValue,
                                    const AtomicString& value) {
   if (!nearestViewportElement()) {
     bool setListener = true;
 
@@ skipping 418 matching lines @@
          m_width->currentValue()->isRelative() ||
          m_height->currentValue()->isRelative();
 }
 
 bool SVGSVGElement::shouldSynthesizeViewBox() const {
   return layoutObject() && layoutObject()->isSVGRoot() &&
          toLayoutSVGRoot(layoutObject())->isEmbeddedThroughSVGImage();
 }
 
 FloatRect SVGSVGElement::currentViewBoxRect() const {
-  if (m_useCurrentView) {
-    DCHECK(m_viewSpec);
+  if (m_viewSpec)
     return m_viewSpec->viewBox()->value();
-  }
 
   FloatRect useViewBox = viewBox()->currentValue()->value();
   if (!useViewBox.isEmpty())
     return useViewBox;
   if (!shouldSynthesizeViewBox())
     return FloatRect();
 
   // If no viewBox is specified but non-relative width/height values, then we
   // should always synthesize a viewBox if we're embedded through a SVGImage.
   FloatSize synthesizedViewBoxSize(intrinsicWidth(), intrinsicHeight());
   if (!hasIntrinsicWidth())
     synthesizedViewBoxSize.setWidth(width()->currentValue()->scaleByPercentage(
         currentViewportSize().width()));
   if (!hasIntrinsicHeight())
     synthesizedViewBoxSize.setHeight(
         height()->currentValue()->scaleByPercentage(
             currentViewportSize().height()));
   return FloatRect(FloatPoint(), synthesizedViewBoxSize);
 }
 
 SVGPreserveAspectRatio* SVGSVGElement::currentPreserveAspectRatio() const {
-  if (m_useCurrentView) {
-    DCHECK(m_viewSpec);
+  if (m_viewSpec)
     return m_viewSpec->preserveAspectRatio();
-  }
+
   if (!viewBox()->currentValue()->isValid() && shouldSynthesizeViewBox()) {
     // If no viewBox is specified and we're embedded through SVGImage, then
     // synthesize a pAR with the value 'none'.
     SVGPreserveAspectRatio* synthesizedPAR = SVGPreserveAspectRatio::create();
     synthesizedPAR->setAlign(
         SVGPreserveAspectRatio::kSvgPreserveaspectratioNone);
     return synthesizedPAR;
   }
   return preserveAspectRatio()->currentValue();
 }
@@ skipping 41 matching lines @@
 
   SVGLengthContext lengthContext(this);
   return height()->currentValue()->value(lengthContext);
 }
 
 AffineTransform SVGSVGElement::viewBoxToViewTransform(float viewWidth,
                                                       float viewHeight) const {
   AffineTransform ctm = SVGFitToViewBox::viewBoxToViewTransform(
       currentViewBoxRect(), currentPreserveAspectRatio(), viewWidth,
       viewHeight);
-  if (!m_useCurrentView)
+  if (!m_viewSpec)
     return ctm;
-  DCHECK(m_viewSpec);
 
   SVGTransformList* transformList = m_viewSpec->transform();
   if (transformList->isEmpty())
     return ctm;
 
   AffineTransform transform;
   if (transformList->concatenate(transform))
     ctm *= transform;
 
   return ctm;
 }
 
+void SVGSVGElement::setViewSpec(SVGViewSpec* viewSpec) {
+  // Even if the viewspec object itself doesn't change, it could still
+  // have been mutated, so only treat a "no viewspec" -> "no viewspec"
+  // transition as a no-op.
+  if (!m_viewSpec && !viewSpec)
+    return;
+  m_viewSpec = viewSpec;
+  if (LayoutObject* layoutObject = this->layoutObject())
+    markForLayoutAndParentResourceInvalidation(layoutObject);
+}
+
 void SVGSVGElement::setupInitialView(const String& fragmentIdentifier,
                                      Element* anchorNode) {
-  if (m_viewSpec)
-    m_viewSpec->reset();
-
-  // If we previously had a view, we need to layout again, regardless of the
-  // state after setting.
-  bool needsViewUpdate = m_useCurrentView;
-  m_useCurrentView = false;
-
   if (fragmentIdentifier.startsWith("svgView(")) {
-    // Ensure the SVGViewSpec has been created.
-    SVGViewSpec& view = ensureViewSpec();
-    view.inheritViewAttributesFromElement(this);
-
-    if (view.parseViewSpec(fragmentIdentifier)) {
+    SVGViewSpec* viewSpec = SVGViewSpec::createForElement(*this);
+    if (viewSpec->parseViewSpec(fragmentIdentifier)) {
       UseCounter::count(document(), UseCounter::SVGSVGElementFragmentSVGView);
-      m_useCurrentView = true;
-      needsViewUpdate = true;
-    } else {
-      view.reset();
-    }
-  } else if (isSVGViewElement(anchorNode)) {
-    // Spec: If the SVG fragment identifier addresses a 'view' element
-    // within an SVG document (e.g., MyDrawing.svg#MyView or
-    // MyDrawing.svg#xpointer(id('MyView'))) then the closest ancestor
-    // 'svg' element is displayed in the viewport.  Any view specification
-    // attributes included on the given 'view' element override the
-    // corresponding view specification attributes on the closest ancestor
-    // 'svg' element.
-    // TODO(ed): The spec text above is a bit unclear.
-    // Should the transform from outermost svg to nested svg be applied to
-    // "display" the inner svg in the viewport, then let the view element
-    // override the inner svg's view specification attributes. Should it
-    // fill/override the outer viewport?
-    SVGViewElement& viewElement = toSVGViewElement(*anchorNode);
-
-    if (SVGSVGElement* svg = viewElement.ownerSVGElement()) {
-      svg->inheritViewAttributes(&viewElement);
-
-      if (LayoutObject* layoutObject = svg->layoutObject())
-        markForLayoutAndParentResourceInvalidation(layoutObject);
-
+      setViewSpec(viewSpec);
       return;
     }
   }
 
-  LayoutObject* layoutObject = this->layoutObject();
-  if (layoutObject && needsViewUpdate)
-    markForLayoutAndParentResourceInvalidation(layoutObject);
+  setViewSpec(nullptr);
 
-  // If m_useCurrentView is true we should have a view-spec.
-  DCHECK(!m_useCurrentView || m_viewSpec);
+  if (!isSVGViewElement(anchorNode))
+    return;
 
-  // FIXME: We need to decide which <svg> to focus on, and zoom to it.
-  // FIXME: We need to actually "highlight" the viewTarget(s).
-}
+  SVGViewElement& viewElement = toSVGViewElement(*anchorNode);
 
-void SVGSVGElement::inheritViewAttributes(SVGViewElement* viewElement) {
-  SVGViewSpec& view = ensureViewSpec();
-  m_useCurrentView = true;
-  UseCounter::count(document(),
+  // Spec: If the SVG fragment identifier addresses a 'view' element
+  // within an SVG document (e.g., MyDrawing.svg#MyView) then the
+  // closest ancestor 'svg' element is displayed in the
+  // viewport. Any view specification attributes included on the
+  // given 'view' element override the corresponding view
+  // specification attributes on the closest ancestor 'svg' element.
+  // TODO(ed): The spec text above is a bit unclear.
+  // Should the transform from outermost svg to nested svg be applied to
+  // "display" the inner svg in the viewport, then let the view element
+  // override the inner svg's view specification attributes. Should it
+  // fill/override the outer viewport?
+  SVGSVGElement* svg = viewElement.ownerSVGElement();
+  if (!svg)
+    return;
+  SVGViewSpec* viewSpec = SVGViewSpec::createForElement(*svg);
+  viewSpec->inheritViewAttributesFromElement(viewElement);
+  UseCounter::count(svg->document(),
                     UseCounter::SVGSVGElementFragmentSVGViewElement);
-  view.inheritViewAttributesFromElement(this);
-  view.inheritViewAttributesFromElement(viewElement);
-  DCHECK(!m_useCurrentView || m_viewSpec);
+  svg->setViewSpec(viewSpec);
 }
 
 void SVGSVGElement::finishParsingChildren() {
   SVGGraphicsElement::finishParsingChildren();
 
   // The outermost SVGSVGElement SVGLoad event is fired through
   // LocalDOMWindow::dispatchWindowLoadEvent.
   if (isOutermostSVGSVGElement())
     return;
 
   // finishParsingChildren() is called when the close tag is reached for an
   // element (e.g. </svg>) we send SVGLoad events here if we can, otherwise
   // they'll be sent when any required loads finish
   sendSVGLoadEventIfPossible();
 }
 
 DEFINE_TRACE(SVGSVGElement) {
   visitor->trace(m_x);
   visitor->trace(m_y);
   visitor->trace(m_width);
   visitor->trace(m_height);
   visitor->trace(m_translation);
   visitor->trace(m_timeContainer);
   visitor->trace(m_viewSpec);
   SVGGraphicsElement::trace(visitor);
   SVGFitToViewBox::trace(visitor);
 }
 
 }  // namespace blink