The Tor Browser: content/base/src/DirectionalityUtils.cpp@deefc01c0e14 (annotated)

content/base/src/DirectionalityUtils.cpp@deefc01c0e14 (annotated)

content/base/src/DirectionalityUtils.cpp

Thu, 15 Jan 2015 21:03:48 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 21:03:48 +0100
branch: TOR_BUG_9701
changeset 11: deefc01c0e14
permissions: -rw-r--r--

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 sw=2 et tw=78: */
 /* 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/. */
 /*
   Implementation description from https://etherpad.mozilla.org/dir-auto
   Static case
   ===========
   When we see a new content node with @dir=auto from the parser, we set the
   NodeHasDirAuto flag on the node.  We won't have enough information to
   decide the directionality of the node at this point.
   When we bind a new content node to the document, if its parent has either of
   the NodeAncestorHasDirAuto or NodeHasDirAuto flags, we set the
   NodeAncestorHasDirAuto flag on the node.
   When a new input with @type=text/search/tel/url/email and @dir=auto is added
   from the parser, we resolve the directionality based on its @value.
   When a new text node with non-neutral content is appended to a textarea
   element with NodeHasDirAuto, if the directionality of the textarea element
   is still unresolved, it is resolved based on the value of the text node.
   Elements with unresolved directionality behave as LTR.
   When a new text node with non-neutral content is appended to an element that
   is not a textarea but has either of the NodeAncestorHasDirAuto or
   NodeHasDirAuto flags, we walk up the parent chain while the
   NodeAncestorHasDirAuto flag is present, and when we reach an element with
   NodeHasDirAuto and no resolved directionality, we resolve the directionality
   based on the contents of the text node and cease walking the parent chain.
   Note that we should ignore elements with NodeHasDirAuto with resolved
   directionality, so that the second text node in this example tree doesn't
   affect the directionality of the div:
   <div dir=auto>
     <span>foo</span>
     <span>بار</span>
   </div>
   The parent chain walk will be aborted if we hit a script or style element, or
   if we hit an element with @dir=ltr or @dir=rtl.
   I will call this algorithm "upward propagation".
   Each text node should maintain a list of elements which have their
   directionality determined by the first strong character of that text node.
   This is useful to make dynamic changes more efficient.  One way to implement
   this is to have a per-document hash table mapping a text node to a set of
   elements.  I'll call this data structure TextNodeDirectionalityMap. The
   algorithm for appending a new text node above needs to update this data
   structure.
   *IMPLEMENTATION NOTE*
   In practice, the implementation uses two per-node properties:
   dirAutoSetBy, which is set on a node with auto-directionality, and points to
   the textnode that contains the strong character which determines the
   directionality of the node.
   textNodeDirectionalityMap, which is set on a text node and points to a hash
   table listing the nodes whose directionality is determined by the text node.
   Handling dynamic changes
   ========================
   We need to handle the following cases:
 . When the value of an input element with @type=text/search/tel/url/email is
   changed, if it has NodeHasDirAuto, we update the resolved directionality.
 . When the dir attribute is changed from something else (including the case
   where it doesn't exist) to auto on a textarea or an input element with
   @type=text/search/tel/url/email, we set the NodeHasDirAuto flag and resolve
   the directionality based on the value of the element.
 . When the dir attribute is changed from something else (including the case
   where it doesn't exist) to auto on any element except case 1 above and the bdi
   element, we run the following algorithm:
   * We set the NodeHasDirAuto flag.
   * If the element doesn't have the NodeAncestorHasDirAuto flag, we set the
   NodeAncestorHasDirAuto flag on all of its child nodes.  (Note that if the
   element does have NodeAncestorHasDirAuto, all of its children should
   already have this flag too.  We can assert this in debug builds.)
   * To resolve the directionality of the element, we run the algorithm explained
   in http://www.whatwg.org/specs/web-apps/current-work/multipage/elements.html#the-dir-attribute
   (I'll call this the "downward propagation algorithm".) by walking the child
   subtree in tree order.  Note that an element with @dir=auto should not affect
   other elements in its document with @dir=auto.  So there is no need to walk up
   the parent chain in this case.  TextNodeDirectionalityMap needs to be updated
   as appropriate.
 a. When the dir attribute is set to any valid value on an element that didn't
   have a valid dir attribute before, this means that any descendant of that
   element will not affect the directionality of any of its ancestors. So we need
   to check whether any text node descendants of the element are listed in
   TextNodeDirectionalityMap, and whether the elements whose direction they set
   are ancestors of the element. If so, we need to rerun the downward propagation
   algorithm for those ancestors.
 .  When the dir attribute is changed from auto to something else (including
   the case where it gets removed) on a textarea or an input element with
   @type=text/search/tel/url/email, we unset the NodeHasDirAuto flag and
   resolve the directionality based on the directionality of the value of the @dir
   attribute on element itself or its parent element.
 . When the dir attribute is changed from auto to something else (including the
   case where it gets removed) on any element except case 4 above and the bdi
   element, we run the following algorithm:
   * We unset the NodeHasDirAuto flag.
   * If the element does not have the NodeAncestorHasDirAuto flag, we unset
   the NodeAncestorHasDirAuto flag on all of its child nodes, except those
   who are a descendant of another element with NodeHasDirAuto.  (Note that if
   the element has the NodeAncestorHasDirAuto flag, all of its child nodes
   should still retain the same flag.)
   * We resolve the directionality of the element based on the value of the @dir
   attribute on the element itself or its parent element.
   TextNodeDirectionalityMap needs to be updated as appropriate.
 a. When the dir attribute is removed or set to an invalid value on any
   element (except a bdi element) with the NodeAncestorHasDirAuto flag which
   previously had a valid dir attribute, it might have a text node descendant that
   did not previously affect the directionality of any of its ancestors but should
   now begin to affect them.
   We run the following algorithm:
   * Walk up the parent chain from the element.
   * For any element that appears in the TextNodeDirectionalityMap, remove the
     element from the map and rerun the downward propagation algorithm
     (see section 3).
   * If we reach an element without either of the NodeHasDirAuto or
     NodeAncestorHasDirAuto flags, abort the parent chain walk.
 . When an element with @dir=auto is added to the document, we should handle it
   similar to the case 2/3 above.
 . When an element with NodeHasDirAuto or NodeAncestorHasDirAuto is
   removed from the document, we should handle it similar to the case 4/5 above,
   except that we don't need to handle anything in the child subtree.  We should
   also remove all of the occurrences of that node and its descendants from
   TextNodeDirectionalityMap. (This is the conceptual description of what needs to
   happen but in the implementation UnbindFromTree is going to be called on all of
   the descendants so we don't need to descend into the child subtree).
 . When the contents of a text node is changed either from script or by the
   user, we need to run the following algorithm:
   * If the change has happened after the first character with strong
   directionality in the text node, do nothing.
   * If the text node is a child of a bdi, script or style element, do nothing.
   * If the text node belongs to a textarea with NodeHasDirAuto, we need to
   update the directionality of the textarea.
   * Grab a list of elements affected by this text node from
   TextNodeDirectionalityMap and re-resolve the directionality of each one of them
   based on the new contents of the text node.
   * If the text node does not exist in TextNodeDirectionalityMap, and it has the
   NodeAncestorHasDirAuto flag set, this could potentially be a text node
   which is going to start affecting the directionality of its parent @dir=auto
   elements. In this case, we need to fall back to the (potentially expensive)
   "upward propagation algorithm".  The TextNodeDirectionalityMap data structure
   needs to be update during this algorithm.
   * If the new contents of the text node do not have any strong characters, and
   the old contents used to, and the text node used to exist in
   TextNodeDirectionalityMap and it has the NodeAncestorHasDirAuto flag set,
   the elements associated with this text node inside TextNodeDirectionalityMap
   will now get their directionality from another text node.  In this case, for
   each element in the list retrieved from TextNodeDirectionalityMap, run the
   downward propagation algorithm (section 3), and remove the text node from
   TextNodeDirectionalityMap.
 . When a new text node is injected into a document, we need to run the
   following algorithm:
   * If the contents of the text node do not have any characters with strong
   direction, do nothing.
   * If the text node is a child of a bdi, script or style element, do nothing.
   * If the text node is appended to a textarea element with NodeHasDirAuto, we
   need to update the directionality of the textarea.
   * If the text node has NodeAncestorHasDirAuto, we need to run the "upward
   propagation algorithm".  The TextNodeDirectionalityMap data structure needs to
   be update during this algorithm.
 . When a text node is removed from a document, we need to run the following
   algorithm:
   * If the contents of the text node do not have any characters with strong
   direction, do nothing.
   * If the text node is a child of a bdi, script or style element, do nothing.
   * If the text node is removed from a textarea element with NodeHasDirAuto,
   set the directionality to "ltr". (This is what the spec currently says, but I'm
   filing a spec bug to get it fixed -- the directionality should depend on the
   parent element here.)
   * If the text node has NodeAncestorHasDirAuto, we need to look at the list
   of elements being affected by this text node from TextNodeDirectionalityMap,
   run the "downward propagation algorithm" (section 3) for each one of them,
   while updating TextNodeDirectionalityMap along the way.
 . If the value of the @dir attribute on a bdi element is changed to an
   invalid value (or if it's removed), determine the new directionality similar
   to the case 3 above.
   == Implemention Notes ==
   When a new node gets bound to the tree, the BindToTree function gets called.
   The reverse case is UnbindFromTree.
   When the contents of a text node change, nsGenericDOMDataNode::SetTextInternal
   gets called.
   */
 #include "mozilla/dom/DirectionalityUtils.h"
 #include "nsINode.h"
 #include "nsIContent.h"
 #include "nsIDocument.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/dom/Element.h"
 #include "nsIDOMHTMLDocument.h"
 #include "nsUnicodeProperties.h"
 #include "nsTextFragment.h"
 #include "nsAttrValue.h"
 #include "nsTextNode.h"
 #include "nsCheapSets.h"
 namespace mozilla {
 using mozilla::dom::Element;
 /**
  * Returns true if aElement is one of the elements whose text content should not
  * affect its own direction, nor the direction of ancestors with dir=auto.
  *
  * Note that this does not include <bdi>, whose content does affect its own
  * direction when it has dir=auto (which it has by default), so one needs to
  * test for it separately, e.g. with DoesNotAffectDirectionOfAncestors.
  * It *does* include textarea, because even if a textarea has dir=auto, it has
  * unicode-bidi: plaintext and is handled automatically in bidi resolution.
  */
 static bool
 DoesNotParticipateInAutoDirection(const Element* aElement)
 {
   nsINodeInfo* nodeInfo = aElement->NodeInfo();
   return (!aElement->IsHTML() ||
           nodeInfo->Equals(nsGkAtoms::script) ||
           nodeInfo->Equals(nsGkAtoms::style) ||
           nodeInfo->Equals(nsGkAtoms::textarea) ||
           aElement->IsInAnonymousSubtree());
 }
 static inline bool
 IsBdiWithoutDirAuto(const Element* aElement)
 {
   // We are testing for bdi elements without explicit dir="auto", so we can't
   // use the HasDirAuto() flag, since that will return true for bdi element with
   // no dir attribute or an invalid dir attribute
   return (aElement->IsHTML(nsGkAtoms::bdi) &&
           (!aElement->HasValidDir() || aElement->HasFixedDir()));
 }
 /**
  * Returns true if aElement is one of the element whose text content should not
  * affect the direction of ancestors with dir=auto (though it may affect its own
  * direction, e.g. <bdi>)
  */
 static bool
 DoesNotAffectDirectionOfAncestors(const Element* aElement)
 {
   return (DoesNotParticipateInAutoDirection(aElement) ||
           IsBdiWithoutDirAuto(aElement) ||
           aElement->HasFixedDir());
 }
 /**
  * Returns the directionality of a Unicode character
  */
 static Directionality
 GetDirectionFromChar(uint32_t ch)
 {
   switch(mozilla::unicode::GetBidiCat(ch)) {
     case eCharType_RightToLeft:
     case eCharType_RightToLeftArabic:
       return eDir_RTL;
     case eCharType_LeftToRight:
       return eDir_LTR;
     default:
       return eDir_NotSet;
   }
 }
 inline static bool NodeAffectsDirAutoAncestor(nsINode* aTextNode)
 {
   Element* parent = aTextNode->GetParentElement();
   return (parent &&
           !DoesNotParticipateInAutoDirection(parent) &&
           parent->NodeOrAncestorHasDirAuto());
 }
 /**
  * Various methods for returning the directionality of a string using the
  * first-strong algorithm defined in http://unicode.org/reports/tr9/#P2
  *
  * @param[out] aFirstStrong the offset to the first character in the string with
  *             strong directionality, or UINT32_MAX if there is none (return
                value is eDir_NotSet).
  * @return the directionality of the string
  */
 static Directionality
 GetDirectionFromText(const char16_t* aText, const uint32_t aLength,
                      uint32_t* aFirstStrong = nullptr)
 {
   const char16_t* start = aText;
   const char16_t* end = aText + aLength;
   while (start < end) {
     uint32_t current = start - aText;
     uint32_t ch = *start++;
     if (NS_IS_HIGH_SURROGATE(ch) &&
         start < end &&
         NS_IS_LOW_SURROGATE(*start)) {
       ch = SURROGATE_TO_UCS4(ch, *start++);
       current++;
     }
     // Just ignore lone surrogates
     if (!IS_SURROGATE(ch)) {
       Directionality dir = GetDirectionFromChar(ch);
       if (dir != eDir_NotSet) {
         if (aFirstStrong) {
           *aFirstStrong = current;
         }
         return dir;
       }
     }
   }
   if (aFirstStrong) {
     *aFirstStrong = UINT32_MAX;
   }
   return eDir_NotSet;
 }
 static Directionality
 GetDirectionFromText(const char* aText, const uint32_t aLength,
                         uint32_t* aFirstStrong = nullptr)
 {
   const char* start = aText;
   const char* end = aText + aLength;
   while (start < end) {
     uint32_t current = start - aText;
     unsigned char ch = (unsigned char)*start++;
     Directionality dir = GetDirectionFromChar(ch);
     if (dir != eDir_NotSet) {
       if (aFirstStrong) {
         *aFirstStrong = current;
       }
       return dir;
     }
   }
   if (aFirstStrong) {
     *aFirstStrong = UINT32_MAX;
   }
   return eDir_NotSet;
 }
 static Directionality
 GetDirectionFromText(const nsTextFragment* aFrag,
                      uint32_t* aFirstStrong = nullptr)
 {
   if (aFrag->Is2b()) {
     return GetDirectionFromText(aFrag->Get2b(), aFrag->GetLength(),
                                    aFirstStrong);
   }
   return GetDirectionFromText(aFrag->Get1b(), aFrag->GetLength(),
                                  aFirstStrong);
 }
 /**
  * Set the directionality of a node with dir=auto as defined in
  * http://www.whatwg.org/specs/web-apps/current-work/multipage/elements.html#the-directionality
  *
  * @param[in] changedNode If we call this method because the content of a text
  *            node is about to change, pass in the changed node, so that we
  *            know not to return it
  * @return the text node containing the character that determined the direction
  */
 static nsINode*
 WalkDescendantsSetDirectionFromText(Element* aElement, bool aNotify = true,
                                     nsINode* aChangedNode = nullptr)
 {
   MOZ_ASSERT(aElement, "Must have an element");
   MOZ_ASSERT(aElement->HasDirAuto(), "Element must have dir=auto");
   if (DoesNotParticipateInAutoDirection(aElement)) {
     return nullptr;
   }
   nsIContent* child = aElement->GetFirstChild();
   while (child) {
     if (child->IsElement() &&
         DoesNotAffectDirectionOfAncestors(child->AsElement())) {
       child = child->GetNextNonChildNode(aElement);
       continue;
     }
     if (child->NodeType() == nsIDOMNode::TEXT_NODE &&
         child != aChangedNode) {
       Directionality textNodeDir = GetDirectionFromText(child->GetText());
       if (textNodeDir != eDir_NotSet) {
         // We found a descendant text node with strong directional characters.
         // Set the directionality of aElement to the corresponding value.
         aElement->SetDirectionality(textNodeDir, aNotify);
         return child;
       }
     }
     child = child->GetNextNode(aElement);
   }
   // We walked all the descendants without finding a text node with strong
   // directional characters. Set the directionality to LTR
   aElement->SetDirectionality(eDir_LTR, aNotify);
   return nullptr;
 }
 class nsTextNodeDirectionalityMap
 {
   static void
   nsTextNodeDirectionalityMapDtor(void *aObject, nsIAtom* aPropertyName,
                                   void *aPropertyValue, void* aData)
   {
     nsINode* textNode = static_cast<nsINode * >(aObject);
     textNode->ClearHasTextNodeDirectionalityMap();
     nsTextNodeDirectionalityMap* map =
       reinterpret_cast<nsTextNodeDirectionalityMap * >(aPropertyValue);
     map->EnsureMapIsClear(textNode);
     delete map;
   }
 public:
   nsTextNodeDirectionalityMap(nsINode* aTextNode)
   {
     MOZ_ASSERT(aTextNode, "Null text node");
     MOZ_COUNT_CTOR(nsTextNodeDirectionalityMap);
     aTextNode->SetProperty(nsGkAtoms::textNodeDirectionalityMap, this,
                            nsTextNodeDirectionalityMapDtor);
     aTextNode->SetHasTextNodeDirectionalityMap();
   }
   ~nsTextNodeDirectionalityMap()
   {
     MOZ_COUNT_DTOR(nsTextNodeDirectionalityMap);
   }
   void AddEntry(nsINode* aTextNode, Element* aElement)
   {
     if (!mElements.Contains(aElement)) {
       mElements.Put(aElement);
       aElement->SetProperty(nsGkAtoms::dirAutoSetBy, aTextNode);
       aElement->SetHasDirAutoSet();
     }
   }
   void RemoveEntry(nsINode* aTextNode, Element* aElement)
   {
     NS_ASSERTION(mElements.Contains(aElement),
                  "element already removed from map");
     mElements.Remove(aElement);
     aElement->ClearHasDirAutoSet();
     aElement->UnsetProperty(nsGkAtoms::dirAutoSetBy);
   }
 private:
   nsCheapSet<nsPtrHashKey<Element> > mElements;
   static nsTextNodeDirectionalityMap* GetDirectionalityMap(nsINode* aTextNode)
   {
     MOZ_ASSERT(aTextNode->NodeType() == nsIDOMNode::TEXT_NODE,
                "Must be a text node");
     nsTextNodeDirectionalityMap* map = nullptr;
     if (aTextNode->HasTextNodeDirectionalityMap()) {
       map = static_cast<nsTextNodeDirectionalityMap * >
         (aTextNode->GetProperty(nsGkAtoms::textNodeDirectionalityMap));
     }
     return map;
   }
   static PLDHashOperator SetNodeDirection(nsPtrHashKey<Element>* aEntry, void* aDir)
   {
     MOZ_ASSERT(aEntry->GetKey()->IsElement(), "Must be an Element");
     aEntry->GetKey()->SetDirectionality(*reinterpret_cast<Directionality*>(aDir),
                                         true);
     return PL_DHASH_NEXT;
   }
   static PLDHashOperator ResetNodeDirection(nsPtrHashKey<Element>* aEntry, void* aData)
   {
     MOZ_ASSERT(aEntry->GetKey()->IsElement(), "Must be an Element");
     // run the downward propagation algorithm
     // and remove the text node from the map
     nsINode* oldTextNode = static_cast<Element*>(aData);
     Element* rootNode = aEntry->GetKey();
     nsINode* newTextNode = nullptr;
     if (oldTextNode && rootNode->HasDirAuto()) {
       newTextNode = WalkDescendantsSetDirectionFromText(rootNode, true,
                                                         oldTextNode);
     }
     if (newTextNode) {
       nsTextNodeDirectionalityMap::AddEntryToMap(newTextNode, rootNode);
     } else {
       rootNode->ClearHasDirAutoSet();
       rootNode->UnsetProperty(nsGkAtoms::dirAutoSetBy);
     }
     return PL_DHASH_REMOVE;
   }
   static PLDHashOperator ClearEntry(nsPtrHashKey<Element>* aEntry, void* aData)
   {
     Element* rootNode = aEntry->GetKey();
     rootNode->ClearHasDirAutoSet();
     rootNode->UnsetProperty(nsGkAtoms::dirAutoSetBy);
     return PL_DHASH_REMOVE;
   }
 public:
   void UpdateAutoDirection(Directionality aDir)
   {
     mElements.EnumerateEntries(SetNodeDirection, &aDir);
   }
   void ClearAutoDirection()
   {
     mElements.EnumerateEntries(ResetNodeDirection, nullptr);
   }
   void ResetAutoDirection(nsINode* aTextNode)
   {
     mElements.EnumerateEntries(ResetNodeDirection, aTextNode);
   }
   void EnsureMapIsClear(nsINode* aTextNode)
   {
     DebugOnly<uint32_t> clearedEntries =
       mElements.EnumerateEntries(ClearEntry, aTextNode);
     MOZ_ASSERT(clearedEntries == 0, "Map should be empty already");
   }
   static void RemoveElementFromMap(nsINode* aTextNode, Element* aElement)
   {
     if (aTextNode->HasTextNodeDirectionalityMap()) {
       GetDirectionalityMap(aTextNode)->RemoveEntry(aTextNode, aElement);
     }
   }
   static void AddEntryToMap(nsINode* aTextNode, Element* aElement)
   {
     nsTextNodeDirectionalityMap* map = GetDirectionalityMap(aTextNode);
     if (!map) {
       map = new nsTextNodeDirectionalityMap(aTextNode);
     }
     map->AddEntry(aTextNode, aElement);
   }
   static void UpdateTextNodeDirection(nsINode* aTextNode, Directionality aDir)
   {
     MOZ_ASSERT(aTextNode->HasTextNodeDirectionalityMap(),
                "Map missing in UpdateTextNodeDirection");
     GetDirectionalityMap(aTextNode)->UpdateAutoDirection(aDir);
   }
   static void ClearTextNodeDirection(nsINode* aTextNode)
   {
     MOZ_ASSERT(aTextNode->HasTextNodeDirectionalityMap(),
                "Map missing in ResetTextNodeDirection");
     GetDirectionalityMap(aTextNode)->ClearAutoDirection();
   }
   static void ResetTextNodeDirection(nsINode* aTextNode)
   {
     MOZ_ASSERT(aTextNode->HasTextNodeDirectionalityMap(),
                "Map missing in ResetTextNodeDirection");
     GetDirectionalityMap(aTextNode)->ResetAutoDirection(aTextNode);
   }
   static void EnsureMapIsClearFor(nsINode* aTextNode)
   {
     if (aTextNode->HasTextNodeDirectionalityMap()) {
       GetDirectionalityMap(aTextNode)->EnsureMapIsClear(aTextNode);
     }
   }
 };
 Directionality
 RecomputeDirectionality(Element* aElement, bool aNotify)
 {
   MOZ_ASSERT(!aElement->HasDirAuto(),
              "RecomputeDirectionality called with dir=auto");
   Directionality dir = eDir_LTR;
   if (aElement->HasValidDir()) {
     dir = aElement->GetDirectionality();
   } else {
     Element* parent = aElement->GetParentElement();
     if (parent) {
       // If the element doesn't have an explicit dir attribute with a valid
       // value, the directionality is the same as the parent element (but
       // don't propagate the parent directionality if it isn't set yet).
       Directionality parentDir = parent->GetDirectionality();
       if (parentDir != eDir_NotSet) {
         dir = parentDir;
       }
     } else {
       // If there is no parent element and no dir attribute, the directionality
       // is LTR.
       dir = eDir_LTR;
     }
     aElement->SetDirectionality(dir, aNotify);
   }
   return dir;
 }
 void
 SetDirectionalityOnDescendants(Element* aElement, Directionality aDir,
                                bool aNotify)
 {
   for (nsIContent* child = aElement->GetFirstChild(); child; ) {
     if (!child->IsElement()) {
       child = child->GetNextNode(aElement);
       continue;
     }
     Element* element = child->AsElement();
     if (element->HasValidDir() || element->HasDirAuto()) {
       child = child->GetNextNonChildNode(aElement);
       continue;
     }
     element->SetDirectionality(aDir, aNotify);
     child = child->GetNextNode(aElement);
   }
 }
 /**
  * Walk the parent chain of a text node whose dir attribute has been removed and
  * reset the direction of any of its ancestors which have dir=auto and whose
  * directionality is determined by a text node descendant.
  */
 void
 WalkAncestorsResetAutoDirection(Element* aElement, bool aNotify)
 {
   nsINode* setByNode;
   Element* parent = aElement->GetParentElement();
   while (parent && parent->NodeOrAncestorHasDirAuto()) {
     if (parent->HasDirAutoSet()) {
       // If the parent has the DirAutoSet flag, its direction is determined by
       // some text node descendant.
       // Remove it from the map and reset its direction by the downward
       // propagation algorithm
       setByNode =
         static_cast<nsINode*>(parent->GetProperty(nsGkAtoms::dirAutoSetBy));
       if (setByNode) {
         nsTextNodeDirectionalityMap::RemoveElementFromMap(setByNode, parent);
       }
     }
     if (parent->HasDirAuto()) {
       setByNode = WalkDescendantsSetDirectionFromText(parent, aNotify);
       if (setByNode) {
         nsTextNodeDirectionalityMap::AddEntryToMap(setByNode, parent);
       }
       break;
     }
     parent = parent->GetParentElement();
   }
 }
 void
 WalkDescendantsResetAutoDirection(Element* aElement)
 {
   nsIContent* child = aElement->GetFirstChild();
   while (child) {
     if (child->HasDirAuto()) {
       child = child->GetNextNonChildNode(aElement);
       continue;
     }
     if (child->HasTextNodeDirectionalityMap()) {
       nsTextNodeDirectionalityMap::ResetTextNodeDirection(child);
       nsTextNodeDirectionalityMap::EnsureMapIsClearFor(child);
     }
     child = child->GetNextNode(aElement);
   }
 }
 void
 WalkDescendantsSetDirAuto(Element* aElement, bool aNotify)
 {
   // Only test for DoesNotParticipateInAutoDirection -- in other words, if
   // aElement is a <bdi> which is having its dir attribute set to auto (or
   // removed or set to an invalid value, which are equivalent to dir=auto for
   // <bdi>, we *do* want to set AncestorHasDirAuto on its descendants, unlike
   // in SetDirOnBind where we don't propagate AncestorHasDirAuto to a <bdi>
   // being bound to an existing node with dir=auto.
   if (!DoesNotParticipateInAutoDirection(aElement)) {
     bool setAncestorDirAutoFlag =
 #ifdef DEBUG
       true;
 #else
       !aElement->AncestorHasDirAuto();
 #endif
     if (setAncestorDirAutoFlag) {
       nsIContent* child = aElement->GetFirstChild();
       while (child) {
         if (child->IsElement() &&
             DoesNotAffectDirectionOfAncestors(child->AsElement())) {
           child = child->GetNextNonChildNode(aElement);
           continue;
         }
         MOZ_ASSERT(!aElement->AncestorHasDirAuto() ||
                    child->AncestorHasDirAuto(),
                    "AncestorHasDirAuto set on node but not its children");
         child->SetAncestorHasDirAuto();
         child = child->GetNextNode(aElement);
       }
     }
   }
   nsINode* textNode = WalkDescendantsSetDirectionFromText(aElement, aNotify);
   if (textNode) {
     nsTextNodeDirectionalityMap::AddEntryToMap(textNode, aElement);
   }
 }
 void
 WalkDescendantsClearAncestorDirAuto(Element* aElement)
 {
   nsIContent* child = aElement->GetFirstChild();
   while (child) {
     if (child->HasDirAuto()) {
       child = child->GetNextNonChildNode(aElement);
       continue;
     }
     child->ClearAncestorHasDirAuto();
     child = child->GetNextNode(aElement);
   }
 }
 void SetAncestorDirectionIfAuto(nsINode* aTextNode, Directionality aDir,
                                 bool aNotify = true)
 {
   MOZ_ASSERT(aTextNode->NodeType() == nsIDOMNode::TEXT_NODE,
              "Must be a text node");
   Element* parent = aTextNode->GetParentElement();
   while (parent && parent->NodeOrAncestorHasDirAuto()) {
     if (DoesNotParticipateInAutoDirection(parent) || parent->HasFixedDir()) {
       break;
     }
     if (parent->HasDirAuto()) {
       bool resetDirection = false;
       nsINode* directionWasSetByTextNode =
         static_cast<nsINode*>(parent->GetProperty(nsGkAtoms::dirAutoSetBy));
       if (!parent->HasDirAutoSet()) {
         // Fast path if parent's direction is not yet set by any descendant
         MOZ_ASSERT(!directionWasSetByTextNode,
                    "dirAutoSetBy property should be null");
         resetDirection = true;
       } else {
         // If parent's direction is already set, we need to know if
         // aTextNode is before or after the text node that had set it.
         // We will walk parent's descendants in tree order starting from
         // aTextNode to optimize for the most common case where text nodes are
         // being appended to tree.
         if (!directionWasSetByTextNode) {
           resetDirection = true;
         } else if (directionWasSetByTextNode != aTextNode) {
           nsIContent* child = aTextNode->GetNextNode(parent);
           while (child) {
             if (child->IsElement() &&
                 DoesNotAffectDirectionOfAncestors(child->AsElement())) {
               child = child->GetNextNonChildNode(parent);
               continue;
             }
             if (child == directionWasSetByTextNode) {
               // we found the node that set the element's direction after our
               // text node, so we need to reset the direction
               resetDirection = true;
               break;
             }
             child = child->GetNextNode(parent);
           }
         }
       }
       if (resetDirection) {
         if (directionWasSetByTextNode) {
           nsTextNodeDirectionalityMap::RemoveElementFromMap(
             directionWasSetByTextNode, parent
           );
         }
         parent->SetDirectionality(aDir, aNotify);
         nsTextNodeDirectionalityMap::AddEntryToMap(aTextNode, parent);
         SetDirectionalityOnDescendants(parent, aDir, aNotify);
       }
       // Since we found an element with dir=auto, we can stop walking the
       // parent chain: none of its ancestors will have their direction set by
       // any of its descendants.
       return;
     }
     parent = parent->GetParentElement();
   }
 }
 bool
 TextNodeWillChangeDirection(nsIContent* aTextNode, Directionality* aOldDir,
                             uint32_t aOffset)
 {
   if (!NodeAffectsDirAutoAncestor(aTextNode)) {
     nsTextNodeDirectionalityMap::EnsureMapIsClearFor(aTextNode);
     return false;
   }
   uint32_t firstStrong;
   *aOldDir = GetDirectionFromText(aTextNode->GetText(), &firstStrong);
   return (aOffset <= firstStrong);
 }
 void
 TextNodeChangedDirection(nsIContent* aTextNode, Directionality aOldDir,
                          bool aNotify)
 {
   Directionality newDir = GetDirectionFromText(aTextNode->GetText());
   if (newDir == eDir_NotSet) {
     if (aOldDir != eDir_NotSet && aTextNode->HasTextNodeDirectionalityMap()) {
       // This node used to have a strong directional character but no
       // longer does. ResetTextNodeDirection() will re-resolve the
       // directionality of any elements whose directionality was
       // determined by this node.
       nsTextNodeDirectionalityMap::ResetTextNodeDirection(aTextNode);
     }
   } else {
     // This node has a strong directional character. If it has a
     // TextNodeDirectionalityMap property, it already determines the
     // directionality of some element(s), so call UpdateTextNodeDirection to
     // reresolve their directionality. Otherwise call
     // SetAncestorDirectionIfAuto to find ancestor elements which should
     // have their directionality determined by this node.
     if (aTextNode->HasTextNodeDirectionalityMap()) {
       nsTextNodeDirectionalityMap::UpdateTextNodeDirection(aTextNode, newDir);
     } else {
       SetAncestorDirectionIfAuto(aTextNode, newDir, aNotify);
     }
   }
 }
 void
 SetDirectionFromNewTextNode(nsIContent* aTextNode)
 {
   if (!NodeAffectsDirAutoAncestor(aTextNode)) {
     return;
   }
   Element* parent = aTextNode->GetParentElement();
   if (parent && parent->NodeOrAncestorHasDirAuto()) {
     aTextNode->SetAncestorHasDirAuto();
   }
   Directionality dir = GetDirectionFromText(aTextNode->GetText());
   if (dir != eDir_NotSet) {
     SetAncestorDirectionIfAuto(aTextNode, dir);
   }
 }
 void
 ResetDirectionSetByTextNode(nsTextNode* aTextNode, bool aNullParent)
 {
   if (!NodeAffectsDirAutoAncestor(aTextNode)) {
     nsTextNodeDirectionalityMap::EnsureMapIsClearFor(aTextNode);
     return;
   }
   Directionality dir = GetDirectionFromText(aTextNode->GetText());
   if (dir != eDir_NotSet && aTextNode->HasTextNodeDirectionalityMap()) {
     if (aNullParent) {
       nsTextNodeDirectionalityMap::ClearTextNodeDirection(aTextNode);
     } else {
       nsTextNodeDirectionalityMap::ResetTextNodeDirection(aTextNode);
     }
   }
 }
 void
 SetDirectionalityFromValue(Element* aElement, const nsAString& value,
                            bool aNotify)
 {
   Directionality dir = GetDirectionFromText(PromiseFlatString(value).get(),
                                             value.Length());
   if (dir == eDir_NotSet) {
     dir = eDir_LTR;
   }
   aElement->SetDirectionality(dir, aNotify);
 }
 void
 OnSetDirAttr(Element* aElement, const nsAttrValue* aNewValue,
              bool hadValidDir, bool hadDirAuto, bool aNotify)
 {
   if (aElement->IsHTML(nsGkAtoms::input)) {
     return;
   }
   if (aElement->AncestorHasDirAuto()) {
     if (!hadValidDir) {
       // The element is a descendant of an element with dir = auto, is
       // having its dir attribute set, and previously didn't have a valid dir
       // attribute.
       // Check whether any of its text node descendants determine the
       // direction of any of its ancestors, and redetermine their direction
       WalkDescendantsResetAutoDirection(aElement);
     } else if (!aElement->HasValidDir()) {
       // The element is a descendant of an element with dir = auto and is
       // having its dir attribute removed or set to an invalid value.
       // Reset the direction of any of its ancestors whose direction is
       // determined by a text node descendant
       WalkAncestorsResetAutoDirection(aElement, aNotify);
     }
   } else if (hadDirAuto && !aElement->HasDirAuto()) {
     // The element isn't a descendant of an element with dir = auto, and is
     // having its dir attribute set to something other than auto.
     // Walk the descendant tree and clear the AncestorHasDirAuto flag.
     //
     // N.B: For elements other than <bdi> it would be enough to test that the
     //      current value of dir was "auto" in BeforeSetAttr to know that we
     //      were unsetting dir="auto". For <bdi> things are more complicated,
     //      since it behaves like dir="auto" whenever the dir attribute is
     //      empty or invalid, so we would have to check whether the old value
     //      was not either "ltr" or "rtl", and the new value was either "ltr"
     //      or "rtl". Element::HasDirAuto() encapsulates all that, so doing it
     //      here is simpler.
     WalkDescendantsClearAncestorDirAuto(aElement);
   }
   if (aElement->HasDirAuto()) {
     WalkDescendantsSetDirAuto(aElement, aNotify);
   } else {
     if (aElement->HasDirAutoSet()) {
       nsINode* setByNode =
         static_cast<nsINode*>(aElement->GetProperty(nsGkAtoms::dirAutoSetBy));
       nsTextNodeDirectionalityMap::RemoveElementFromMap(setByNode, aElement);
     }
     SetDirectionalityOnDescendants(aElement,
                                    RecomputeDirectionality(aElement, aNotify),
                                    aNotify);
   }
 }
 void
 SetDirOnBind(mozilla::dom::Element* aElement, nsIContent* aParent)
 {
   // Set the AncestorHasDirAuto flag, unless this element shouldn't affect
   // ancestors that have dir=auto
   if (!DoesNotParticipateInAutoDirection(aElement) &&
       !aElement->IsHTML(nsGkAtoms::bdi) &&
       aParent && aParent->NodeOrAncestorHasDirAuto()) {
     aElement->SetAncestorHasDirAuto();
     nsIContent* child = aElement->GetFirstChild();
     if (child) {
       // If we are binding an element to the tree that already has descendants,
       // and the parent has NodeHasDirAuto or NodeAncestorHasDirAuto, we need
       // to set NodeAncestorHasDirAuto on all the element's descendants, except
       // for nodes that don't affect the direction of their ancestors.
       do {
         if (child->IsElement() &&
             DoesNotAffectDirectionOfAncestors(child->AsElement())) {
           child = child->GetNextNonChildNode(aElement);
           continue;
         }
         child->SetAncestorHasDirAuto();
         child = child->GetNextNode(aElement);
       } while (child);
       // We may also need to reset the direction of an ancestor with dir=auto
       WalkAncestorsResetAutoDirection(aElement, true);
     }
   }
   if (!aElement->HasDirAuto()) {
     // if the element doesn't have dir=auto, set its own directionality from
     // the dir attribute or by inheriting from its ancestors.
     RecomputeDirectionality(aElement, false);
   }
 }
 void ResetDir(mozilla::dom::Element* aElement)
 {
   if (aElement->HasDirAutoSet()) {
     nsINode* setByNode =
       static_cast<nsINode*>(aElement->GetProperty(nsGkAtoms::dirAutoSetBy));
     nsTextNodeDirectionalityMap::RemoveElementFromMap(setByNode, aElement);
   }
   if (!aElement->HasDirAuto()) {
     RecomputeDirectionality(aElement, false);
   }
 }
 } // end namespace mozilla

The Tor Browser / annotate

content/base/src/DirectionalityUtils.cpp@deefc01c0e14 (annotated)

content/base/src/DirectionalityUtils.cpp