[oilpan] Completely move HTMLFormControlElement's hierarchy to the managed heap

Source/core/html/HTMLOptionElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2004, 2005, 2006, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2011 Motorola Mobility, Inc.  All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 127 matching lines @@
     return document->displayStringModifiedByEncoding(text).stripWhiteSpace(isHTMLSpace).simplifyWhiteSpace(isHTMLSpace);
 }
 
 void HTMLOptionElement::setText(const String &text, ExceptionCode& ec)
 {
     RefPtr<Node> protectFromMutationEvents(this);
 
     // Changing the text causes a recalc of a select's items, which will reset the selected
     // index to the first item if the select is single selection with a menu list. We attempt to
     // preserve the selected item.
-    RefPtr<HTMLSelectElement> select = ownerSelectElement();
+    Handle<HTMLSelectElement> select = ownerSelectElement();
     bool selectIsMenuList = select && select->usesMenuList();
     int oldSelectedIndex = selectIsMenuList ? select->selectedIndex() : -1;
 
     // Handle the common special case where there's exactly 1 child node, and it's a text node.
     Node* child = firstChild();
     if (child && child->isTextNode() && !child->nextSibling())
         toText(child)->setData(text, ec);
     else {
         removeChildren();
         appendChild(Text::create(document(), text), ec);
     }
     
     if (selectIsMenuList && select->selectedIndex() != oldSelectedIndex)
         select->setSelectedIndex(oldSelectedIndex);
 }
 
 void HTMLOptionElement::accessKeyAction(bool)
 {
-    HTMLSelectElement* select = ownerSelectElement();
+    Handle<HTMLSelectElement> select = ownerSelectElement();
     if (select)
         select->accessKeySetSelectedIndex(index());
 }
 
 int HTMLOptionElement::index() const
 {
     // It would be faster to cache the index, but harder to get it right in all cases.
 
-    HTMLSelectElement* selectElement = ownerSelectElement();
+    Handle<HTMLSelectElement> selectElement = ownerSelectElement();
     if (!selectElement)
         return 0;
 
     int optionIndex = 0;
 
     const Vector<HTMLElement*>& items = selectElement->listItems();
     size_t length = items.size();
     for (size_t i = 0; i < length; ++i) {
         if (!items[i]->hasTagName(optionTag))
             continue;
@@ skipping 41 matching lines @@
     return collectOptionInnerText().stripWhiteSpace(isHTMLSpace).simplifyWhiteSpace(isHTMLSpace);
 }
 
 void HTMLOptionElement::setValue(const String& value)
 {
     setAttribute(valueAttr, value);
 }
 
 bool HTMLOptionElement::selected()
 {
-    if (HTMLSelectElement* select = ownerSelectElement())
+    if (Handle<HTMLSelectElement> select = ownerSelectElement())
         select->updateListItemSelectedStates();
     return m_isSelected;
 }
 
 void HTMLOptionElement::setSelected(bool selected)
 {
     if (m_isSelected == selected)
         return;
 
     setSelectedState(selected);
 
-    if (HTMLSelectElement* select = ownerSelectElement())
+    if (Handle<HTMLSelectElement> select = ownerSelectElement())
         select->optionSelectionStateChanged(this, selected);
 }
 
 void HTMLOptionElement::setSelectedState(bool selected)
 {
     if (m_isSelected == selected)
         return;
 
     m_isSelected = selected;
     didAffectSelector(AffectedSelectorChecked);
 
-    if (HTMLSelectElement* select = ownerSelectElement())
+    if (Handle<HTMLSelectElement> select = ownerSelectElement())
         select->invalidateSelectedItems();
 }
 
 void HTMLOptionElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
 {
 #if ENABLE(DATALIST_ELEMENT)
     if (HTMLDataListElement* dataList = ownerDataListElement())
         dataList->optionElementChildrenChanged();
     else
 #endif
-    if (HTMLSelectElement* select = ownerSelectElement())
+    if (Handle<HTMLSelectElement> select = ownerSelectElement())
         select->optionElementChildrenChanged();
     HTMLElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 }
 
 #if ENABLE(DATALIST_ELEMENT)
 HTMLDataListElement* HTMLOptionElement::ownerDataListElement() const
 {
     for (ContainerNode* parent = parentNode(); parent ; parent = parent->parentNode()) {
         if (parent->hasTagName(datalistTag))
             return static_cast<HTMLDataListElement*>(parent);
     }
     return 0;
 }
 #endif
 
-HTMLSelectElement* HTMLOptionElement::ownerSelectElement() const
+Result<HTMLSelectElement> HTMLOptionElement::ownerSelectElement() const
 {
     ContainerNode* select = parentNode();
     while (select && !select->hasTagName(selectTag))
         select = select->parentNode();
 
     if (!select)
-        return 0;
+        return nullptr;
 
     return toHTMLSelectElement(select);
 }
 
 String HTMLOptionElement::label() const
 {
     const AtomicString& label = fastGetAttribute(labelAttr);
     if (!label.isNull())
         return label; 
     return collectOptionInnerText().stripWhiteSpace(isHTMLSpace).simplifyWhiteSpace(isHTMLSpace);
@@ skipping 19 matching lines @@
     // styleForRenderer is called whenever a new style should be associated
     // with an Element so now is a good time to update our cached style.
     updateNonRenderStyle();
     return m_style;
 }
 
 void HTMLOptionElement::didRecalcStyle(StyleChange)
 {
     // FIXME: This is nasty, we ask our owner select to repaint even if the new
     // style is exactly the same.
-    if (HTMLSelectElement* select = ownerSelectElement()) {
+    if (Handle<HTMLSelectElement> select = ownerSelectElement()) {
         if (RenderObject* renderer = select->renderer())
             renderer->repaint();
     }
 }
 
 String HTMLOptionElement::textIndentedToRespectGroupLabel() const
 {
     ContainerNode* parent = parentNode();
     if (parent && parent->hasTagName(optgroupTag))
         return "    " + text();
     return text();
 }
 
 bool HTMLOptionElement::isDisabledFormControl() const
 {
     if (ownElementDisabled())
         return true;
 
     if (!parentNode() || !parentNode()->isHTMLElement())
         return false;
 
     HTMLElement* parentElement = static_cast<HTMLElement*>(parentNode());
     return parentElement->hasTagName(optgroupTag) && parentElement->isDisabledFormControl();
 }
 
 Node::InsertionNotificationRequest HTMLOptionElement::insertedInto(ContainerNode* insertionPoint)
 {
-    if (HTMLSelectElement* select = ownerSelectElement()) {
+    if (Handle<HTMLSelectElement> select = ownerSelectElement()) {
         select->setRecalcListItems();
         // Do not call selected() since calling updateListItemSelectedStates()
         // at this time won't do the right thing. (Why, exactly?)
         // FIXME: Might be better to call this unconditionally, always passing m_isSelected,
         // rather than only calling it if we are selected.
         if (m_isSelected)
             select->optionSelectionStateChanged(this, true);
         select->scrollToSelection();
     }
 
@@ skipping 25 matching lines @@
 
 const HTMLOptionElement* toHTMLOptionElement(const Node* node)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!node || node->hasTagName(optionTag));
     return static_cast<const HTMLOptionElement*>(node);
 }
 
 #endif
 
 } // namespace