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

Source/core/html/FormController.cpp

 /*
  * Copyright (C) 2006, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010, 2011, 2012 Google Inc. 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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 14 matching lines @@
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/platform/FileChooser.h"
 #include <wtf/FastMalloc.h>
 #include <wtf/text/StringBuilder.h>
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
-static inline HTMLFormElement* ownerFormForState(const HTMLFormControlElementWithState& control)
+static inline HTMLFormElement* ownerFormForState(Handle<const HTMLFormControlElementWithState> control)
 {
     // Assume controls with form attribute have no owners because we restore
     // state during parsing and form owners of such controls might be
     // indeterminate.
-    return control.fastHasAttribute(formAttr) ? 0 : control.form();
+    return control->fastHasAttribute(formAttr) ? 0 : control->form();
 }
 
 // ----------------------------------------------------------------------------
 
 // Serilized form of FormControlState:
 //  (',' means strings around it are separated in stateVector.)
 //
 // SerializedControlState ::= SkipState | RestoreState
 // SkipState ::= '0'
 // RestoreState ::= UnsignedNumber, ControlValue+
@@ skipping 235 matching lines @@
 }
 
 // ----------------------------------------------------------------------------
 
 class FormKeyGenerator {
     WTF_MAKE_NONCOPYABLE(FormKeyGenerator);
     WTF_MAKE_FAST_ALLOCATED;
 
 public:
     static PassOwnPtr<FormKeyGenerator> create() { return adoptPtr(new FormKeyGenerator); }
-    AtomicString formKey(const HTMLFormControlElementWithState&);
+    AtomicString formKey(Handle<const HTMLFormControlElementWithState>);
     void willDeleteForm(HTMLFormElement*);
 
     void clearWeakPointers(Visitor*);
 
 private:
     FormKeyGenerator() { }
 
     typedef HashMap<HTMLFormElement*, AtomicString> FormToKeyMap;
     typedef HashMap<String, unsigned> FormSignatureToNextIndexMap;
     FormToKeyMap m_formToKeyMap;
     FormSignatureToNextIndexMap m_formSignatureToNextIndexMap;
 };
 
 static inline void recordFormStructure(const HTMLFormElement& form, StringBuilder& builder)
 {
     // 2 is enough to distinguish forms in webkit.org/b/91209#c0
     const size_t namedControlsToBeRecorded = 2;
     const Vector<FormAssociatedElement*>& controls = form.associatedElements();
     builder.append(" [");
     for (size_t i = 0, namedControls = 0; i < controls.size() && namedControls < namedControlsToBeRecorded; ++i) {
         if (!controls[i]->isFormControlElementWithState())
             continue;
-        HTMLFormControlElementWithState* control = static_cast<HTMLFormControlElementWithState*>(controls[i]);
-        if (!ownerFormForState(*control))
+        Handle<HTMLFormControlElementWithState> control(static_cast<HTMLFormControlElementWithState*>(controls[i]));
+        if (!ownerFormForState(control))
             continue;
         AtomicString name = control->name();
         if (name.isEmpty())
             continue;
         namedControls++;
         builder.append(name);
         builder.append(" ");
     }
     builder.append("]");
 }
 
 static inline String formSignature(const HTMLFormElement& form)
 {
     KURL actionURL = form.getURLAttribute(actionAttr);
     // Remove the query part because it might contain volatile parameters such
     // as a session key.
     actionURL.setQuery(String());
     StringBuilder builder;
     if (!actionURL.isEmpty())
         builder.append(actionURL.string());
 
     recordFormStructure(form, builder);
     return builder.toString();
 }
 
-AtomicString FormKeyGenerator::formKey(const HTMLFormControlElementWithState& control)
+AtomicString FormKeyGenerator::formKey(Handle<const HTMLFormControlElementWithState> control)
 {
     HTMLFormElement* form = ownerFormForState(control);
     if (!form) {
         DEFINE_STATIC_LOCAL(AtomicString, formKeyForNoOwner, ("No owner", AtomicString::ConstructFromLiteral));
         return formKeyForNoOwner;
     }
     FormToKeyMap::const_iterator it = m_formToKeyMap.find(form);
     if (it != m_formToKeyMap.end())
         return it->value;
 
@@ skipping 38 matching lines @@
     // contain some characters which are rarely used for name attribute values.
     DEFINE_STATIC_LOCAL(String, signature, (ASCIILiteral("\n\r?% WebKit serialized form state version 8 \n\r=&")));
     return signature;
 }
 
 PassOwnPtr<FormController::SavedFormStateMap> FormController::createSavedFormStateMap(const FormElementListHashSet& controlList)
 {
     OwnPtr<FormKeyGenerator> keyGenerator = FormKeyGenerator::create();
     OwnPtr<SavedFormStateMap> stateMap = adoptPtr(new SavedFormStateMap);
     for (FormElementListHashSet::const_iterator it = controlList.begin(); it != controlList.end(); ++it) {
-        HTMLFormControlElementWithState* control = *it;
+        Handle<HTMLFormControlElementWithState> control = Handle<HTMLFormControlElementWithState>(*it); // FIXME(oilpan): Remove Handle<>().
         if (!control->shouldSaveAndRestoreFormControlState())
             continue;
-        SavedFormStateMap::AddResult result = stateMap->add(keyGenerator->formKey(*control).impl(), nullptr);
+        SavedFormStateMap::AddResult result = stateMap->add(keyGenerator->formKey(control).impl(), nullptr);
         if (result.isNewEntry)
             result.iterator->value = SavedFormState::create();
         result.iterator->value->appendControlState(control->name(), control->type(), control->saveFormControlState());
     }
     return stateMap.release();
 }
 
 Vector<String> FormController::formElementsState() const
 {
     OwnPtr<SavedFormStateMap> stateMap = createSavedFormStateMap(m_formElementsWithState);
     Vector<String> stateVector;
     stateVector.reserveInitialCapacity(m_formElementsWithState.size() * 4);
     stateVector.append(formStateSignature());
     for (SavedFormStateMap::const_iterator it = stateMap->begin(); it != stateMap->end(); ++it) {
         stateVector.append(it->key.get());
         it->value->serializeTo(stateVector);
     }
     bool hasOnlySignature = stateVector.size() == 1;
     if (hasOnlySignature)
         stateVector.clear();
     return stateVector;
 }
 
 void FormController::setStateForNewFormElements(const Vector<String>& stateVector)
 {
     formStatesFromStateVector(stateVector, m_savedFormStateMap);
 }
 
-FormControlState FormController::takeStateForFormElement(const HTMLFormControlElementWithState& control)
+FormControlState FormController::takeStateForFormElement(Handle<const HTMLFormControlElementWithState> control)
 {
     if (m_savedFormStateMap.isEmpty())
         return FormControlState();
     if (!m_formKeyGenerator)
         m_formKeyGenerator = FormKeyGenerator::create();
     SavedFormStateMap::iterator it = m_savedFormStateMap.find(m_formKeyGenerator->formKey(control).impl());
     if (it == m_savedFormStateMap.end())
         return FormControlState();
-    FormControlState state = it->value->takeControlState(control.name(), control.type());
+    FormControlState state = it->value->takeControlState(control->name(), control->type());
     if (it->value->isEmpty())
         m_savedFormStateMap.remove(it);
     return state;
 }
 
 void FormController::formStatesFromStateVector(const Vector<String>& stateVector, SavedFormStateMap& map)
 {
     map.clear();
 
     size_t i = 0;
@@ skipping 12 matching lines @@
     if (i != stateVector.size())
         map.clear();
 }
 
 void FormController::willDeleteForm(HTMLFormElement* form)
 {
     if (m_formKeyGenerator)
         m_formKeyGenerator->willDeleteForm(form);
 }
 
-void FormController::restoreControlStateFor(HTMLFormControlElementWithState& control)
+void FormController::restoreControlStateFor(Handle<HTMLFormControlElementWithState> control)
 {
     // We don't save state of a control with shouldSaveAndRestoreFormControlState()
     // == false. But we need to skip restoring process too because a control in
     // another form might have the same pair of name and type and saved its state.
-    if (!control.shouldSaveAndRestoreFormControlState())
+    if (!control->shouldSaveAndRestoreFormControlState())
         return;
     if (ownerFormForState(control))
         return;
     FormControlState state = takeStateForFormElement(control);
     if (state.valueSize() > 0)
-        control.restoreFormControlState(state);
+        control->restoreFormControlState(state);
 }
 
 void FormController::restoreControlStateIn(HTMLFormElement& form)
 {
     const Vector<FormAssociatedElement*>& elements = form.associatedElements();
     for (size_t i = 0; i < elements.size(); ++i) {
         if (!elements[i]->isFormControlElementWithState())
             continue;
-        HTMLFormControlElementWithState* control = static_cast<HTMLFormControlElementWithState*>(elements[i]);
+        Handle<HTMLFormControlElementWithState> control(static_cast<HTMLFormControlElementWithState*>(elements[i]));
         if (!control->shouldSaveAndRestoreFormControlState())
             continue;
-        if (ownerFormForState(*control) != &form)
+        if (ownerFormForState(control) != &form)
             continue;
-        FormControlState state = takeStateForFormElement(*control);
+        FormControlState state = takeStateForFormElement(control);
         if (state.valueSize() > 0)
             control->restoreFormControlState(state);
     }
 }
 
 Vector<String> FormController::getReferencedFilePaths(const Vector<String>& stateVector)
 {
     Vector<String> toReturn;
     SavedFormStateMap map;
     formStatesFromStateVector(stateVector, map);
     for (SavedFormStateMap::const_iterator it = map.begin(); it != map.end(); ++it)
         toReturn.append(it->value->getReferencedFilePaths());
     return toReturn;
 }
 
 void FormController::clearWeakPointers(Visitor* visitor)
 {
     clearWeakSet(visitor, m_formElementsWithState);
     if (m_formKeyGenerator)
         m_formKeyGenerator->clearWeakPointers(visitor);
 }
 
 } // namespace WebCore