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

Source/core/html/HTMLInputElement.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, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Samsung Electronics. All rights reserved.
@@ skipping 74 matching lines @@
 using namespace std;
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 #if ENABLE(DATALIST_ELEMENT)
 class ListAttributeTargetObserver : IdTargetObserver {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    static PassOwnPtr<ListAttributeTargetObserver> create(const AtomicString& id, HTMLInputElement*);
+    static PassOwnPtr<ListAttributeTargetObserver> create(const AtomicString& id, Handle<HTMLInputElement>);
     virtual void idTargetChanged() OVERRIDE;
 
 private:
-    ListAttributeTargetObserver(const AtomicString& id, HTMLInputElement*);
+    ListAttributeTargetObserver(const AtomicString& id, Handle<HTMLInputElement>);
 
+    // FIXME(oilpan): Move ListAttributeTargetObserver to the heap and use a Member.
     HTMLInputElement* m_element;
 };
 #endif
 
 // FIXME: According to HTML4, the length attribute's value can be arbitrarily
 // large. However, due to https://bugs.webkit.org/show_bug.cgi?id=14536 things
 // get rather sluggish when a text field has a larger number of characters than
 // this, even when just clicking in the text field.
 const int HTMLInputElement::maximumLength = 524288;
 const int defaultSize = 20;
@@ skipping 13 matching lines @@
     , m_isAutofilled(false)
 #if ENABLE(DATALIST_ELEMENT)
     , m_hasNonEmptyList(false)
 #endif
     , m_stateRestored(false)
     , m_parsingInProgress(createdByParser)
     , m_valueAttributeWasUpdatedAfterParsing(false)
     , m_wasModifiedByUser(false)
     , m_canReceiveDroppedFiles(false)
     , m_hasTouchEventHandler(false)
-    , m_inputType(InputType::createText(this))
+    , m_inputType(InputType::createText(Handle<HTMLInputElement>(this)))
 {
     ASSERT(hasTagName(inputTag) || hasTagName(isindexTag));
 #if ENABLE(INPUT_MULTIPLE_FIELDS_UI)
     setHasCustomStyleCallbacks();
 #endif
     ScriptWrappable::init(this);
 }
 
-PassRefPtr<HTMLInputElement> HTMLInputElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form, bool createdByParser)
+Result<HTMLInputElement> HTMLInputElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form, bool createdByParser)
 {
-    RefPtr<HTMLInputElement> inputElement = adoptRef(new HTMLInputElement(tagName, document, form, createdByParser));
+    Handle<HTMLInputElement> inputElement = adoptNode(new HTMLInputElement(tagName, document, form, createdByParser));
     inputElement->ensureUserAgentShadowRoot();
-    return inputElement.release();
+    return inputElement;
 }
 
 HTMLImageLoader* HTMLInputElement::imageLoader()
 {
     if (!m_imageLoader)
         m_imageLoader = adoptPtr(new HTMLImageLoader(this));
     return m_imageLoader.get();
 }
 
 void HTMLInputElement::didAddUserAgentShadowRoot(ShadowRoot*)
 {
     m_inputType->createShadowSubtree();
 }
 
 HTMLInputElement::~HTMLInputElement()
 {
     // Need to remove form association while this is still an HTMLInputElement
     // so that virtual functions are called correctly.
     setForm(0);
     // setForm(0) may register this to a document-level radio button group.
     // We should unregister it to avoid accessing a deleted object.
     if (isRadioButton())
-        document()->formController()->checkedRadioButtons().removeButton(this);
+        document()->formController()->checkedRadioButtons().removeButton(Handle<HTMLInputElement>(this));
     if (m_hasTouchEventHandler)
         document()->didRemoveEventTargetNode(this);
 }
 
 const AtomicString& HTMLInputElement::name() const
 {
     return m_name.isNull() ? emptyAtom : m_name;
 }
 
 Vector<FileChooserFileInfo> HTMLInputElement::filesFromFileInputFormControlState(const FormControlState& state)
