Remove a part of type checking predicates of HTMLInputElement.

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 17 matching lines @@
 
 #include "config.h"
 #include "core/html/HTMLInputElement.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "bindings/core/v8/V8DOMActivityLogger.h"
 #include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
+#include "core/InputTypeNames.h"
 #include "core/accessibility/AXObjectCache.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/IdTargetObserver.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/InsertionPoint.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/SpellChecker.h"
 #include "core/events/BeforeTextInsertedEvent.h"
@@ skipping 119 matching lines @@
 }
 
 HTMLInputElement::~HTMLInputElement()
 {
 #if !ENABLE(OILPAN)
     // 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())
+    if (type() == InputTypeNames::radio)
         document().formController().radioButtonGroupScope().removeButton(this);
     if (m_hasTouchEventHandler && document().frameHost())
         document().frameHost()->eventHandlerRegistry().didRemoveEventHandler(*this, EventHandlerRegistry::TouchEvent);
 #endif
 }
 
 const AtomicString& HTMLInputElement::name() const
 {
     return m_name.isNull() ? emptyAtom : m_name;
 }
@@ skipping 398 matching lines @@
     HTMLTextFormControlElement::setSelectionRange(start, end, direction);
 }
 
 void HTMLInputElement::accessKeyAction(bool sendMouseEvents)
 {
     m_inputType->accessKeyAction(sendMouseEvents);
 }
 
 bool HTMLInputElement::isPresentationAttribute(const QualifiedName& name) const
 {
-    if (name == vspaceAttr || name == hspaceAttr || name == alignAttr || name == widthAttr || name == heightAttr || (name == borderAttr && isImageButton()))
+    // FIXME: Remove type check.
+    if (name == vspaceAttr || name == hspaceAttr || name == alignAttr || name == widthAttr || name == heightAttr || (name == borderAttr && type() == InputTypeNames::image))
         return true;
     return HTMLTextFormControlElement::isPresentationAttribute(name);
 }
 
 void HTMLInputElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
 {
     if (name == vspaceAttr) {
         addHTMLLengthToStyle(style, CSSPropertyMarginTop, value);
         addHTMLLengthToStyle(style, CSSPropertyMarginBottom, value);
     } else if (name == hspaceAttr) {
         addHTMLLengthToStyle(style, CSSPropertyMarginLeft, value);
         addHTMLLengthToStyle(style, CSSPropertyMarginRight, value);
     } else if (name == alignAttr) {
         if (m_inputType->shouldRespectAlignAttribute())
             applyAlignmentAttributeToStyle(value, style);
     } else if (name == widthAttr) {
         if (m_inputType->shouldRespectHeightAndWidthAttributes())
             addHTMLLengthToStyle(style, CSSPropertyWidth, value);
     } else if (name == heightAttr) {
         if (m_inputType->shouldRespectHeightAndWidthAttributes())
             addHTMLLengthToStyle(style, CSSPropertyHeight, value);
-    } else if (name == borderAttr && isImageButton())
+    } else if (name == borderAttr && type() == InputTypeNames::image) // FIXME: Remove type check.
         applyBorderAttributeToStyle(value, style);
     else
         HTMLTextFormControlElement::collectStyleForPresentationAttribute(name, value, style);
 }
 
 void HTMLInputElement::attributeWillChange(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue)
 {
     if (name == formactionAttr && inDocument()) {
         V8DOMActivityLogger* activityLogger = V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
         if (activityLogger) {
@@ skipping 361 matching lines @@
 }
 
 void HTMLInputElement::setInnerEditorValue(const String& value)
 {
     HTMLTextFormControlElement::setInnerEditorValue(value);
     m_needsToUpdateViewValue = false;
 }
 
 void HTMLInputElement::setValue(const String& value, ExceptionState& exceptionState, TextFieldEventBehavior eventBehavior)
 {
-    if (isFileUpload() && !value.isEmpty()) {
+    // FIXME: Remove type check.
+    if (type() == InputTypeNames::file && !value.isEmpty()) {
         exceptionState.throwDOMException(InvalidStateError, "This input element accepts a filename, which may only be programmatically set to the empty string.");
         return;
     }
     setValue(value, eventBehavior);
 }
 
 void HTMLInputElement::setValue(const String& value, TextFieldEventBehavior eventBehavior)
 {
     m_inputType->warnIfValueIsInvalidAndElementIsVisible(value);
     if (!m_inputType->canSetValue(value))
@@ skipping 56 matching lines @@
     if (std::isinf(newValue)) {
         exceptionState.throwTypeError(ExceptionMessages::notAFiniteNumber(newValue));
         return;
     }
     m_inputType->setValueAsDouble(newValue, eventBehavior, exceptionState);
 }
 
 void HTMLInputElement::setValueFromRenderer(const String& value)
 {
     // File upload controls will never use this.
-    ASSERT(!isFileUpload());
+    ASSERT(type() != InputTypeNames::file);
 
     m_suggestedValue = String();
 
     // Renderer and our event handler are responsible for sanitizing values.
     ASSERT(value == sanitizeValue(value) || sanitizeValue(value).isEmpty());
 
     m_valueIfDirty = value;
     m_needsToUpdateViewValue = false;
 
     // Input event is fired by the Node::defaultEventHandler for editable controls.
@@ skipping 80 matching lines @@
             return;
     }
 
     if (evt->isKeyboardEvent() && evt->type() == EventTypeNames::keyup) {
         m_inputTypeView->handleKeyupEvent(toKeyboardEvent(evt));
         if (evt->defaultHandled())
             return;
     }
 
     if (m_inputTypeView->shouldSubmitImplicitly(evt)) {
-        if (isSearchField())
+        // FIXME: Remove type check.
+        if (type() == InputTypeNames::search)
             onSearch();
         // Form submission finishes editing, just as loss of focus does.
         // If there was a change, send the event now.
         if (wasChangedSinceLastFormControlChangeEvent())
             dispatchFormControlChangeEvent();
 
         RefPtrWillBeRawPtr<HTMLFormElement> formForSubmission = m_inputTypeView->formForSubmission();
         // Form may never have been present, or may have been destroyed by code responding to the change event.
         if (formForSubmission)
             formForSubmission->submitImplicitly(evt, canTriggerImplicitSubmission());
@@ skipping 209 matching lines @@
     return m_inputType->supportsReadOnly() && isReadOnly();
 }
 
 bool HTMLInputElement::matchesReadWritePseudoClass() const
 {
     return m_inputType->supportsReadOnly() && !isReadOnly();
 }
 
 void HTMLInputElement::onSearch()
 {
-    ASSERT(isSearchField());
+    // FIXME: Remove type check, and static_cast.
+    ASSERT(type() == InputTypeNames::search);
     if (m_inputType)
         static_cast<SearchInputType*>(m_inputType.get())->stopSearchEventTimer();
     dispatchEvent(Event::createBubble(EventTypeNames::search));
 }
 
 void HTMLInputElement::updateClearButtonVisibility()
 {
     m_inputTypeView->updateClearButtonVisibility();
 }
 
@@ skipping 35 matching lines @@
     HTMLTextFormControlElement::removedFrom(insertionPoint);
     ASSERT(!inDocument());
     resetListAttributeTargetObserver();
 }
 
 void HTMLInputElement::didMoveToNewDocument(Document& oldDocument)
 {
     if (hasImageLoader())
         imageLoader()->elementDidMoveToNewDocument();
 
-    if (isRadioButton())
+    // FIXME: Remove type check.
+    if (type() == InputTypeNames::radio)
         oldDocument.formController().radioButtonGroupScope().removeButton(this);
 
     HTMLTextFormControlElement::didMoveToNewDocument(oldDocument);
 }
 
 void HTMLInputElement::removeAllEventListeners()
 {
     HTMLTextFormControlElement::removeAllEventListeners();
     m_hasTouchEventHandler = false;
 }
 
 bool HTMLInputElement::recalcWillValidate() const
 {
     return m_inputType->supportsValidation() && HTMLTextFormControlElement::recalcWillValidate();
 }
 
 void HTMLInputElement::requiredAttributeChanged()
 {
     HTMLTextFormControlElement::requiredAttributeChanged();
     if (RadioButtonGroupScope* scope = radioButtonGroupScope())
         scope->requiredAttributeChanged(this);
     m_inputTypeView->requiredAttributeChanged();
 }
 
 void HTMLInputElement::selectColorInColorChooser(const Color& color)
 {
-    if (!m_inputType->isColorControl())
+    // FIXME: Remove type check and static_cast.
+    if (type() != InputTypeNames::color)
         return;
     static_cast<ColorInputType*>(m_inputType.get())->didChooseColor(color);
 }
 
 HTMLElement* HTMLInputElement::list() const
 {
     return dataList();
 }
 
 HTMLDataListElement* HTMLInputElement::dataList() const
@@ skipping 49 matching lines @@
 bool HTMLInputElement::isSteppable() const
 {
     return m_inputType->isSteppable();
 }
 
 bool HTMLInputElement::isTextButton() const
 {
     return m_inputType->isTextButton();
 }
 
-bool HTMLInputElement::isRadioButton() const
-{
-    return m_inputType->isRadioButton();
-}
-
-bool HTMLInputElement::isSearchField() const
-{
-    return m_inputType->isSearchField();
-}
-
-bool HTMLInputElement::isInputTypeHidden() const
-{
-    return m_inputType->isHiddenType();
-}
-
-bool HTMLInputElement::isPasswordField() const
-{
-    return m_inputType->isPasswordField();
-}
-
-bool HTMLInputElement::isCheckbox() const
-{
-    return m_inputType->isCheckbox();
-}
-
-bool HTMLInputElement::isRangeControl() const
-{
-    return m_inputType->isRangeControl();
-}
-
 bool HTMLInputElement::isText() const
 {
     return m_inputType->isTextType();
 }
 
-bool HTMLInputElement::isEmailField() const
-{
-    return m_inputType->isEmailField();
-}
-
-bool HTMLInputElement::isFileUpload() const
-{
-    return m_inputType->isFileUpload();
-}
-
-bool HTMLInputElement::isImageButton() const
-{
-    return m_inputType->isImageButton();
-}
-
-bool HTMLInputElement::isNumberField() const
-{
-    return m_inputType->isNumberField();
-}
-
-bool HTMLInputElement::isTelephoneField() const
-{
-    return m_inputType->isTelephoneField();
-}
-
-bool HTMLInputElement::isURLField() const
-{
-    return m_inputType->isURLField();
-}
-
-bool HTMLInputElement::isDateField() const
-{
-    return m_inputType->isDateField();
-}
-
-bool HTMLInputElement::isDateTimeLocalField() const
-{
-    return m_inputType->isDateTimeLocalField();
-}
-
-bool HTMLInputElement::isMonthField() const
-{
-    return m_inputType->isMonthField();
-}
-
-bool HTMLInputElement::isTimeField() const
-{
-    return m_inputType->isTimeField();
-}
-
-bool HTMLInputElement::isWeekField() const
-{
-    return m_inputType->isWeekField();
-}
-
 bool HTMLInputElement::isEnumeratable() const
 {
     return m_inputType->isEnumeratable();
 }
 
 bool HTMLInputElement::supportLabels() const
 {
     return m_inputType->isInteractiveContent();
 }
 
@@ skipping 40 matching lines @@
     return m_inputType->defaultToolTip();
 }
 
 bool HTMLInputElement::shouldAppearIndeterminate() const
 {
     return m_inputType->shouldAppearIndeterminate();
 }
 
 bool HTMLInputElement::isInRequiredRadioButtonGroup()
 {
-    ASSERT(isRadioButton());
+    // FIXME: Remove type check.
+    ASSERT(type() == InputTypeNames::radio);
     if (RadioButtonGroupScope* scope = radioButtonGroupScope())
         return scope->isInRequiredGroup(this);
     return false;
 }
 
 HTMLInputElement* HTMLInputElement::checkedRadioButtonForGroup()
 {
     if (checked())
         return this;
     if (RadioButtonGroupScope* scope = radioButtonGroupScope())
         return scope->checkedButtonForGroup(name());
     return 0;
 }
 
 RadioButtonGroupScope* HTMLInputElement::radioButtonGroupScope() const
 {
-    if (!isRadioButton())
+    // FIXME: Remove type check.
+    if (type() != InputTypeNames::radio)
         return 0;
     if (HTMLFormElement* formElement = form())
         return &formElement->radioButtonGroupScope();
     if (inDocument())
         return &document().formController().radioButtonGroupScope();
     return 0;
 }
 
 inline void HTMLInputElement::addToRadioButtonGroup()
 {
@@ skipping 154 matching lines @@
 {
     listAttributeTargetChanged();
 }
 
 AXObject* HTMLInputElement::popupRootAXObject()
 {
     return m_inputTypeView->popupRootAXObject();
 }
 
 } // namespace