reflow comments in core/svg/

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

 /*
- * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann
+ * <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Alp Toker <alp@atoker.com>
  * Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
  *
  * 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 80 matching lines @@
 
 short SVGElement::tabIndex() const {
   if (supportsFocus())
     return Element::tabIndex();
   return -1;
 }
 
 void SVGElement::willRecalcStyle(StyleRecalcChange change) {
   if (!hasSVGRareData())
     return;
-  // If the style changes because of a regular property change (not induced by SMIL animations themselves)
-  // reset the "computed style without SMIL style properties", so the base value change gets reflected.
+  // If the style changes because of a regular property change (not induced by
+  // SMIL animations themselves) reset the "computed style without SMIL style
+  // properties", so the base value change gets reflected.
   if (change > NoChange || needsStyleRecalc())
     svgRareData()->setNeedsOverrideComputedStyleUpdate();
 }
 
 void SVGElement::buildPendingResourcesIfNeeded() {
   Document& document = this->document();
   if (!needsPendingResourceHandling() || !isConnected() || inUseShadowTree())
     return;
 
   SVGDocumentExtensions& extensions = document.accessSVGExtensions();
   AtomicString resourceId = getIdAttribute();
   if (!extensions.hasPendingResource(resourceId))
     return;
 
   // Mark pending resources as pending for removal.
   extensions.markPendingResourcesForRemoval(resourceId);
 
-  // Rebuild pending resources for each client of a pending resource that is being removed.
+  // Rebuild pending resources for each client of a pending resource that is
+  // being removed.
   while (
       Element* clientElement =
           extensions.removeElementFromPendingResourcesForRemoval(resourceId)) {
     ASSERT(clientElement->hasPendingResources());
     if (clientElement->hasPendingResources()) {
-      // FIXME: Ideally we'd always resolve pending resources async instead of inside
-      // insertedInto and svgAttributeChanged. For now we only do it for <use> since
-      // that would stamp out DOM.
+      // FIXME: Ideally we'd always resolve pending resources async instead of
+      // inside insertedInto and svgAttributeChanged. For now we only do it for
+      // <use> since that would stamp out DOM.
       if (isSVGUseElement(clientElement))
         toSVGUseElement(clientElement)->invalidateShadowTree();
       else
         clientElement->buildPendingResource();
       extensions.clearHasPendingResourcesIfPossible(clientElement);
     }
   }
 }
 
 SVGElementRareData* SVGElement::ensureSVGRareData() {
   if (hasSVGRareData())
     return svgRareData();
 
   m_SVGRareData = new SVGElementRareData(this);
   return m_SVGRareData.get();
 }
 
 bool SVGElement::isOutermostSVGSVGElement() const {
   if (!isSVGSVGElement(*this))
     return false;
 
-  // Element may not be in the document, pretend we're outermost for viewport(), getCTM(), etc.
+  // Element may not be in the document, pretend we're outermost for viewport(),
+  // getCTM(), etc.
   if (!parentNode())
     return true;
 
-  // We act like an outermost SVG element, if we're a direct child of a <foreignObject> element.
+  // We act like an outermost SVG element, if we're a direct child of a
+  // <foreignObject> element.
   if (isSVGForeignObjectElement(*parentNode()))
     return true;
 
-  // If we're living in a shadow tree, we're a <svg> element that got created as replacement
-  // for a <symbol> element or a cloned <svg> element in the referenced tree. In that case
-  // we're always an inner <svg> element.
+  // If we're living in a shadow tree, we're a <svg> element that got created as
+  // replacement for a <symbol> element or a cloned <svg> element in the
+  // referenced tree. In that case we're always an inner <svg> element.
   if (inUseShadowTree() && parentOrShadowHostElement() &&
       parentOrShadowHostElement()->isSVGElement())
     return false;
 
-  // This is true whenever this is the outermost SVG, even if there are HTML elements outside it
+  // This is true whenever this is the outermost SVG, even if there are HTML
+  // elements outside it
   return !parentNode()->isSVGElement();
 }
 
 void SVGElement::reportAttributeParsingError(SVGParsingError error,
                                              const QualifiedName& name,
                                              const AtomicString& value) {
   if (error == SVGParseStatus::NoError)
     return;
   // Don't report any errors on attribute removal.
   if (value.isNull())
     return;
   document().accessSVGExtensions().reportError(
       error.format(tagName(), name, value));
 }
 
 String SVGElement::title() const {
-  // According to spec, we should not return titles when hovering over root <svg> elements (those
-  // <title> elements are the title of the document, not a tooltip) so we instantly return.
+  // According to spec, we should not return titles when hovering over root
+  // <svg> elements (those <title> elements are the title of the document, not a
+  // tooltip) so we instantly return.
   if (isOutermostSVGSVGElement())
     return String();
 
   if (inUseShadowTree()) {
     String useTitle(ownerShadowHost()->title());
     if (!useTitle.isEmpty())
       return useTitle;
   }
 
-  // If we aren't an instance in a <use> or the <use> title was not found, then find the first
-  // <title> child of this element.
+  // If we aren't an instance in a <use> or the <use> title was not found, then
+  // find the first <title> child of this element.
   // If a title child was found, return the text contents.
   if (Element* titleElement = Traversal<SVGTitleElement>::firstChild(*this))
     return titleElement->innerText();
 
   // Otherwise return a null/empty string.
   return String();
 }
 
 bool SVGElement::instanceUpdatesBlocked() const {
   return hasSVGRareData() && svgRareData()->instanceUpdatesBlocked();
@@ skipping 87 matching lines @@
 
 void SVGElement::clearAnimatedAttribute(const QualifiedName& attribute) {
   forSelfAndInstances(this, [&attribute](SVGElement* element) {
     if (SVGAnimatedPropertyBase* animatedProperty =
             element->propertyFromAttribute(attribute))
       animatedProperty->animationEnded();
   });
 }
 
 AffineTransform SVGElement::localCoordinateSpaceTransform(CTMScope) const {
-  // To be overriden by SVGGraphicsElement (or as special case SVGTextElement and SVGPatternElement)
+  // To be overriden by SVGGraphicsElement (or as special case SVGTextElement
+  // and SVGPatternElement)
   return AffineTransform();
 }
 
 Node::InsertionNotificationRequest SVGElement::insertedInto(
     ContainerNode* rootParent) {
   Element::insertedInto(rootParent);
   updateRelativeLengthsInformation();
   buildPendingResourcesIfNeeded();
   return InsertionDone;
 }
 
 void SVGElement::removedFrom(ContainerNode* rootParent) {
   bool wasInDocument = rootParent->isConnected();
 
   if (wasInDocument && hasRelativeLengths()) {
-    // The root of the subtree being removed should take itself out from its parent's relative
-    // length set. For the other nodes in the subtree we don't need to do anything: they will
-    // get their own removedFrom() notification and just clear their sets.
+    // The root of the subtree being removed should take itself out from its
+    // parent's relative length set. For the other nodes in the subtree we don't
+    // need to do anything: they will get their own removedFrom() notification
+    // and just clear their sets.
     if (rootParent->isSVGElement() && !parentNode()) {
       ASSERT(toSVGElement(rootParent)
                  ->m_elementsWithRelativeLengths.contains(this));
       toSVGElement(rootParent)->updateRelativeLengthsInformation(false, this);
     }
 
     m_elementsWithRelativeLengths.clear();
   }
 
   ASSERT_WITH_SECURITY_IMPLICATION(
@@ skipping 19 matching lines @@
 }
 
 CSSPropertyID SVGElement::cssPropertyIdForSVGAttributeName(
     const QualifiedName& attrName) {
   if (!attrName.namespaceURI().isNull())
     return CSSPropertyInvalid;
 
   static HashMap<StringImpl*, CSSPropertyID>* propertyNameToIdMap = 0;
   if (!propertyNameToIdMap) {
     propertyNameToIdMap = new HashMap<StringImpl*, CSSPropertyID>;
-    // This is a list of all base CSS and SVG CSS properties which are exposed as SVG XML attributes
+    // This is a list of all base CSS and SVG CSS properties which are exposed
+    // as SVG XML attributes
     const QualifiedName* const attrNames[] = {
         &alignment_baselineAttr,
         &baseline_shiftAttr,
         &buffered_renderingAttr,
         &clipAttr,
         &clip_pathAttr,
         &clip_ruleAttr,
         &SVGNames::colorAttr,
         &color_interpolationAttr,
         &color_interpolation_filtersAttr,
@@ skipping 54 matching lines @@
     }
   }
 
   return propertyNameToIdMap->get(attrName.localName().impl());
 }
 
 void SVGElement::updateRelativeLengthsInformation(bool clientHasRelativeLengths,
                                                   SVGElement* clientElement) {
   ASSERT(clientElement);
 
-  // If we're not yet in a document, this function will be called again from insertedInto(). Do nothing now.
+  // If we're not yet in a document, this function will be called again from
+  // insertedInto(). Do nothing now.
   if (!isConnected())
     return;
 
   // An element wants to notify us that its own relative lengths state changed.
-  // Register it in the relative length map, and register us in the parent relative length map.
-  // Register the parent in the grandparents map, etc. Repeat procedure until the root of the SVG tree.
+  // Register it in the relative length map, and register us in the parent
+  // relative length map.  Register the parent in the grandparents map, etc.
+  // Repeat procedure until the root of the SVG tree.
   for (Node& currentNode : NodeTraversal::inclusiveAncestorsOf(*this)) {
     if (!currentNode.isSVGElement())
       break;
     SVGElement& currentElement = toSVGElement(currentNode);
     ASSERT(!currentElement.m_inRelativeLengthClientsInvalidation);
 
     bool hadRelativeLengths = currentElement.hasRelativeLengths();
     if (clientHasRelativeLengths)
       currentElement.m_elementsWithRelativeLengths.add(clientElement);
     else
       currentElement.m_elementsWithRelativeLengths.remove(clientElement);
 
-    // If the relative length state hasn't changed, we can stop propagating the notification.
+    // If the relative length state hasn't changed, we can stop propagating the
+    // notification.
     if (hadRelativeLengths == currentElement.hasRelativeLengths())
       return;
 
     clientElement = &currentElement;
     clientHasRelativeLengths = clientElement->hasRelativeLengths();
   }
 
   // Register root SVG elements for top level viewport change notifications.
   if (isSVGSVGElement(*clientElement)) {
     SVGDocumentExtensions& svgExtensions = accessDocumentSVGExtensions();
@@ skipping 38 matching lines @@
     if (isSVGSVGElement(*n))
       return toSVGSVGElement(n);
 
     n = n->parentOrShadowHostNode();
   }
 
   return nullptr;
 }
 
 SVGElement* SVGElement::viewportElement() const {
-  // This function needs shadow tree support - as LayoutSVGContainer uses this function
-  // to determine the "overflow" property. <use> on <symbol> wouldn't work otherwhise.
+  // This function needs shadow tree support - as LayoutSVGContainer uses this
+  // function to determine the "overflow" property. <use> on <symbol> wouldn't
+  // work otherwhise.
   ContainerNode* n = parentOrShadowHostNode();
   while (n) {
     if (isSVGSVGElement(*n) || isSVGImageElement(*n) || isSVGSymbolElement(*n))
       return toSVGElement(n);
 
     n = n->parentOrShadowHostNode();
   }
 
   return nullptr;
 }
@@ skipping 295 matching lines @@
 bool SVGElement::sendSVGLoadEventIfPossible() {
   if (!haveLoadedRequiredResources())
     return false;
   if ((isStructurallyExternal() || isSVGSVGElement(*this)) &&
       hasLoadListener(this))
     dispatchEvent(Event::create(EventTypeNames::load));
   return true;
 }
 
 void SVGElement::sendSVGLoadEventToSelfAndAncestorChainIfPossible() {
-  // Let Document::implicitClose() dispatch the 'load' to the outermost SVG root.
+  // Let Document::implicitClose() dispatch the 'load' to the outermost SVG
+  // root.
   if (isOutermostSVGSVGElement())
     return;
 
-  // Save the next parent to dispatch to in case dispatching the event mutates the tree.
+  // Save the next parent to dispatch to in case dispatching the event mutates
+  // the tree.
   Element* parent = parentOrShadowHostElement();
   if (!sendSVGLoadEventIfPossible())
     return;
 
   // If document/window 'load' has been sent already, then only deliver to
   // the element in question.
   if (document().loadEventFinished())
     return;
 
   if (!parent || !parent->isSVGElement())
     return;
 
   toSVGElement(parent)->sendSVGLoadEventToSelfAndAncestorChainIfPossible();
 }
 
 void SVGElement::attributeChanged(const QualifiedName& name,
                                   const AtomicString& oldValue,
                                   const AtomicString& newValue,
                                   AttributeModificationReason) {
   Element::attributeChanged(name, oldValue, newValue);
 
   if (name == HTMLNames::idAttr)
     rebuildAllIncomingReferences();
 
-  // Changes to the style attribute are processed lazily (see Element::getAttribute() and related methods),
-  // so we don't want changes to the style attribute to result in extra work here.
+  // Changes to the style attribute are processed lazily (see
+  // Element::getAttribute() and related methods), so we don't want changes to
+  // the style attribute to result in extra work here.
   if (name == HTMLNames::styleAttr)
     return;
 
   svgAttributeBaseValChanged(name);
 }
 
 void SVGElement::svgAttributeChanged(const QualifiedName& attrName) {
   CSSPropertyID propId = SVGElement::cssPropertyIdForSVGAttributeName(attrName);
   if (propId > 0) {
     invalidateInstances();
     return;
   }
 
   if (attrName == HTMLNames::classAttr) {
     classAttributeChanged(AtomicString(m_className->currentValue()->value()));
     invalidateInstances();
     return;
   }
 
   if (attrName == HTMLNames::idAttr) {
     LayoutObject* object = layoutObject();
-    // Notify resources about id changes, this is important as we cache resources by id in SVGDocumentExtensions
+    // Notify resources about id changes, this is important as we cache
+    // resources by id in SVGDocumentExtensions
     if (object && object->isSVGResourceContainer())
       toLayoutSVGResourceContainer(object)->idChanged();
     if (isConnected())
       buildPendingResourcesIfNeeded();
     invalidateInstances();
     return;
   }
 }
 
 void SVGElement::svgAttributeBaseValChanged(const QualifiedName& attribute) {
   svgAttributeChanged(attribute);
 
   if (!hasSVGRareData() || svgRareData()->webAnimatedAttributes().isEmpty())
     return;
 
-  // TODO(alancutter): Only mark attributes as dirty if their animation depends on the underlying value.
+  // TODO(alancutter): Only mark attributes as dirty if their animation depends
+  // on the underlying value.
   svgRareData()->setWebAnimatedAttributesDirty(true);
   elementData()->m_animatedSVGAttributesAreDirty = true;
 }
 
 void SVGElement::ensureAttributeAnimValUpdated() {
   if (!RuntimeEnabledFeatures::webAnimationsSVGEnabled())
     return;
 
   if ((hasSVGRareData() && svgRareData()->webAnimatedAttributesDirty()) ||
       (elementAnimations() &&
        DocumentAnimations::needsAnimationTimingUpdate(document()))) {
     DocumentAnimations::updateAnimationTimingIfNeeded(document());
     applyActiveWebAnimations();
   }
 }
 
 void SVGElement::synchronizeAnimatedSVGAttribute(
     const QualifiedName& name) const {
   if (!elementData() || !elementData()->m_animatedSVGAttributesAreDirty)
     return;
 
-  // We const_cast here because we have deferred baseVal mutation animation updates to this point in time.
+  // We const_cast here because we have deferred baseVal mutation animation
+  // updates to this point in time.
   const_cast<SVGElement*>(this)->ensureAttributeAnimValUpdated();
 
   if (name == anyQName()) {
     AttributeToPropertyMap::const_iterator::ValuesIterator it =
         m_attributeToPropertyMap.values().begin();
     AttributeToPropertyMap::const_iterator::ValuesIterator end =
         m_attributeToPropertyMap.values().end();
     for (; it != end; ++it) {
       if ((*it)->needsSynchronizeAttribute())
         (*it)->synchronizeAttribute();
@@ skipping 232 matching lines @@
     return;
 
   const SVGElementSet& incomingReferences = svgRareData()->incomingReferences();
 
   // Iterate on a snapshot as |incomingReferences| may be altered inside loop.
   HeapVector<Member<SVGElement>> incomingReferencesSnapshot;
   copyToVector(incomingReferences, incomingReferencesSnapshot);
 
   // Force rebuilding the |sourceElement| so it knows about this change.
   for (SVGElement* sourceElement : incomingReferencesSnapshot) {
-    // Before rebuilding |sourceElement| ensure it was not removed from under us.
+    // Before rebuilding |sourceElement| ensure it was not removed from under
+    // us.
     if (incomingReferences.contains(sourceElement))
       sourceElement->svgAttributeChanged(SVGNames::hrefAttr);
   }
 }
 
 void SVGElement::removeAllIncomingReferences() {
   if (!hasSVGRareData())
     return;
 
   SVGElementSet& incomingReferences = svgRareData()->incomingReferences();
@@ skipping 23 matching lines @@
   visitor->trace(m_className);
   Element::trace(visitor);
 }
 
 const AtomicString& SVGElement::eventParameterName() {
   DEFINE_STATIC_LOCAL(const AtomicString, evtString, ("evt"));
   return evtString;
 }
 
 }  // namespace blink