Oilpan: Prepare to move FormAssociatedElement to Oilpan heap, part 2.

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 73 matching lines @@
 HTMLFormElement::~HTMLFormElement()
 {
 #if !ENABLE(OILPAN)
     // With Oilpan, either removedFrom is called or the document and
     // form controller are dead as well and there is no need to remove
     // this form element from it.
     document().formController().willDeleteForm(this);
 #endif
 }
 
+void HTMLFormElement::trace(Visitor* visitor)
+{
+#if ENABLE(OILPAN)
+    visitor->trace(m_associatedElements);
+#endif
+    HTMLElement::trace(visitor);
+}
+
 bool HTMLFormElement::rendererIsNeeded(const RenderStyle& style)
 {
     if (!m_wasDemoted)
         return HTMLElement::rendererIsNeeded(style);
 
     ContainerNode* node = parentNode();
     if (!node || !node->renderer())
         return HTMLElement::rendererIsNeeded(style);
     RenderObject* parentRenderer = node->renderer();
     // FIXME: Shouldn't we also check for table caption (see |formIsTablePart| below).
@@ skipping 18 matching lines @@
 
 Node::InsertionNotificationRequest HTMLFormElement::insertedInto(ContainerNode* insertionPoint)
 {
     HTMLElement::insertedInto(insertionPoint);
     if (insertionPoint->inDocument())
         this->document().didAssociateFormControl(this);
     return InsertionDone;
 }
 
 template<class T>
-void notifyFormRemovedFromTree(const Vector<T*>& elements, Node& root)
+void notifyFormRemovedFromTree(const T& elements, Node& root)
 {
     size_t size = elements.size();
     for (size_t i = 0; i < size; ++i)
         elements[i]->formRemovedFromTree(root);
     ASSERT(elements.size() == size);
 }
 
 void HTMLFormElement::removedFrom(ContainerNode* insertionPoint)
 {
     // We don't need to take care of form association by 'form' content
     // attribute becuse IdTargetObserver handles it.
     if (m_hasElementsAssociatedByParser) {
         Node& root = highestAncestorOrSelf();
         if (!m_associatedElementsAreDirty) {
-            Vector<FormAssociatedElement*> elements(associatedElements());
+            FormAssociatedElement::List elements(associatedElements());
             notifyFormRemovedFromTree(elements, root);
         } else {
-            Vector<FormAssociatedElement*> elements;
+            FormAssociatedElement::List elements;
             collectAssociatedElements(insertionPoint->highestAncestorOrSelf(), elements);
             notifyFormRemovedFromTree(elements, root);
             collectAssociatedElements(root, elements);
             notifyFormRemovedFromTree(elements, root);
         }
 
         if (!m_imageElementsAreDirty) {
             Vector<HTMLImageElement*> images(imageElements());
             notifyFormRemovedFromTree(images, root);
         } else {
@@ skipping 15 matching lines @@
     Node* targetNode = event->target()->toNode();
     if (event->eventPhase() != Event::CAPTURING_PHASE && targetNode && targetNode != this && (event->type() == EventTypeNames::submit || event->type() == EventTypeNames::reset)) {
         event->stopPropagation();
         return;
     }
     HTMLElement::handleLocalEvents(event);
 }
 
 unsigned HTMLFormElement::length() const
 {
-    const Vector<FormAssociatedElement*>& elements = associatedElements();
+    const FormAssociatedElement::List& elements = associatedElements();
     unsigned len = 0;
     for (unsigned i = 0; i < elements.size(); ++i) {
         if (elements[i]->isEnumeratable())
             ++len;
     }
     return len;
 }
 
 Element* HTMLFormElement::item(unsigned index)
 {
     return elements()->item(index);
 }
 
 void HTMLFormElement::submitImplicitly(Event* event, bool fromImplicitSubmissionTrigger)
 {
     int submissionTriggerCount = 0;
     bool seenDefaultButton = false;
-    const Vector<FormAssociatedElement*>& elements = associatedElements();
+    const FormAssociatedElement::List& elements = associatedElements();
     for (unsigned i = 0; i < elements.size(); ++i) {
         FormAssociatedElement* formAssociatedElement = elements[i];
         if (!formAssociatedElement->isFormControlElement())
             continue;
         HTMLFormControlElement* control = toHTMLFormControlElement(formAssociatedElement);
         if (!seenDefaultButton && control->canBeSuccessfulSubmitButton()) {
             if (fromImplicitSubmissionTrigger)
                 seenDefaultButton = true;
             if (control->isSuccessfulSubmitButton()) {
                 control->dispatchSimulatedClick(event);
@@ skipping 23 matching lines @@
 bool HTMLFormElement::validateInteractively(Event* event)
 {
     ASSERT(event);
     if (!document().page() || noValidate())
         return true;
 
     HTMLFormControlElement* submitElement = submitElementFromEvent(event);
     if (submitElement && submitElement->formNoValidate())
         return true;
 
-    const Vector<FormAssociatedElement*>& elements = associatedElements();
+    const FormAssociatedElement::List& elements = associatedElements();
     for (unsigned i = 0; i < elements.size(); ++i) {
         if (elements[i]->isFormControlElement())
             toHTMLFormControlElement(elements[i])->hideVisibleValidationMessage();
     }
 
     WillBeHeapVector<RefPtrWillBeMember<FormAssociatedElement> > unhandledInvalidControls;
     if (!checkInvalidControlsAndCollectUnhandled(&unhandledInvalidControls))
         return true;
     // Because the form has invalid controls, we abort the form submission and
     // show a validation message on a focusable form control.
@@ skipping 72 matching lines @@
     FrameView* view = document().view();
     LocalFrame* frame = document().frame();
     if (!view || !frame || !frame->page())
         return;
 
     m_wasUserSubmitted = processingUserGesture;
 
     RefPtr<HTMLFormControlElement> firstSuccessfulSubmitButton;
     bool needButtonActivation = activateSubmitButton; // do we need to activate a submit button?
 
-    const Vector<FormAssociatedElement*>& elements = associatedElements();
+    const FormAssociatedElement::List& elements = associatedElements();
     for (unsigned i = 0; i < elements.size(); ++i) {
         FormAssociatedElement* associatedElement = elements[i];
         if (!associatedElement->isFormControlElement())
             continue;
         if (needButtonActivation) {
             HTMLFormControlElement* control = toHTMLFormControlElement(associatedElement);
             if (control->isActivatedSubmit())
                 needButtonActivation = false;
             else if (firstSuccessfulSubmitButton == 0 && control->isSuccessfulSubmitButton())
                 firstSuccessfulSubmitButton = control;
@@ skipping 57 matching lines @@
     if (m_isInResetFunction || !frame)
         return;
 
     m_isInResetFunction = true;
 
     if (!dispatchEvent(Event::createCancelableBubble(EventTypeNames::reset))) {
         m_isInResetFunction = false;
         return;
     }
 
-    const Vector<FormAssociatedElement*>& elements = associatedElements();
+    const FormAssociatedElement::List& elements = associatedElements();
     for (unsigned i = 0; i < elements.size(); ++i) {
         if (elements[i]->isFormControlElement())
             toHTMLFormControlElement(elements[i])->reset();
     }
 
     m_isInResetFunction = false;
 }
 
 void HTMLFormElement::requestAutocomplete(const Dictionary& details)
 {
@@ skipping 99 matching lines @@
         return;
     m_hasElementsAssociatedByParser = true;
     UseCounter::count(document(), UseCounter::FormAssociationByParser);
 }
 
 PassRefPtr<HTMLCollection> HTMLFormElement::elements()
 {
     return ensureCachedHTMLCollection(FormControls);
 }
 
-void HTMLFormElement::collectAssociatedElements(Node& root, Vector<FormAssociatedElement*>& elements) const
+void HTMLFormElement::collectAssociatedElements(Node& root, FormAssociatedElement::List& elements) const
 {
     elements.clear();
     for (HTMLElement* element = Traversal<HTMLElement>::firstWithin(root); element; element = Traversal<HTMLElement>::next(*element)) {
         FormAssociatedElement* associatedElement = 0;
         if (element->isFormControlElement())
             associatedElement = toHTMLFormControlElement(element);
         else if (isHTMLObjectElement(*element))
             associatedElement = toHTMLObjectElement(element);
         else
             continue;
         if (associatedElement->form()== this)
             elements.append(associatedElement);
     }
 }
 
 // This function should be const conceptually. However we update some fields
 // because of lazy evaluation.
-const Vector<FormAssociatedElement*>& HTMLFormElement::associatedElements() const
+const FormAssociatedElement::List& HTMLFormElement::associatedElements() const
 {
     if (!m_associatedElementsAreDirty)
         return m_associatedElements;
     HTMLFormElement* mutableThis = const_cast<HTMLFormElement*>(this);
     Node* scope = mutableThis;
     if (m_hasElementsAssociatedByParser)
         scope = &highestAncestorOrSelf();
     if (inDocument() && treeScope().idTargetObserverRegistry().hasObservers(fastGetAttribute(idAttr)))
         scope = &treeScope().rootNode();
     ASSERT(scope);
@@ skipping 53 matching lines @@
     setAttribute(methodAttr, value);
 }
 
 bool HTMLFormElement::wasUserSubmitted() const
 {
     return m_wasUserSubmitted;
 }
 
 HTMLFormControlElement* HTMLFormElement::defaultButton() const
 {
-    const Vector<FormAssociatedElement*>& elements = associatedElements();
+    const FormAssociatedElement::List& elements = associatedElements();
     for (unsigned i = 0; i < elements.size(); ++i) {
         if (!elements[i]->isFormControlElement())
             continue;
         HTMLFormControlElement* control = toHTMLFormControlElement(elements[i]);
         if (control->isSuccessfulSubmitButton())
             return control;
     }
 
     return 0;
 }
 
 bool HTMLFormElement::checkValidity()
 {
     return !checkInvalidControlsAndCollectUnhandled(0);
 }
 
 bool HTMLFormElement::checkInvalidControlsAndCollectUnhandled(WillBeHeapVector<RefPtrWillBeMember<FormAssociatedElement> >* unhandledInvalidControls)
 {
     RefPtr<HTMLFormElement> protector(this);
     // Copy associatedElements because event handlers called from
     // HTMLFormControlElement::checkValidity() might change associatedElements.
-    const Vector<FormAssociatedElement*>& associatedElements = this->associatedElements();
+    const FormAssociatedElement::List& associatedElements = this->associatedElements();
     WillBeHeapVector<RefPtrWillBeMember<FormAssociatedElement> > elements;
     elements.reserveCapacity(associatedElements.size());
     for (unsigned i = 0; i < associatedElements.size(); ++i)
         elements.append(associatedElements[i]);
     bool hasInvalidControls = false;
     for (unsigned i = 0; i < elements.size(); ++i) {
         if (elements[i]->form() == this && elements[i]->isFormControlElement()) {
             HTMLFormControlElement* control = toHTMLFormControlElement(elements[i].get());
             if (!control->checkValidity(unhandledInvalidControls) && control->formOwner() == this)
                 hasInvalidControls = true;
@@ skipping 106 matching lines @@
 }
 
 void HTMLFormElement::setDemoted(bool demoted)
 {
     if (demoted)
         UseCounter::count(document(), UseCounter::DemotedFormElement);
     m_wasDemoted = demoted;
 }
 
 } // namespace