Reflow comments in core/dom/.

third_party/WebKit/Source/core/dom/Element.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003-2011, 2013, 2014 Apple Inc. All rights reserved.
  *
  * 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
@@ skipping 123 matching lines @@
   DEFINE_ATTRIBUTE_EVENT_LISTENER(gotpointercapture);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(lostpointercapture);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(paste);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(search);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(selectstart);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(wheel);
 
   bool hasAttribute(const QualifiedName&) const;
   const AtomicString& getAttribute(const QualifiedName&) const;
 
-  // Passing nullAtom as the second parameter removes the attribute when calling either of these set methods.
+  // Passing nullAtom as the second parameter removes the attribute when calling
+  // either of these set methods.
   void setAttribute(const QualifiedName&, const AtomicString& value);
   void setSynchronizedLazyAttribute(const QualifiedName&,
                                     const AtomicString& value);
 
   void removeAttribute(const QualifiedName&);
 
   // Typed getters and setters for language bindings.
   int getIntegralAttribute(const QualifiedName& attributeName) const;
   void setIntegralAttribute(const QualifiedName& attributeName, int value);
   void setUnsignedIntegralAttribute(const QualifiedName& attributeName,
                                     unsigned value);
   double getFloatingPointAttribute(
       const QualifiedName& attributeName,
       double fallbackValue = std::numeric_limits<double>::quiet_NaN()) const;
   void setFloatingPointAttribute(const QualifiedName& attributeName,
                                  double value);
 
-  // Call this to get the value of an attribute that is known not to be the style
-  // attribute or one of the SVG animatable attributes.
+  // Call this to get the value of an attribute that is known not to be the
+  // style attribute or one of the SVG animatable attributes.
   bool fastHasAttribute(const QualifiedName&) const;
   const AtomicString& fastGetAttribute(const QualifiedName&) const;
 #if DCHECK_IS_ON()
   bool fastAttributeLookupAllowed(const QualifiedName&) const;
 #endif
 
 #ifdef DUMP_NODE_STATISTICS
   bool hasNamedNodeMap() const;
 #endif
   bool hasAttributes() const;
@@ skipping 19 matching lines @@
                       ExceptionState&);
 
   const AtomicString& getIdAttribute() const;
   void setIdAttribute(const AtomicString&);
 
   const AtomicString& getNameAttribute() const;
   const AtomicString& getClassAttribute() const;
 
   bool shouldIgnoreAttributeCase() const;
 
-  // Call this to get the value of the id attribute for style resolution purposes.
-  // The value will already be lowercased if the document is in compatibility mode,
-  // so this function is not suitable for non-style uses.
+  // Call this to get the value of the id attribute for style resolution
+  // purposes.  The value will already be lowercased if the document is in
+  // compatibility mode, so this function is not suitable for non-style uses.
   const AtomicString& idForStyleResolution() const;
 
   // This getter takes care of synchronizing all attributes before returning the
-  // AttributeCollection. If the Element has no attributes, an empty AttributeCollection
-  // will be returned. This is not a trivial getter and its return value should be cached
-  // for performance.
+  // AttributeCollection. If the Element has no attributes, an empty
+  // AttributeCollection will be returned. This is not a trivial getter and its
+  // return value should be cached for performance.
   AttributeCollection attributes() const;
-  // This variant will not update the potentially invalid attributes. To be used when not interested
-  // in style attribute or one of the SVG animation attributes.
+  // This variant will not update the potentially invalid attributes. To be used
+  // when not interested in style attribute or one of the SVG animation
+  // attributes.
   AttributeCollection attributesWithoutUpdate() const;
 
   void scrollIntoView(bool alignToTop = true);
   void scrollIntoViewIfNeeded(bool centerIfNeeded = true);
 
   int offsetLeft();
   int offsetTop();
   int offsetWidth();
   int offsetHeight();
 
@@ skipping 57 matching lines @@
   bool hasTagName(const QualifiedName& tagName) const {
     return m_tagName.matches(tagName);
   }
   bool hasTagName(const HTMLQualifiedName& tagName) const {
     return ContainerNode::hasTagName(tagName);
   }
   bool hasTagName(const SVGQualifiedName& tagName) const {
     return ContainerNode::hasTagName(tagName);
   }
 
