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

Source/core/html/HTMLFormElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * 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 166 matching lines @@
     return elements()->item(index);
 }
 
 void HTMLFormElement::submitImplicitly(Event* event, bool fromImplicitSubmissionTrigger)
 {
     int submissionTriggerCount = 0;
     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
         FormAssociatedElement* formAssociatedElement = m_associatedElements[i];
         if (!formAssociatedElement->isFormControlElement())
             continue;
-        HTMLFormControlElement* formElement = static_cast<HTMLFormControlElement*>(formAssociatedElement);
+        Handle<HTMLFormControlElement> formElement(static_cast<HTMLFormControlElement*>(formAssociatedElement));
         if (formElement->isSuccessfulSubmitButton()) {
             if (formElement->renderer()) {
                 formElement->dispatchSimulatedClick(event);
                 return;
             }
         } else if (formElement->canTriggerImplicitSubmission())
             ++submissionTriggerCount;
     }
     if (fromImplicitSubmissionTrigger && submissionTriggerCount == 1)
         prepareForSubmission(event);
 }
 
-static inline HTMLFormControlElement* submitElementFromEvent(const Event* event)
+static inline Result<HTMLFormControlElement> submitElementFromEvent(const Event* event)
 {
     for (Node* node = event->target()->toNode(); node; node = node->parentNode()) {
         if (node->isElementNode() && toElement(node)->isFormControlElement())
-            return static_cast<HTMLFormControlElement*>(node);
+            return Handle<HTMLFormControlElement>(static_cast<HTMLFormControlElement*>(node));
     }
-    return 0;
+    return nullptr;
 }
 
 bool HTMLFormElement::validateInteractively(Event* event)
 {
     ASSERT(event);
     if (!document()->page() || !document()->page()->settings()->interactiveFormValidationEnabled() || noValidate())
         return true;
 
-    HTMLFormControlElement* submitElement = submitElementFromEvent(event);
+    Handle<HTMLFormControlElement> submitElement = submitElementFromEvent(event);
     if (submitElement && submitElement->formNoValidate())
         return true;
 
     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
         if (m_associatedElements[i]->isFormControlElement())
             static_cast<HTMLFormControlElement*>(m_associatedElements[i])->hideVisibleValidationMessage();
     }
 
     Vector<RefPtr<FormAssociatedElement> > unhandledInvalidControls;
     if (!checkInvalidControlsAndCollectUnhandled(unhandledInvalidControls))
@@ skipping 78 matching lines @@
 {
     ASSERT_ARG(fieldNamesAndValues, fieldNamesAndValues.isEmpty());
 
     fieldNamesAndValues.reserveCapacity(m_associatedElements.size());
     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
         FormAssociatedElement* control = m_associatedElements[i];
         HTMLElement* element = toHTMLElement(control);
         if (!element->hasLocalName(inputTag))
             continue;
 
-        HTMLInputElement* input = static_cast<HTMLInputElement*>(control);
+        Handle<HTMLInputElement> input(static_cast<HTMLInputElement*>(control));
         if (!input->isTextField())
             continue;
 
         fieldNamesAndValues.append(make_pair(input->name().string(), input->value()));
     }
 }
 
 void HTMLFormElement::submit(Event* event, bool activateSubmitButton, bool processingUserGesture, FormSubmissionTrigger formSubmissionTrigger)
 {
     FrameView* view = document()->view();
     Frame* frame = document()->frame();
     if (!view || !frame)
         return;
 
     if (m_isSubmittingOrPreparingForSubmission) {
         m_shouldSubmit = true;
         return;
     }
 
     m_isSubmittingOrPreparingForSubmission = true;
     m_wasUserSubmitted = processingUserGesture;
 
-    HTMLFormControlElement* firstSuccessfulSubmitButton = 0;
+    Handle<HTMLFormControlElement> firstSuccessfulSubmitButton;
     bool needButtonActivation = activateSubmitButton; // do we need to activate a submit button?
 
     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
         FormAssociatedElement* associatedElement = m_associatedElements[i];
         if (!associatedElement->isFormControlElement())
             continue;
         if (needButtonActivation) {
-            HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(associatedElement);
+            Handle<HTMLFormControlElement> control(static_cast<HTMLFormControlElement*>(associatedElement));
             if (control->isActivatedSubmit())
                 needButtonActivation = false;
             else if (firstSuccessfulSubmitButton == 0 && control->isSuccessfulSubmitButton())
                 firstSuccessfulSubmitButton = control;
         }
     }
 
     if (needButtonActivation && firstSuccessfulSubmitButton)
         firstSuccessfulSubmitButton->setActivatedSubmit(true);
 
@@ skipping 256 matching lines @@
 String HTMLFormElement::target() const
 {
     return getAttribute(targetAttr);
 }
 
 bool HTMLFormElement::wasUserSubmitted() const
 {
     return m_wasUserSubmitted;
 }
 
