[oilpan] Handlify childrenChanged.

Source/core/html/HTMLElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2011 Motorola Mobility. 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 778 matching lines @@
             node = NodeTraversal::nextSkippingChildren(node, firstNode);
             continue;
         }
         node->setSelfOrAncestorHasDirAutoAttribute(flag);
         if (node == lastNode)
             return;
         node = NodeTraversal::next(node, firstNode);
     }
 }
 
-void HTMLElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
+void HTMLElement::childrenChanged(bool changedByParser, const Handle<Node>& beforeChange, const Handle<Node>& afterChange, int childCountDelta)
 {
     StyledElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 
     if (!selfOrAncestorHasDirAutoAttribute())
         return;
 
     for (Element* ancestor = this; ancestor; ancestor = ancestor->parentElement()) {
         if (!elementAffectsDirectionality(ancestor))
             continue;
         toHTMLElement(ancestor)->calculateAndAdjustDirectionality();
@@ skipping 27 matching lines @@
 {
     if (!(selfOrAncestorHasDirAutoAttribute() && hasDirectionAuto())) {
         isAuto = false;
         return LTR;
     }
 
     isAuto = true;
     return directionality();
 }
 
-TextDirection HTMLElement::directionality(Node** strongDirectionalityTextNode) const
+TextDirection HTMLElement::directionality(Handle<Node>* strongDirectionalityTextNode) const

[haraken, 2013/08/06 01:32:50]

Could you change Handle<Node>* to Handle<Node>& ? It looks like a bit dangerous
programming pattern to expose Handle<Node>*.

 {
     if (isHTMLTextFormControlElement(this)) {
         Handle<HTMLTextFormControlElement> textElement = toHTMLTextFormControlElement(const_cast<HTMLElement*>(this));
         bool hasStrongDirectionality;
         Unicode::Direction textDirection = textElement->value().defaultWritingDirection(&hasStrongDirectionality);
         if (strongDirectionalityTextNode)
-            *strongDirectionalityTextNode = hasStrongDirectionality ? textElement.raw() : 0;
+            *strongDirectionalityTextNode = hasStrongDirectionality ? textElement : nullptr;
         return (textDirection == Unicode::LeftToRight) ? LTR : RTL;
     }
 
     Node* node = firstChild();
     while (node) {
         // Skip bdi, script, style and text form controls.
         if (equalIgnoringCase(node->nodeName(), "bdi") || node->hasTagName(scriptTag) || node->hasTagName(styleTag) 
             || (node->isElementNode() && toElement(node)->isTextFormControl())) {
             node = NodeTraversal::nextSkippingChildren(node, this);
             continue;
         }
 
         // Skip elements with valid dir attribute
         if (node->isElementNode()) {
             AtomicString dirAttributeValue = toElement(node)->fastGetAttribute(dirAttr);
             if (equalIgnoringCase(dirAttributeValue, "rtl") || equalIgnoringCase(dirAttributeValue, "ltr") || equalIgnoringCase(dirAttributeValue, "auto")) {
                 node = NodeTraversal::nextSkippingChildren(node, this);
                 continue;
             }
         }
 
         if (node->isTextNode()) {
             bool hasStrongDirectionality;
             WTF::Unicode::Direction textDirection = node->textContent(true).defaultWritingDirection(&hasStrongDirectionality);
             if (hasStrongDirectionality) {
                 if (strongDirectionalityTextNode)
-                    *strongDirectionalityTextNode = node;
+                    *strongDirectionalityTextNode = adoptRawResult(node);
                 return (textDirection == WTF::Unicode::LeftToRight) ? LTR : RTL;
             }
         }
         node = NodeTraversal::next(node, this);
     }
     if (strongDirectionalityTextNode)
-        *strongDirectionalityTextNode = 0;
+        *strongDirectionalityTextNode = nullptr;
     return LTR;
 }
 
 void HTMLElement::dirAttributeChanged(const AtomicString& value)
 {
     Element* parent = parentElement();
 
     if (parent && parent->isHTMLElement() && parent->selfOrAncestorHasDirAutoAttribute())
         toHTMLElement(parent)->adjustDirectionalityIfNeededAfterChildAttributeChanged(this);
 
     if (equalIgnoringCase(value, "auto"))
         calculateAndAdjustDirectionality();
 }
 
 void HTMLElement::adjustDirectionalityIfNeededAfterChildAttributeChanged(Element* child)
 {
     ASSERT(selfOrAncestorHasDirAutoAttribute());
-    Node* strongDirectionalityTextNode;
-    TextDirection textDirection = directionality(&strongDirectionalityTextNode);
+    TextDirection textDirection = directionality();
     setHasDirAutoFlagRecursively(child, false);
     if (renderer() && renderer()->style() && renderer()->style()->direction() != textDirection) {
         Element* elementToAdjust = this;
         for (; elementToAdjust; elementToAdjust = elementToAdjust->parentElement()) {
             if (elementAffectsDirectionality(elementToAdjust)) {
                 elementToAdjust->setNeedsStyleRecalc();
                 return;
             }
         }
     }
 }
 
 void HTMLElement::calculateAndAdjustDirectionality()
 {
-    Node* strongDirectionalityTextNode;
+    Handle<Node> strongDirectionalityTextNode;
     TextDirection textDirection = directionality(&strongDirectionalityTextNode);
-    setHasDirAutoFlagRecursively(this, true, strongDirectionalityTextNode);
+    setHasDirAutoFlagRecursively(this, true, strongDirectionalityTextNode.raw());
     if (renderer() && renderer()->style() && renderer()->style()->direction() != textDirection)
         setNeedsStyleRecalc();
 }
 
 void HTMLElement::addHTMLLengthToStyle(Handle<MutableStylePropertySet> style, CSSPropertyID propertyID, const String& value)
 {
     // FIXME: This function should not spin up the CSS parser, but should instead just figure out the correct
     // length unit and make the appropriate parsed value.
 
     // strip attribute garbage..
@@ skipping 112 matching lines @@
 #ifndef NDEBUG
 
 // For use in the debugger
 void dumpInnerHTML(WebCore::HTMLElement*);
 
 void dumpInnerHTML(WebCore::HTMLElement* element)
 {
     printf("%s\n", element->innerHTML().ascii().data());
 }
 #endif