-  // Should be called only by Document::createElementNS to fix up m_tagName immediately after construction.
+  // Should be called only by Document::createElementNS to fix up m_tagName
+  // immediately after construction.
   void setTagNameForCreateElementNS(const QualifiedName&);
 
   // A fast function for checking the local name against another atomic string.
   bool hasLocalName(const AtomicString& other) const {
     return m_tagName.localName() == other;
   }
 
   const AtomicString& localName() const { return m_tagName.localName(); }
   AtomicString localNameForSelectorMatching() const;
   const AtomicString& prefix() const { return m_tagName.prefix(); }
@@ skipping 61 matching lines @@
   virtual void parseAttribute(const QualifiedName&,
                               const AtomicString& oldValue,
                               const AtomicString& newValue);
 
   virtual bool hasLegalLinkAttribute(const QualifiedName&) const;
   virtual const QualifiedName& subResourceAttributeName() const;
 
   // Only called by the parser immediately after element construction.
   void parserSetAttributes(const Vector<Attribute>&);
 
-  // Remove attributes that might introduce scripting from the vector leaving the element unchanged.
+  // Remove attributes that might introduce scripting from the vector leaving
+  // the element unchanged.
   void stripScriptingAttributes(Vector<Attribute>&) const;
 
   bool sharesSameElementData(const Element& other) const {
     return elementData() == other.elementData();
   }
 
   // Clones attributes only.
   void cloneAttributesFromElement(const Element&);
 
-  // Clones all attribute-derived data, including subclass specifics (through copyNonAttributeProperties.)
+  // Clones all attribute-derived data, including subclass specifics (through
+  // copyNonAttributeProperties.)
   void cloneDataFromElement(const Element&);
 
   bool hasEquivalentAttributes(const Element* other) const;
 
   virtual void copyNonAttributePropertiesFromElement(const Element&) {}
 
   void attachLayoutTree(const AttachContext& = AttachContext()) override;
   void detachLayoutTree(const AttachContext& = AttachContext()) override;
 
   virtual LayoutObject* createLayoutObject(const ComputedStyle&);
   virtual bool layoutObjectIsNeeded(const ComputedStyle&);
   void recalcStyle(StyleRecalcChange, Text* nextTextSibling = nullptr);
   void pseudoStateChanged(CSSSelector::PseudoType);
   void setAnimationStyleChange(bool);
   void clearAnimationStyleChange();
   void setNeedsAnimationStyleRecalc();
 
   void setNeedsCompositingUpdate();
 
   bool supportsStyleSharing() const;
 
   ElementShadow* shadow() const;
   ElementShadow& ensureShadow();
-  // If type of ShadowRoot (either closed or open) is explicitly specified, creation of multiple
-  // shadow roots is prohibited in any combination and throws an exception. Multiple shadow roots
-  // are allowed only when createShadowRoot() is used without any parameters from JavaScript.
+  // If type of ShadowRoot (either closed or open) is explicitly specified,
+  // creation of multiple shadow roots is prohibited in any combination and
+  // throws an exception.  Multiple shadow roots are allowed only when
+  // createShadowRoot() is used without any parameters from JavaScript.
   ShadowRoot* createShadowRoot(const ScriptState*, ExceptionState&);
   ShadowRoot* attachShadow(const ScriptState*,
                            const ShadowRootInit&,
                            ExceptionState&);
   ShadowRoot* createShadowRootInternal(ShadowRootType, ExceptionState&);
 
   ShadowRoot* openShadowRoot() const;
   ShadowRoot* closedShadowRoot() const;
   ShadowRoot* authorShadowRoot() const;
   ShadowRoot* userAgentShadowRoot() const;
 
   ShadowRoot* youngestShadowRoot() const;
 
   ShadowRoot* shadowRootIfV1() const;
 
   ShadowRoot& ensureUserAgentShadowRoot();
 
   bool isInDescendantTreeOf(const Element* shadowHost) const;
 