@@ skipping 260 matching lines @@
     // attribute in other browsers and then fix this. Note that setting to null *does* remove
     // the attribute and setAttribute implements that.
     if (type.isEmpty())
         removeAttribute(typeAttr);
     else
         setAttribute(typeAttr, type);
 }
 
 void HTMLInputElement::updateType()
 {
-    OwnPtr<InputType> newType = InputType::create(this, fastGetAttribute(typeAttr));
+    OwnPtr<InputType> newType = InputType::create(Handle<HTMLInputElement>(this), fastGetAttribute(typeAttr));
     bool hadType = m_hasType;
     m_hasType = true;
     if (m_inputType->formControlType() == newType->formControlType())
         return;
 
     if (hadType && !newType->canChangeFromAnotherType()) {
         // Set the attribute back to the old value.
         // Useful in case we were called from inside parseAttribute.
         setAttribute(typeAttr, type());
         return;
@@ skipping 387 matching lines @@
 void HTMLInputElement::setChecked(bool nowChecked, TextFieldEventBehavior eventBehavior)
 {
     if (checked() == nowChecked)
         return;
 
     m_reflectsCheckedAttribute = false;
     m_isChecked = nowChecked;
     setNeedsStyleRecalc();
 
     if (CheckedRadioButtons* buttons = checkedRadioButtons())
-            buttons->updateCheckedState(this);
+        buttons->updateCheckedState(Handle<HTMLInputElement>(this));
     if (renderer() && renderer()->style()->hasAppearance())
         renderer()->theme()->stateChanged(renderer(), CheckedState);
     setNeedsValidityCheck();
 
     // Ideally we'd do this from the render tree (matching
     // RenderTextView), but it's not possible to do it at the moment
     // because of the way the code is structured.
     if (renderer()) {
         if (AXObjectCache* cache = renderer()->document()->existingAXObjectCache())
             cache->checkedStateChanged(this);
@@ skipping 385 matching lines @@
 Vector<String> HTMLInputElement::acceptMIMETypes()
 {
     return parseAcceptAttribute(fastGetAttribute(acceptAttr), isValidMIMEType);
 }
 
 Vector<String> HTMLInputElement::acceptFileExtensions()
 {
     return parseAcceptAttribute(fastGetAttribute(acceptAttr), isValidFileExtension);
 }
 
-String HTMLInputElement::accept() const
-{
-    return fastGetAttribute(acceptAttr);
-}
-
 String HTMLInputElement::alt() const
 {
     return fastGetAttribute(altAttr);
 }
 
 int HTMLInputElement::maxLength() const
 {
     return m_maxLength;
 }
 
@@ skipping 172 matching lines @@
 #endif
 }
 
 void HTMLInputElement::didMoveToNewDocument(Document* oldDocument)
 {
     if (hasImageLoader())
         imageLoader()->elementDidMoveToNewDocument();
 
     if (oldDocument) {
         if (isRadioButton())
-            oldDocument->formController()->checkedRadioButtons().removeButton(this);
+            oldDocument->formController()->checkedRadioButtons().removeButton(Handle<HTMLInputElement>(this));
         if (m_hasTouchEventHandler)
             oldDocument->didRemoveEventTargetNode(this);
     }
 
     if (m_hasTouchEventHandler)
         document()->didAddTouchEventHandler(this);
 
     HTMLTextFormControlElement::didMoveToNewDocument(oldDocument);
 }
 
 void HTMLInputElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
 {
     HTMLTextFormControlElement::addSubresourceAttributeURLs(urls);
 
     addSubresourceURL(urls, src());
 }
 
 bool HTMLInputElement::recalcWillValidate() const
 {
     return m_inputType->supportsValidation() && HTMLTextFormControlElement::recalcWillValidate();
 }
 
 void HTMLInputElement::requiredAttributeChanged()
 {
     HTMLTextFormControlElement::requiredAttributeChanged();
     if (CheckedRadioButtons* buttons = checkedRadioButtons())
-        buttons->requiredAttributeChanged(this);
+        buttons->requiredAttributeChanged(Handle<HTMLInputElement>(this));
     m_inputType->requiredAttributeChanged();
 }
 
 #if ENABLE(INPUT_TYPE_COLOR)
 void HTMLInputElement::selectColorInColorChooser(const Color& color)
 {
     if (!m_inputType->isColorControl())
         return;
     static_cast<ColorInputType*>(m_inputType.get())->didChooseColor(color);
 }
@@ skipping 18 matching lines @@
         return 0;
     if (!element->hasTagName(datalistTag))
         return 0;
 
     return static_cast<HTMLDataListElement*>(element);
 }
 
 void HTMLInputElement::resetListAttributeTargetObserver()
 {
     if (inDocument())
-        m_listAttributeTargetObserver = ListAttributeTargetObserver::create(fastGetAttribute(listAttr), this);
+        m_listAttributeTargetObserver = ListAttributeTargetObserver::create(fastGetAttribute(listAttr), Handle<HTMLInputElement>(this));
     else
         m_listAttributeTargetObserver = nullptr;
 }
 
 void HTMLInputElement::listAttributeTargetChanged()
 {
     m_inputType->listAttributeTargetChanged();
 }
 #endif // ENABLE(DATALIST_ELEMENT)
 
@@ skipping 202 matching lines @@
 {
     setAttribute(captureAttr, value);
 }
 
 #endif
 
 bool HTMLInputElement::isInRequiredRadioButtonGroup()
 {
     ASSERT(isRadioButton());
     if (CheckedRadioButtons* buttons = checkedRadioButtons())
-        return buttons->isInRequiredGroup(this);
+        return buttons->isInRequiredGroup(Handle<HTMLInputElement>(this));
     return false;
 }
 
-HTMLInputElement* HTMLInputElement::checkedRadioButtonForGroup() const
+Result<HTMLInputElement> HTMLInputElement::checkedRadioButtonForGroup() const
 {
     if (CheckedRadioButtons* buttons = checkedRadioButtons())
         return buttons->checkedButtonForGroup(name());
-    return 0;
+    return nullptr;
 }
 
 CheckedRadioButtons* HTMLInputElement::checkedRadioButtons() const
 {
     if (!isRadioButton())
         return 0;
     if (HTMLFormElement* formElement = form())
         return &formElement->checkedRadioButtons();
     if (inDocument())
         return &document()->formController()->checkedRadioButtons();
     return 0;
 }
 
 inline void HTMLInputElement::addToRadioButtonGroup()
 {
     if (CheckedRadioButtons* buttons = checkedRadioButtons())
-        buttons->addButton(this);
+        buttons->addButton(Handle<HTMLInputElement>(this));
 }
 
 inline void HTMLInputElement::removeFromRadioButtonGroup()
 {
     if (CheckedRadioButtons* buttons = checkedRadioButtons())
-        buttons->removeButton(this);
+        buttons->removeButton(Handle<HTMLInputElement>(this));
 }
 
 unsigned HTMLInputElement::height() const
 {
     return m_inputType->height();
 }
 
 unsigned HTMLInputElement::width() const
 {
     return m_inputType->width();
 }
 
 void HTMLInputElement::setHeight(unsigned height)
 {
     setAttribute(heightAttr, String::number(height));
 }
 
 void HTMLInputElement::setWidth(unsigned width)
 {
     setAttribute(widthAttr, String::number(width));
 }
 
 #if ENABLE(DATALIST_ELEMENT)
-PassOwnPtr<ListAttributeTargetObserver> ListAttributeTargetObserver::create(const AtomicString& id, HTMLInputElement* element)
+PassOwnPtr<ListAttributeTargetObserver> ListAttributeTargetObserver::create(const AtomicString& id, Handle<HTMLInputElement> element)
 {
     return adoptPtr(new ListAttributeTargetObserver(id, element));
 }
 
-ListAttributeTargetObserver::ListAttributeTargetObserver(const AtomicString& id, HTMLInputElement* element)
+ListAttributeTargetObserver::ListAttributeTargetObserver(const AtomicString& id, Handle<HTMLInputElement> element)
     : IdTargetObserver(element->treeScope()->idTargetObserverRegistry(), id)
-    , m_element(element)
+    , m_element(element.raw())
 {
 }
 
 void ListAttributeTargetObserver::idTargetChanged()
 {
     m_element->listAttributeTargetChanged();
 }
 #endif
 
 void HTMLInputElement::setRangeText(const String& replacement, ExceptionCode& ec)
@@ skipping 72 matching lines @@
 #endif
 }
 
 #if ENABLE(INPUT_MULTIPLE_FIELDS_UI)
 PassRefPtr<RenderStyle> HTMLInputElement::customStyleForRenderer()
 {
     return m_inputType->customStyleForRenderer(document()->styleResolver()->styleForElement(this));
 }
 #endif
 
+void HTMLInputElement::acceptHeapVisitor(Visitor* visitor) const
+{
+    HTMLTextFormControlElement::acceptHeapVisitor(visitor);
+}
+
 } // namespace