reflow comments in modules/accessiblity

third_party/WebKit/Source/modules/accessibility/AXObject.h

 /*
  * Copyright (C) 2008, 2009, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nuanti Ltd.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 291 matching lines @@
 enum TextStyle {
   TextStyleNone = 0,
   TextStyleBold = 1 << 0,
   TextStyleItalic = 1 << 1,
   TextStyleUnderline = 1 << 2,
   TextStyleLineThrough = 1 << 3
 };
 
 enum TextUnderElementMode {
   TextUnderElementAll,
-  TextUnderElementAny  // If the text is unimportant, just whether or not it's present
+  TextUnderElementAny  // If the text is unimportant, just whether or not it's
+                       // present
 };
 
 // The source of the accessible name of an element. This is needed
 // because on some platforms this determines how the accessible name
 // is exposed.
 enum AXNameFrom {
   AXNameFromUninitialized = -1,
   AXNameFromAttribute = 0,
   AXNameFromCaption,
   AXNameFromContents,
   AXNameFromPlaceholder,
   AXNameFromRelatedElement,
   AXNameFromValue,
   AXNameFromTitle,
 };
 
-// The potential native HTML-based text (name, description or placeholder) sources for an element.
-// See http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
+// The potential native HTML-based text (name, description or placeholder)
+// sources for an element.  See
+// http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
 enum AXTextFromNativeHTML {
   AXTextFromNativeHTMLUninitialized = -1,
   AXTextFromNativeHTMLFigcaption,
   AXTextFromNativeHTMLLabel,
   AXTextFromNativeHTMLLabelFor,
   AXTextFromNativeHTMLLabelWrapped,
   AXTextFromNativeHTMLLegend,
   AXTextFromNativeHTMLTableCaption,
   AXTextFromNativeHTMLTitleElement,
 };
@@ skipping 170 matching lines @@
           focusObject(focusObject),
           focusOffset(focusOffset),
           focusAffinity(focusAffinity) {}
 
     bool isValid() const {
       return ((anchorObject && focusObject) ||
               (!anchorObject && !focusObject)) &&
              anchorOffset >= 0 && focusOffset >= 0;
     }
 
-    // Determines if the range only refers to text offsets under the current object.
+    // Determines if the range only refers to text offsets under the current
+    // object.
     bool isSimple() const {
       return anchorObject == focusObject || !anchorObject || !focusObject;
     }
   };
 
  protected:
   AXObject(AXObjectCacheImpl&);
 
  public:
   virtual ~AXObject();
   DECLARE_VIRTUAL_TRACE();
 
   static unsigned numberOfLiveAXObjects() { return s_numberOfLiveAXObjects; }
 
   // After constructing an AXObject, it must be given a
   // unique ID, then added to AXObjectCacheImpl, and finally init() must
   // be called last.
   void setAXObjectID(AXID axObjectID) { m_id = axObjectID; }
   virtual void init() {}
 
   // When the corresponding WebCore object that this AXObject
   // wraps is deleted, it must be detached.
   virtual void detach();
   virtual bool isDetached() const;
 
-  // If the parent of this object is known, this can be faster than using computeParent().
+  // If the parent of this object is known, this can be faster than using
+  // computeParent().
   virtual void setParent(AXObject* parent) { m_parent = parent; }
 
-  // The AXObjectCacheImpl that owns this object, and its unique ID within this cache.
+  // The AXObjectCacheImpl that owns this object, and its unique ID within this
+  // cache.
   AXObjectCacheImpl& axObjectCache() const {
     ASSERT(m_axObjectCache);
     return *m_axObjectCache;
   }
 
   AXID axObjectID() const { return m_id; }
 
   // Determine subclass type.
   virtual bool isAXNodeObject() const { return false; }
   virtual bool isAXLayoutObject() const { return false; }
@@ skipping 111 matching lines @@
   void setLastKnownIsIgnoredValue(bool);
   bool hasInheritedPresentationalRole() const;
   bool isPresentationalChild() const;
   bool ancestorExposesActiveDescendant() const;
   bool computeAncestorExposesActiveDescendant() const;
 
   //
   // Accessible name calculation
   //
 
-  // Retrieves the accessible name of the object, an enum indicating where the name
-  // was derived from, and a list of objects that were used to derive the name, if any.
+  // Retrieves the accessible name of the object, an enum indicating where the
+  // name was derived from, and a list of objects that were used to derive the
+  // name, if any.
   virtual String name(AXNameFrom&, AXObjectVector* nameObjects) const;
 
   typedef HeapVector<NameSource> NameSources;
-  // Retrieves the accessible name of the object and a list of all potential sources
-  // for the name, indicating which were used.
+  // Retrieves the accessible name of the object and a list of all potential
+  // sources for the name, indicating which were used.
   virtual String name(NameSources*) const;
 
   typedef HeapVector<DescriptionSource> DescriptionSources;
   // Takes the result of nameFrom from calling |name|, above, and retrieves the
-  // accessible description of the object, which is secondary to |name|, an enum indicating
-  // where the description was derived from, and a list of objects that were used to
-  // derive the description, if any.
+  // accessible description of the object, which is secondary to |name|, an enum
+  // indicating where the description was derived from, and a list of objects
+  // that were used to derive the description, if any.
   virtual String description(AXNameFrom,
                              AXDescriptionFrom&,
                              AXObjectVector* descriptionObjects) const {
     return String();
   }
 
-  // Same as above, but returns a list of all potential sources for the description, indicating which were used.
+  // Same as above, but returns a list of all potential sources for the
+  // description, indicating which were used.
   virtual String description(AXNameFrom,
                              AXDescriptionFrom&,
                              DescriptionSources*,
                              AXRelatedObjectVector*) const {
     return String();
   }
 
-  // Takes the result of nameFrom and descriptionFrom from calling |name| and |description|,
-  // above, and retrieves the placeholder of the object, if present and if it wasn't already
-  // exposed by one of the two functions above.
+  // Takes the result of nameFrom and descriptionFrom from calling |name| and
+  // |description|, above, and retrieves the placeholder of the object, if
+  // present and if it wasn't already exposed by one of the two functions above.
   virtual String placeholder(AXNameFrom, AXDescriptionFrom) const {
     return String();
   }
 
   // Internal functions used by name and description, above.
   typedef HeapHashSet<Member<const AXObject>> AXObjectSet;
   virtual String textAlternative(bool recursive,
                                  bool inAriaLabelledByTraversal,
                                  AXObjectSet& visited,
                                  AXNameFrom& nameFrom,
                                  AXRelatedObjectVector* relatedObjects,
                                  NameSources* nameSources) const {
     return String();
   }
   virtual String textFromDescendants(AXObjectSet& visited,
                                      bool recursive) const {
     return String();
   }
 
   // Returns result of Accessible Name Calculation algorithm.
   // This is a simpler high-level interface to |name| used by Inspector.
   String computedName() const;
 
-  // Internal function used to determine whether the result of calling |name| on this object would
-  // return text that came from the an HTML label element or not. This is intended to be faster than calling
-  // |name| or |textAlternative|, and without side effects (it won't call axObjectCache->getOrCreate).
+  // Internal function used to determine whether the result of calling |name| on
+  // this object would return text that came from the an HTML label element or
+  // not. This is intended to be faster than calling |name| or
+  // |textAlternative|, and without side effects (it won't call
+  // axObjectCache->getOrCreate).
   virtual bool nameFromLabelElement() const { return false; }
 
   //
   // Properties of static elements.
   //
 
   virtual const AtomicString& accessKey() const { return nullAtom; }
   RGBA32 backgroundColor() const;
   virtual RGBA32 computeBackgroundColor() const { return Color::transparent; }
   virtual RGBA32 color() const { return Color::black; }
@@ skipping 23 matching lines @@
   // Walk the AXObjects on the same line. This is supported on any
   // object type but primarily intended to be used for inline text boxes.
   virtual AXObject* nextOnLine() const { return nullptr; }
   virtual AXObject* previousOnLine() const { return nullptr; }
 
   // For all node objects. The start and end character offset of each
   // marker, such as spelling or grammar error.
   virtual void markers(Vector<DocumentMarker::MarkerType>&,
                        Vector<AXRange>&) const {}
   // For an inline text box.
-  // The integer horizontal pixel offset of each character in the string; negative values for RTL.
+  // The integer horizontal pixel offset of each character in the string;
+  // negative values for RTL.
   virtual void textCharacterOffsets(Vector<int>&) const {}
   // The start and end character offset of each word in the object's text.
   virtual void wordBoundaries(Vector<AXRange>&) const {}
 
   // Properties of interactive elements.
   String actionVerb() const;
   virtual AccessibilityButtonState checkboxOrRadioValue() const;
   virtual AriaCurrentState ariaCurrentState() const {
     return AriaCurrentStateUndefined;
   }
@@ skipping 56 matching lines @@
   const AtomicString& containerLiveRegionStatus() const;
   const AtomicString& containerLiveRegionRelevant() const;
   bool containerLiveRegionAtomic() const;
   bool containerLiveRegionBusy() const;
 
   // Every object's bounding box is returned relative to a
   // container object (which is guaranteed to be an ancestor) and
   // optionally a transformation matrix that needs to be applied too.
   // To compute the absolute bounding box of an element, start with its
   // boundsInContainer and apply the transform. Then as long as its container is
-  // not null, walk up to its container and offset by the container's offset from
-  // origin, the container's scroll position if any, and apply the container's transform.
-  // Do this until you reach the root of the tree.
+  // not null, walk up to its container and offset by the container's offset
+  // from origin, the container's scroll position if any, and apply the
+  // container's transform.  Do this until you reach the root of the tree.
   virtual void getRelativeBounds(AXObject** outContainer,
                                  FloatRect& outBoundsInContainer,
                                  SkMatrix44& outContainerTransform) const;
 
   // Get the bounds in frame-relative coordinates as a LayoutRect.
   LayoutRect getBoundsInFrameCoordinates() const;
 
   // Explicitly set an object's bounding rect and offset container.
   void setElementRect(LayoutRect r, AXObject* container) {
     m_explicitElementRect = r;
     m_explicitContainerID = container->axObjectID();
   }
 
   // Hit testing.
   // Called on the root AX object to return the deepest available element.
   virtual AXObject* accessibilityHitTest(const IntPoint&) const { return 0; }
-  // Called on the AX object after the layout tree determines which is the right AXLayoutObject.
+  // Called on the AX object after the layout tree determines which is the right
+  // AXLayoutObject.
   virtual AXObject* elementAccessibilityHitTest(const IntPoint&) const;
 
-  // High-level accessibility tree access. Other modules should only use these functions.
+  // High-level accessibility tree access. Other modules should only use these
+  // functions.
   const AXObjectVector& children();
   AXObject* parentObject() const;
   AXObject* parentObjectIfExists() const;
   virtual AXObject* computeParent() const = 0;
   virtual AXObject* computeParentIfExists() const { return 0; }
   AXObject* cachedParentObject() const { return m_parent; }
   AXObject* parentObjectUnignored() const;
 
-  // Low-level accessibility tree exploration, only for use within the accessibility module.
+  // Low-level accessibility tree exploration, only for use within the
+  // accessibility module.
   virtual AXObject* rawFirstChild() const { return 0; }
   virtual AXObject* rawNextSibling() const { return 0; }
   virtual void addChildren() {}
   virtual bool canHaveChildren() const { return true; }
   bool hasChildren() const { return m_haveChildren; }
   virtual void updateChildrenIfNecessary();
   virtual bool needsToUpdateChildren() const { return false; }
   virtual void setNeedsToUpdateChildren() {}
   virtual void clearChildren();
   virtual void detachFromParent() { m_parent = 0; }
@@ skipping 31 matching lines @@
   void setScrollOffset(const IntPoint&) const;
 
   // If this object itself scrolls, return its ScrollableArea.
   virtual ScrollableArea* getScrollableAreaIfScrollable() const { return 0; }
 
   // Modify or take an action on an object.
   virtual void increment() {}
   virtual void decrement() {}
   bool performDefaultAction() const { return press(); }
   virtual bool press() const;
-  // Make this object visible by scrolling as many nested scrollable views as needed.
+  // Make this object visible by scrolling as many nested scrollable views as
+  // needed.
   void scrollToMakeVisible() const;
-  // Same, but if the whole object can't be made visible, try for this subrect, in local coordinates.
+  // Same, but if the whole object can't be made visible, try for this subrect,
+  // in local coordinates.
   void scrollToMakeVisibleWithSubFocus(const IntRect&) const;
-  // Scroll this object to a given point in global coordinates of the top-level window.
+  // Scroll this object to a given point in global coordinates of the top-level
+  // window.
   void scrollToGlobalPoint(const IntPoint&) const;
   virtual void setFocused(bool) {}
   virtual void setSelected(bool) {}
   virtual void setValue(const String&) {}
   virtual void setValue(float) {}
 
   // Notifications that this object may have changed.
   virtual void childrenChanged() {}
   virtual void handleActiveDescendantChanged() {}
   virtual void handleAriaExpandedChanged() {}
@@ skipping 58 matching lines @@
 
   AccessibilityRole buttonRoleType() const;
 
   virtual LayoutObject* layoutObjectForRelativeBounds() const {
     return nullptr;
   }
 
   mutable Member<AXObject> m_parent;
 
   // The following cached attribute values (the ones starting with m_cached*)
-  // are only valid if m_lastModificationCount matches AXObjectCacheImpl::modificationCount().
+  // are only valid if m_lastModificationCount matches
+  // AXObjectCacheImpl::modificationCount().
   mutable int m_lastModificationCount;
   mutable RGBA32 m_cachedBackgroundColor;
   mutable bool m_cachedIsIgnored : 1;
   mutable bool m_cachedIsInertOrAriaHidden : 1;
   mutable bool m_cachedIsDescendantOfLeafNode : 1;
   mutable bool m_cachedIsDescendantOfDisabledNode : 1;
   mutable bool m_cachedHasInheritedPresentationalRole : 1;
   mutable bool m_cachedIsPresentationalChild : 1;
   mutable bool m_cachedAncestorExposesActiveDescendant : 1;
   mutable Member<AXObject> m_cachedLiveRegionRoot;
 
   Member<AXObjectCacheImpl> m_axObjectCache;
 
-  // Updates the cached attribute values. This may be recursive, so to prevent deadlocks,
+  // Updates the cached attribute values. This may be recursive, so to prevent
+  // deadlocks,
   // functions called here may only search up the tree (ancestors), not down.
   void updateCachedAttributeValuesIfNeeded() const;
 
  private:
   static bool includesARIAWidgetRole(const String&);
   static bool hasInteractiveARIAAttribute(const Element&);
 
   static unsigned s_numberOfLiveAXObjects;
 };
 
 #define DEFINE_AX_OBJECT_TYPE_CASTS(thisType, predicate)           \
   DEFINE_TYPE_CASTS(thisType, AXObject, object, object->predicate, \
                     object.predicate)
 
 }  // namespace blink
 
 #endif  // AXObject_h