-  // Returns the Element’s ComputedStyle. If the ComputedStyle is not already stored on the Element,
-  // computes the ComputedStyle and stores it on the Element’s ElementRareData. Used for getComputedStyle
-  // when Element is display none.
+  // Returns the Element’s ComputedStyle. If the ComputedStyle is not already
+  // stored on the Element, computes the ComputedStyle and stores it on the
+  // Element’s ElementRareData.  Used for getComputedStyle when Element is
+  // display none.
   const ComputedStyle* ensureComputedStyle(PseudoId = PseudoIdNone);
 
-  // Methods for indicating the style is affected by dynamic updates (e.g., children changing, our position changing in our sibling list, etc.)
+  // Methods for indicating the style is affected by dynamic updates (e.g.,
+  // children changing, our position changing in our sibling list, etc.)
   bool styleAffectedByEmpty() const {
     return hasElementFlag(StyleAffectedByEmpty);
   }
   void setStyleAffectedByEmpty() { setElementFlag(StyleAffectedByEmpty); }
 
   void setIsInCanvasSubtree(bool value) {
     setElementFlag(IsInCanvasSubtree, value);
   }
   bool isInCanvasSubtree() const { return hasElementFlag(IsInCanvasSubtree); }
 
@@ skipping 40 matching lines @@
   void removeApplyScroll();
   void nativeApplyScroll(ScrollState&);
 
   void callDistributeScroll(ScrollState&);
   void callApplyScroll(ScrollState&);
 
   ScrollStateCallback* getApplyScroll();
 
   // Whether this element can receive focus at all. Most elements are not
   // focusable but some elements, such as form controls and links, are. Unlike
-  // layoutObjectIsFocusable(), this method may be called when layout is not up to
-  // date, so it must not use the layoutObject to determine focusability.
+  // layoutObjectIsFocusable(), this method may be called when layout is not up
+  // to date, so it must not use the layoutObject to determine focusability.
   virtual bool supportsFocus() const;
   // isFocusable(), isKeyboardFocusable(), and isMouseFocusable() check
   // whether the element can actually be focused. Callers should ensure
   // ComputedStyle is up to date;
   // e.g. by calling Document::updateLayoutTreeIgnorePendingStylesheets().
   bool isFocusable() const;
   virtual bool isKeyboardFocusable() const;
   virtual bool isMouseFocusable() const;
   bool isFocusedElementInDocument() const;
   Element* adjustedFocusedElementInTreeScope() const;
@@ skipping 59 matching lines @@
   // former can be used as a selector in any places, and the latter can be
   // used only in UA stylesheet.
   void setShadowPseudoId(const AtomicString&);
 
   LayoutSize minimumSizeForResizing() const;
   void setMinimumSizeForResizing(const LayoutSize&);
 
   virtual void didBecomeFullscreenElement() {}
   virtual void willStopBeingFullscreenElement() {}
 
-  // Called by the parser when this element's close tag is reached,
-  // signaling that all child tags have been parsed and added.
-  // This is needed for <applet> and <object> elements, which can't lay themselves out
-  // until they know all of their nested <param>s. [Radar 3603191, 4040848].
-  // Also used for script elements and some SVG elements for similar purposes,
-  // but making parsing a special case in this respect should be avoided if possible.
+  // Called by the parser when this element's close tag is reached, signaling
+  // that all child tags have been parsed and added.  This is needed for
+  // <applet> and <object> elements, which can't lay themselves out until they
+  // know all of their nested <param>s. [Radar 3603191, 4040848].  Also used for
+  // script elements and some SVG elements for similar purposes, but making
+  // parsing a special case in this respect should be avoided if possible.
   virtual void finishParsingChildren();
 
   void beginParsingChildren() { setIsFinishedParsingChildren(false); }
 
   PseudoElement* pseudoElement(PseudoId) const;
   LayoutObject* pseudoElementLayoutObject(PseudoId) const;
 
   virtual bool matchesDefaultPseudoClass() const { return false; }
   virtual bool matchesEnabledPseudoClass() const { return false; }
   virtual bool matchesReadOnlyPseudoClass() const { return false; }