-HTMLFormControlElement* HTMLFormElement::defaultButton() const
+Result<HTMLFormControlElement> HTMLFormElement::defaultButton() const
 {
     for (unsigned i = 0; i < m_associatedElements.size(); ++i) {
         if (!m_associatedElements[i]->isFormControlElement())
             continue;
-        HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(m_associatedElements[i]);
+        Handle<HTMLFormControlElement> control(static_cast<HTMLFormControlElement*>(m_associatedElements[i]));
         if (control->isSuccessfulSubmitButton())
             return control;
     }
 
-    return 0;
+    return nullptr;
 }
 
 bool HTMLFormElement::checkValidity()
 {
     Vector<RefPtr<FormAssociatedElement> > controls;
     return !checkInvalidControlsAndCollectUnhandled(controls);
 }
 
 bool HTMLFormElement::checkInvalidControlsAndCollectUnhandled(Vector<RefPtr<FormAssociatedElement> >& unhandledInvalidControls)
 {
     RefPtr<HTMLFormElement> protector(this);
     // Copy m_associatedElements because event handlers called from
     // HTMLFormControlElement::checkValidity() might change m_associatedElements.
     Vector<RefPtr<FormAssociatedElement> > elements;
     elements.reserveCapacity(m_associatedElements.size());
     for (unsigned i = 0; i < m_associatedElements.size(); ++i)
         elements.append(m_associatedElements[i]);
     bool hasInvalidControls = false;
     for (unsigned i = 0; i < elements.size(); ++i) {
         if (elements[i]->form() == this && elements[i]->isFormControlElement()) {
-            HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(elements[i].get());
+            Handle<HTMLFormControlElement> control(static_cast<HTMLFormControlElement*>(elements[i].get()));
             if (!control->checkValidity(&unhandledInvalidControls) && control->form() == this)
                 hasInvalidControls = true;
         }
     }
     return hasInvalidControls;
 }
 
-HTMLFormControlElement* HTMLFormElement::elementForAlias(const AtomicString& alias)
+Result<HTMLFormControlElement> HTMLFormElement::elementForAlias(const AtomicString& alias)
 {
     if (alias.isEmpty() || !m_elementAliases)
-        return 0;
-    return m_elementAliases->get(alias.impl()).get();
+        return nullptr;
+    return m_elementAliases->get(alias.impl());
 }
 
-void HTMLFormElement::addElementAlias(HTMLFormControlElement* element, const AtomicString& alias)
+void HTMLFormElement::addElementAlias(Handle<HTMLFormControlElement> element, const AtomicString& alias)
 {
     if (alias.isEmpty())
         return;
     if (!m_elementAliases)
         m_elementAliases = adoptPtr(new AliasMap);
     m_elementAliases->set(alias.impl(), element);
 }
 
 void HTMLFormElement::getNamedElements(const AtomicString& name, Vector<RefPtr<Node> >& namedItems)
 {
     elements()->namedItems(name, namedItems);
 
-    HTMLFormControlElement* aliasElement = elementForAlias(name);
+    Handle<HTMLFormControlElement> aliasElement = elementForAlias(name);
     if (aliasElement) {
-        if (namedItems.find(aliasElement) == notFound) {
+        if (namedItems.find(aliasElement.passRefPtr()) == notFound) {

[Vyacheslav Egorov (Google), 2013/07/18 16:50:08]

Any specific reason why you decided to use passRefPtr here instead of .raw()?

[haraken, 2013/07/19 02:57:09]

Done.

             // We have seen it before but it is gone now. Still, we need to return it.
             // FIXME: The above comment is not clear enough; it does not say why we need to do this.
-            namedItems.append(aliasElement);
+            namedItems.append(aliasElement.passRefPtr());
         }
     }
-    if (namedItems.size() && namedItems.first() != aliasElement)
-        addElementAlias(static_cast<HTMLFormControlElement*>(namedItems.first().get()), name);
+    if (namedItems.size() && namedItems.first().get() != aliasElement.raw())
+        addElementAlias(Handle<HTMLFormControlElement>(static_cast<HTMLFormControlElement*>(namedItems.first().get())), name);
 }
 
 bool HTMLFormElement::shouldAutocomplete() const
 {
     return !equalIgnoringCase(fastGetAttribute(autocompleteAttr), "off");
 }
 
 void HTMLFormElement::finishParsingChildren()
 {
     HTMLElement::finishParsingChildren();
     document()->formController()->restoreControlStateIn(*this);
 }
 
 void HTMLFormElement::copyNonAttributePropertiesFromElement(const Element& source)
 {
     m_wasDemoted = static_cast<const HTMLFormElement&>(source).m_wasDemoted;
     HTMLElement::copyNonAttributePropertiesFromElement(source);
 }
 
 } // namespace