Have InputType factories take an HTMLInputElement reference in parameter

Source/core/html/forms/TextFieldInputType.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 40 matching lines @@
 #include "core/page/Settings.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderTextControlSingleLine.h"
 #include "core/rendering/RenderTheme.h"
 #include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
-TextFieldInputType::TextFieldInputType(HTMLInputElement* element)
+TextFieldInputType::TextFieldInputType(HTMLInputElement& element)
     : InputType(element)
 {
 }
 
 TextFieldInputType::~TextFieldInputType()
 {
     if (SpinButtonElement* spinButton = spinButtonElement())
         spinButton->removeSpinButtonOwner();
 }
 
 SpinButtonElement* TextFieldInputType::spinButtonElement() const
 {
-    return toSpinButtonElement(element()->userAgentShadowRoot()->getElementById(ShadowElementNames::spinButton()));
+    return toSpinButtonElement(element().userAgentShadowRoot()->getElementById(ShadowElementNames::spinButton()));
 }
 
 bool TextFieldInputType::shouldShowFocusRingOnMouseFocus() const
 {
     return true;
 }
 
 bool TextFieldInputType::isTextField() const
 {
     return true;
 }
 
 static inline bool shouldIgnoreRequiredAttribute(const HTMLInputElement& input)
 {
     if (!input.document().settings() || !input.document().settings()->needsSiteSpecificQuirks())
         return false;
     if (!equalIgnoringCase(input.document().url().host(), "egov.uscis.gov"))
         return false;
     return input.fastGetAttribute(requiredAttr) == "no";
 }
 
 bool TextFieldInputType::valueMissing(const String& value) const
 {
-    return !shouldIgnoreRequiredAttribute(*element()) && element()->isRequired() && value.isEmpty();
+    return !shouldIgnoreRequiredAttribute(element()) && element().isRequired() && value.isEmpty();
 }
 
 bool TextFieldInputType::canSetSuggestedValue()
 {
     return true;
 }
 
 void TextFieldInputType::setValue(const String& sanitizedValue, bool valueChanged, TextFieldEventBehavior eventBehavior)
 {
     // Grab this input element to keep reference even if JS event handler
@@ skipping 35 matching lines @@
     case DispatchNoEvent:
         break;
     }
 
     if (!input->focused())
         input->setTextAsOfLastFormControlChangeEvent(sanitizedValue);
 }
 
 void TextFieldInputType::handleKeydownEvent(KeyboardEvent* event)
 {
-    if (!element()->focused())
+    if (!element().focused())
         return;
-    Frame* frame = element()->document().frame();
-    if (!frame || !frame->editor().doTextFieldCommandFromEvent(element(), event))
+    Frame* frame = element().document().frame();
+    if (!frame || !frame->editor().doTextFieldCommandFromEvent(&element(), event))
         return;
     event->setDefaultHandled();
 }
 
 void TextFieldInputType::handleKeydownEventForSpinButton(KeyboardEvent* event)
 {
-    if (element()->isDisabledOrReadOnly())
+    if (element().isDisabledOrReadOnly())
         return;
     const String& key = event->keyIdentifier();
     if (key == "Up")
         spinButtonStepUp();
     else if (key == "Down")
         spinButtonStepDown();
     else
         return;
     event->setDefaultHandled();
 }
 
 void TextFieldInputType::forwardEvent(Event* event)
 {
     if (SpinButtonElement* spinButton = spinButtonElement()) {
         spinButton->forwardEvent(event);
         if (event->defaultHandled())
             return;
     }
 
-    if (element()->renderer() && (event->isMouseEvent() || event->isDragEvent() || event->hasInterface(EventNames::WheelEvent) || event->type() == EventTypeNames::blur || event->type() == EventTypeNames::focus)) {
-        RenderTextControlSingleLine* renderTextControl = toRenderTextControlSingleLine(element()->renderer());
+    if (element().renderer() && (event->isMouseEvent() || event->isDragEvent() || event->hasInterface(EventNames::WheelEvent) || event->type() == EventTypeNames::blur || event->type() == EventTypeNames::focus)) {
+        RenderTextControlSingleLine* renderTextControl = toRenderTextControlSingleLine(element().renderer());
         if (event->type() == EventTypeNames::blur) {
             if (RenderBox* innerTextRenderer = innerTextElement()->renderBox()) {
                 // FIXME: This class has no need to know about RenderLayer!
                 if (RenderLayer* innerLayer = innerTextRenderer->layer()) {
                     RenderLayerScrollableArea* innerScrollableArea = innerLayer->scrollableArea();
                     IntSize scrollOffset(!renderTextControl->style()->isLeftToRightDirection() ? innerScrollableArea->scrollWidth() : 0, 0);
                     innerScrollableArea->scrollToOffset(scrollOffset, ScrollOffsetClamped);
                 }
             }
 
             renderTextControl->capsLockStateMayHaveChanged();
         } else if (event->type() == EventTypeNames::focus) {
             renderTextControl->capsLockStateMayHaveChanged();
         }
 
-        element()->forwardEvent(event);
+        element().forwardEvent(event);
     }
 }
 
 void TextFieldInputType::handleFocusEvent(Element* oldFocusedNode, FocusDirection focusDirection)
 {
     InputType::handleFocusEvent(oldFocusedNode, focusDirection);
-    element()->beginEditing();
+    element().beginEditing();
 }
 
 void TextFieldInputType::handleBlurEvent()
 {
     InputType::handleBlurEvent();
-    element()->endEditing();
+    element().endEditing();
 }
 
 bool TextFieldInputType::shouldSubmitImplicitly(Event* event)
 {
     return (event->type() == EventTypeNames::textInput && event->hasInterface(EventNames::TextEvent) && toTextEvent(event)->data() == "\n") || InputType::shouldSubmitImplicitly(event);
 }
 
 RenderObject* TextFieldInputType::createRenderer(RenderStyle*) const
 {
-    return new RenderTextControlSingleLine(element());
+    return new RenderTextControlSingleLine(&element());
 }
 
 bool TextFieldInputType::needsContainer() const
 {
 #if ENABLE(INPUT_SPEECH)
-    return element()->isSpeechEnabled();
+    return element().isSpeechEnabled();
 #else
     return false;
 #endif
 }
 
 bool TextFieldInputType::shouldHaveSpinButton() const
 {
-    return RenderTheme::theme().shouldHaveSpinButton(element());
+    return RenderTheme::theme().shouldHaveSpinButton(&element());
 }
 
 void TextFieldInputType::createShadowSubtree()
 {
-    ASSERT(element()->shadow());
-    ShadowRoot* shadowRoot = element()->userAgentShadowRoot();
+    ASSERT(element().shadow());
+    ShadowRoot* shadowRoot = element().userAgentShadowRoot();
     ASSERT(!shadowRoot->hasChildNodes());
 
-    Document& document = element()->document();
+    Document& document = element().document();
     bool shouldHaveSpinButton = this->shouldHaveSpinButton();
     bool createsContainer = shouldHaveSpinButton || needsContainer();
 
     m_innerText = TextControlInnerTextElement::create(document);
     if (!createsContainer) {
         shadowRoot->appendChild(m_innerText);
         return;
     }
 
     RefPtr<TextControlInnerContainer> container = TextControlInnerContainer::create(document);
     container->setPart(AtomicString("-webkit-textfield-decoration-container", AtomicString::ConstructFromLiteral));
     shadowRoot->appendChild(container);
 
     RefPtr<EditingViewPortElement> editingViewPort = EditingViewPortElement::create(document);
     editingViewPort->appendChild(m_innerText);
     container->appendChild(editingViewPort.release());
 
 #if ENABLE(INPUT_SPEECH)
-    if (element()->isSpeechEnabled())
+    if (element().isSpeechEnabled())
         container->appendChild(InputFieldSpeechButtonElement::create(document));
 #endif
 
     if (shouldHaveSpinButton)
         container->appendChild(SpinButtonElement::create(document, *this));
 }
 
 Element* TextFieldInputType::containerElement() const
 {
-    return element()->userAgentShadowRoot()->getElementById(ShadowElementNames::textFieldContainer());
+    return element().userAgentShadowRoot()->getElementById(ShadowElementNames::textFieldContainer());
 }
 
 HTMLElement* TextFieldInputType::innerTextElement() const
 {
     ASSERT(m_innerText);
     return m_innerText.get();
 }
 
 void TextFieldInputType::destroyShadowSubtree()
 {
@@ skipping 61 matching lines @@
     return limitLength(proposedValue.removeCharacters(isASCIILineBreak), HTMLInputElement::maximumLength);
 }
 
 void TextFieldInputType::handleBeforeTextInsertedEvent(BeforeTextInsertedEvent* event)
 {
     // Make sure that the text to be inserted will not violate the maxLength.
 
     // We use HTMLInputElement::innerTextValue() instead of
     // HTMLInputElement::value() because they can be mismatched by
     // sanitizeValue() in HTMLInputElement::subtreeHasChanged() in some cases.
-    unsigned oldLength = element()->innerTextValue().length();
+    unsigned oldLength = element().innerTextValue().length();
 
     // selectionLength represents the selection length of this text field to be
     // removed by this insertion.
     // If the text field has no focus, we don't need to take account of the
     // selection length. The selection is the source of text drag-and-drop in
     // that case, and nothing in the text field will be removed.
-    unsigned selectionLength = element()->focused() ? plainText(element()->document().frame()->selection().selection().toNormalizedRange().get()).length() : 0;
+    unsigned selectionLength = element().focused() ? plainText(element().document().frame()->selection().selection().toNormalizedRange().get()).length() : 0;
     ASSERT(oldLength >= selectionLength);
 
     // Selected characters will be removed by the next text event.
     unsigned baseLength = oldLength - selectionLength;
-    unsigned maxLength = static_cast<unsigned>(isTextType() ? element()->maxLength() : HTMLInputElement::maximumLength); // maxLength can never be negative.
+    unsigned maxLength = static_cast<unsigned>(isTextType() ? element().maxLength() : HTMLInputElement::maximumLength); // maxLength can never be negative.
     unsigned appendableLength = maxLength > baseLength ? maxLength - baseLength : 0;
 
     // Truncate the inserted text to avoid violating the maxLength and other constraints.
     String eventText = event->text();
     unsigned textLength = eventText.length();
     while (textLength > 0 && isASCIILineBreak(eventText[textLength - 1]))
         textLength--;
     eventText.truncate(textLength);
     eventText.replace("\r\n", " ");
     eventText.replace('\r', ' ');
     eventText.replace('\n', ' ');
 
     event->setText(limitLength(eventText, appendableLength));
 }
 
 bool TextFieldInputType::shouldRespectListAttribute()
 {
     return InputType::themeSupportsDataListUI(this);
 }
 
 void TextFieldInputType::updatePlaceholderText()
 {
     if (!supportsPlaceholder())
         return;
-    HTMLElement* placeholder = element()->placeholderElement();
-    String placeholderText = element()->strippedPlaceholder();
+    HTMLElement* placeholder = element().placeholderElement();
+    String placeholderText = element().strippedPlaceholder();
     if (placeholderText.isEmpty()) {
         if (placeholder)
             placeholder->remove(ASSERT_NO_EXCEPTION);
         return;
     }
     if (!placeholder) {
-        RefPtr<HTMLElement> newElement = HTMLDivElement::create(element()->document());
+        RefPtr<HTMLElement> newElement = HTMLDivElement::create(element().document());
         placeholder = newElement.get();
         placeholder->setPart(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
         placeholder->setAttribute(idAttr, ShadowElementNames::placeholder());
         Element* container = containerElement();
         Node* previous = container ? container : innerTextElement();
         previous->parentNode()->insertBefore(placeholder, previous->nextSibling());
         ASSERT_WITH_SECURITY_IMPLICATION(placeholder->parentNode() == previous->parentNode());
     }
     placeholder->setTextContent(placeholderText, ASSERT_NO_EXCEPTION);
 }
 
 bool TextFieldInputType::appendFormData(FormDataList& list, bool multipart) const
 {
     InputType::appendFormData(list, multipart);
-    const AtomicString& dirnameAttrValue = element()->fastGetAttribute(dirnameAttr);
+    const AtomicString& dirnameAttrValue = element().fastGetAttribute(dirnameAttr);
     if (!dirnameAttrValue.isNull())
-        list.appendData(dirnameAttrValue, element()->directionForFormData());
+        list.appendData(dirnameAttrValue, element().directionForFormData());
     return true;
 }
 
 String TextFieldInputType::convertFromVisibleValue(const String& visibleValue) const
 {
     return visibleValue;
 }
 
 void TextFieldInputType::subtreeHasChanged()
 {
-    ASSERT(element()->renderer());
+    ASSERT(element().renderer());
 
-    bool wasChanged = element()->wasChangedSinceLastFormControlChangeEvent();
-    element()->setChangedSinceLastFormControlChangeEvent(true);
+    bool wasChanged = element().wasChangedSinceLastFormControlChangeEvent();
+    element().setChangedSinceLastFormControlChangeEvent(true);
 
     // We don't need to call sanitizeUserInputValue() function here because
     // HTMLInputElement::handleBeforeTextInsertedEvent() has already called
     // sanitizeUserInputValue().
     // sanitizeValue() is needed because IME input doesn't dispatch BeforeTextInsertedEvent.
-    element()->setValueFromRenderer(sanitizeValue(convertFromVisibleValue(element()->innerTextValue())));
-    element()->updatePlaceholderVisibility(false);
+    element().setValueFromRenderer(sanitizeValue(convertFromVisibleValue(element().innerTextValue())));
+    element().updatePlaceholderVisibility(false);
     // Recalc for :invalid change.
-    element()->setNeedsStyleRecalc();
+    element().setNeedsStyleRecalc();
 
     didSetValueByUserEdit(wasChanged ? ValueChangeStateChanged : ValueChangeStateNone);
 }
 
 void TextFieldInputType::didSetValueByUserEdit(ValueChangeState state)
 {
-    if (!element()->focused())
+    if (!element().focused())
         return;
-    if (Frame* frame = element()->document().frame())
-        frame->editor().textDidChangeInTextField(element());
+    if (Frame* frame = element().document().frame())
+        frame->editor().textDidChangeInTextField(&element());
 }
 
 void TextFieldInputType::spinButtonStepDown()
 {
     stepUpFromRenderer(-1);
 }
 
 void TextFieldInputType::spinButtonStepUp()
 {
     stepUpFromRenderer(1);
 }
 
 void TextFieldInputType::updateInnerTextValue()
 {
-    if (!element()->suggestedValue().isNull()) {
-        element()->setInnerTextValue(element()->suggestedValue());
-        element()->updatePlaceholderVisibility(false);
-    } else if (!element()->formControlValueMatchesRenderer()) {
+    if (!element().suggestedValue().isNull()) {
+        element().setInnerTextValue(element().suggestedValue());
+        element().updatePlaceholderVisibility(false);
+    } else if (!element().formControlValueMatchesRenderer()) {
         // Update the renderer value if the formControlValueMatchesRenderer() flag is false.
         // It protects an unacceptable renderer value from being overwritten with the DOM value.
-        element()->setInnerTextValue(visibleValue());
-        element()->updatePlaceholderVisibility(false);
+        element().setInnerTextValue(visibleValue());
+        element().updatePlaceholderVisibility(false);
     }
 }
 
 void TextFieldInputType::focusAndSelectSpinButtonOwner()
 {
     RefPtr<HTMLInputElement> input(element());
     input->focus();
     input->select();
 }
 
 bool TextFieldInputType::shouldSpinButtonRespondToMouseEvents()
 {
-    return !element()->isDisabledOrReadOnly();
+    return !element().isDisabledOrReadOnly();
 }
 
 bool TextFieldInputType::shouldSpinButtonRespondToWheelEvents()
 {
-    return shouldSpinButtonRespondToMouseEvents() && element()->focused();
+    return shouldSpinButtonRespondToMouseEvents() && element().focused();
 }
 
 } // namespace WebCore