@@ skipping 17 matching lines @@
   virtual bool isOptionalFormControl() const { return false; }
   virtual bool isRequiredFormControl() const { return false; }
   virtual bool willValidate() const { return false; }
   virtual bool isValidElement() { return false; }
   virtual bool isInRange() const { return false; }
   virtual bool isOutOfRange() const { return false; }
   virtual bool isClearButtonElement() const { return false; }
 
   bool canContainRangeEndPoint() const override { return true; }
 
-  // Used for disabled form elements; if true, prevents mouse events from being dispatched
-  // to event listeners, and prevents DOMActivate events from being sent at all.
+  // Used for disabled form elements; if true, prevents mouse events from being
+  // dispatched to event listeners, and prevents DOMActivate events from being
+  // sent at all.
   virtual bool isDisabledFormControl() const { return false; }
 
   bool hasPendingResources() const {
     return hasElementFlag(HasPendingResources);
   }
   void setHasPendingResources() { setElementFlag(HasPendingResources); }
   void clearHasPendingResources() { clearElementFlag(HasPendingResources); }
   virtual void buildPendingResource() {}
 
   void v0SetCustomElementDefinition(V0CustomElementDefinition*);
@@ skipping 238 matching lines @@
   const ComputedStyle* virtualEnsureComputedStyle(
       PseudoId pseudoElementSpecifier = PseudoIdNone) override {
     return ensureComputedStyle(pseudoElementSpecifier);
   }
 
   inline void updateCallbackSelectors(const ComputedStyle* oldStyle,
                                       const ComputedStyle* newStyle);
   inline void removeCallbackSelectors();
   inline void addCallbackSelectors();
 
-  // cloneNode is private so that non-virtual cloneElementWithChildren and cloneElementWithoutChildren
-  // are used instead.
+  // cloneNode is private so that non-virtual cloneElementWithChildren and
+  // cloneElementWithoutChildren are used instead.
   Node* cloneNode(bool deep) override;
   virtual Element* cloneElementWithoutAttributesAndChildren();
 
   QualifiedName m_tagName;
 
   void updateNamedItemRegistration(const AtomicString& oldName,
                                    const AtomicString& newName);
   void updateExtraNamedItemRegistration(const AtomicString& oldName,
                                         const AtomicString& newName);
 
@@ skipping 224 matching lines @@
   return element.shadow();
 }
 
 inline bool isAtShadowBoundary(const Element* element) {
   if (!element)
     return false;
   ContainerNode* parentNode = element->parentNode();
   return parentNode && parentNode->isShadowRoot();
 }
 
-// These macros do the same as their NODE equivalents but additionally provide a template specialization
-// for isElementOfType<>() so that the Traversal<> API works for these Element types.
+// These macros do the same as their NODE equivalents but additionally provide a
+// template specialization for isElementOfType<>() so that the Traversal<> API
+// works for these Element types.
 #define DEFINE_ELEMENT_TYPE_CASTS(thisType, predicate)            \
   template <>                                                     \
   inline bool isElementOfType<const thisType>(const Node& node) { \
     return node.predicate;                                        \
   }                                                               \
   DEFINE_NODE_TYPE_CASTS(thisType, predicate)
 
 #define DEFINE_ELEMENT_TYPE_CASTS_WITH_FUNCTION(thisType)         \
   template <>                                                     \
   inline bool isElementOfType<const thisType>(const Node& node) { \
     return is##thisType(node);                                    \
   }                                                               \
   DEFINE_NODE_TYPE_CASTS_WITH_FUNCTION(thisType)
 
 #define DECLARE_ELEMENT_FACTORY_WITH_TAGNAME(T) \
   static T* create(const QualifiedName&, Document&)
 #define DEFINE_ELEMENT_FACTORY_WITH_TAGNAME(T)                     \
   T* T::create(const QualifiedName& tagName, Document& document) { \
     return new T(tagName, document);                               \
   }
 
 }  // namespace blink
 
 #endif  // Element_h