Have InputType factories take an HTMLInputElement reference in parameter

Source/core/html/forms/InputType.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) 2009, 2010, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2012 Samsung Electronics. All rights reserved.
  *
@@ skipping 56 matching lines @@
 #include "core/rendering/RenderTheme.h"
 #include "platform/text/PlatformLocale.h"
 #include "platform/text/TextBreakIterator.h"
 
 namespace WebCore {
 
 using WebKit::WebLocalizedString;
 using namespace HTMLNames;
 using namespace std;
 
-typedef PassRefPtr<InputType> (*InputTypeFactoryFunction)(HTMLInputElement*);
+typedef PassRefPtr<InputType> (*InputTypeFactoryFunction)(HTMLInputElement&);
 typedef HashMap<AtomicString, InputTypeFactoryFunction, CaseFoldingHash> InputTypeFactoryMap;
 
 static PassOwnPtr<InputTypeFactoryMap> createInputTypeFactoryMap()
 {
     OwnPtr<InputTypeFactoryMap> map = adoptPtr(new InputTypeFactoryMap);
     map->add(InputTypeNames::button(), ButtonInputType::create);
     map->add(InputTypeNames::checkbox(), CheckboxInputType::create);
     if (RuntimeEnabledFeatures::inputTypeColorEnabled())
         map->add(InputTypeNames::color(), ColorInputType::create);
     map->add(InputTypeNames::date(), DateInputType::create);
@@ skipping 18 matching lines @@
     // No need to register "text" because it is the default type.
     return map.release();
 }
 
 static const InputTypeFactoryMap* factoryMap()
 {
     static const InputTypeFactoryMap* factoryMap = createInputTypeFactoryMap().leakPtr();
     return factoryMap;
 }
 
-PassRefPtr<InputType> InputType::create(HTMLInputElement* element, const AtomicString& typeName)
+PassRefPtr<InputType> InputType::create(HTMLInputElement& element, const AtomicString& typeName)
 {
     InputTypeFactoryFunction factory = typeName.isEmpty() ? 0 : factoryMap()->get(typeName);
     if (!factory)
         factory = TextInputType::create;
     return factory(element);
 }
 
-PassRefPtr<InputType> InputType::createText(HTMLInputElement* element)
+PassRefPtr<InputType> InputType::createText(HTMLInputElement& element)
 {
     return TextInputType::create(element);
 }
 
 const AtomicString& InputType::normalizeTypeName(const AtomicString& typeName)
 {
     if (typeName.isEmpty())
         return InputTypeNames::text();
     InputTypeFactoryMap::const_iterator it = factoryMap()->find(typeName);
     return it == factoryMap()->end() ? InputTypeNames::text() : it->key;
@@ skipping 33 matching lines @@
     return false;
 }
 
 bool InputType::shouldSaveAndRestoreFormControlState() const
 {
     return true;
 }
 
 FormControlState InputType::saveFormControlState() const
 {
-    String currentValue = element()->value();
-    if (currentValue == element()->defaultValue())
+    String currentValue = element().value();
+    if (currentValue == element().defaultValue())
         return FormControlState();
     return FormControlState(currentValue);
 }
 
 void InputType::restoreFormControlState(const FormControlState& state)
 {
-    element()->setValue(state[0]);
+    element().setValue(state[0]);
 }
 
 bool InputType::isFormDataAppendable() const
 {
     // There is no form data unless there's a name for non-image types.
-    return !element()->name().isEmpty();
+    return !element().name().isEmpty();
 }
 
 bool InputType::appendFormData(FormDataList& encoding, bool) const
 {
     // Always successful.
-    encoding.appendData(element()->name(), element()->value());
+    encoding.appendData(element().name(), element().value());
     return true;
 }
 
 double InputType::valueAsDate() const
 {
     return DateComponents::invalidMilliseconds();
 }
 
 void InputType::setValueAsDate(double, ExceptionState& es) const
 {
@@ skipping 151 matching lines @@
     return locale().queryString(WebLocalizedString::ValidationTypeMismatch);
 }
 
 String InputType::valueMissingText() const
 {
     return locale().queryString(WebLocalizedString::ValidationValueMissing);
 }
 
 String InputType::validationMessage() const
 {
-    const String value = element()->value();
+    const String value = element().value();
 
     // The order of the following checks is meaningful. e.g. We'd like to show the
     // badInput message even if the control has other validation errors.
     if (hasBadInput())
         return badInputText();
 
     if (valueMissing(value))
         return valueMissingText();
 
     if (typeMismatch())
         return typeMismatchText();
 
     if (patternMismatch(value))
         return locale().queryString(WebLocalizedString::ValidationPatternMismatch);
 
-    if (element()->tooLong())
-        return locale().validationMessageTooLongText(value.length(), element()->maxLength());
+    if (element().tooLong())
+        return locale().validationMessageTooLongText(value.length(), element().maxLength());
 
     if (!isSteppable())
         return emptyString();
 
     const Decimal numericValue = parseToNumberOrNaN(value);
     if (!numericValue.isFinite())
         return emptyString();
 
     StepRange stepRange(createStepRange(RejectAny));
 
@@ skipping 23 matching lines @@
 {
     return event->isKeyboardEvent() && event->type() == EventTypeNames::keypress && toKeyboardEvent(event)->charCode() == '\r';
 }
 
 void InputType::createShadowSubtree()
 {
 }
 
 void InputType::destroyShadowSubtree()
 {
-    if (ShadowRoot* root = element()->userAgentShadowRoot())
+    if (ShadowRoot* root = element().userAgentShadowRoot())
         root->removeChildren();
 }
 
 Decimal InputType::parseToNumber(const String&, const Decimal& defaultValue) const
 {
     ASSERT_NOT_REACHED();
     return defaultValue;
 }
 
 Decimal InputType::parseToNumberOrNaN(const String& string) const
 {
     return parseToNumber(string, Decimal::nan());
 }
 
 bool InputType::parseToDateComponents(const String&, DateComponents*) const
 {
     ASSERT_NOT_REACHED();
     return false;
 }
 
 String InputType::serialize(const Decimal&) const
 {
     ASSERT_NOT_REACHED();
     return String();
 }
 
 void InputType::dispatchSimulatedClickIfActive(KeyboardEvent* event) const
 {
-    if (element()->active())
-        element()->dispatchSimulatedClick(event);
+    if (element().active())
+        element().dispatchSimulatedClick(event);
     event->setDefaultHandled();
 }
 
 Chrome* InputType::chrome() const
 {
-    if (Page* page = element()->document().page())
+    if (Page* page = element().document().page())
         return &page->chrome();
     return 0;
 }
 
 Locale& InputType::locale() const
 {
-    return element()->locale();
+    return element().locale();
 }
 
 bool InputType::canSetStringValue() const
 {
     return true;
 }
 
 bool InputType::hasCustomFocusLogic() const
 {
     return true;
 }
 
 bool InputType::isKeyboardFocusable() const
 {
-    return element()->isFocusable();
+    return element().isFocusable();
 }
 
 bool InputType::shouldShowFocusRingOnMouseFocus() const
 {
     return false;
 }
 
 bool InputType::shouldUseInputMethod() const
 {
     return false;
 }
 
 void InputType::enableSecureTextInput()
 {
 }
 
 void InputType::disableSecureTextInput()
 {
 }
 
 void InputType::accessKeyAction(bool)
 {
-    element()->focus(false);
+    element().focus(false);
 }
 
 void InputType::detach()
 {
 }
 
 void InputType::countUsage()
 {
 }
 
@@ skipping 50 matching lines @@
     return true;
 }
 
 bool InputType::storesValueSeparateFromAttribute()
 {
     return true;
 }
 
 void InputType::setValue(const String& sanitizedValue, bool valueChanged, TextFieldEventBehavior eventBehavior)
 {
-    element()->setValueInternal(sanitizedValue, eventBehavior);
-    element()->setNeedsStyleRecalc();
+    element().setValueInternal(sanitizedValue, eventBehavior);
+    element().setNeedsStyleRecalc();
     if (!valueChanged)
         return;
     switch (eventBehavior) {
     case DispatchChangeEvent:
-        element()->dispatchFormControlChangeEvent();
+        element().dispatchFormControlChangeEvent();
         break;
     case DispatchInputAndChangeEvent:
-        element()->dispatchFormControlInputEvent();
-        element()->dispatchFormControlChangeEvent();
+        element().dispatchFormControlInputEvent();
+        element().dispatchFormControlChangeEvent();
         break;
     case DispatchNoEvent:
         break;
     }
 }
 
 bool InputType::canSetValue(const String&)
 {
     return true;
 }
 
 String InputType::localizeValue(const String& proposedValue) const
 {
     return proposedValue;
 }
 
 String InputType::visibleValue() const
 {
-    return element()->value();
+    return element().value();
 }
 
 String InputType::sanitizeValue(const String& proposedValue) const
 {
     return proposedValue;
 }
 
 bool InputType::receiveDroppedFiles(const DragData*)
 {
     ASSERT_NOT_REACHED();
@@ skipping 196 matching lines @@
 }
 
 void InputType::applyStep(int count, AnyStepHandling anyStepHandling, TextFieldEventBehavior eventBehavior, ExceptionState& es)
 {
     StepRange stepRange(createStepRange(anyStepHandling));
     if (!stepRange.hasStep()) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         return;
     }
 
-    const Decimal current = parseToNumberOrNaN(element()->value());
+    const Decimal current = parseToNumberOrNaN(element().value());
     if (!current.isFinite()) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         return;
     }
     Decimal newValue = current + stepRange.step() * count;
     if (!newValue.isFinite()) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         return;
     }
 
     const Decimal acceptableErrorValue = stepRange.acceptableError();
     if (newValue - stepRange.minimum() < -acceptableErrorValue) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         return;
     }
     if (newValue < stepRange.minimum())
         newValue = stepRange.minimum();
 
-    const AtomicString& stepString = element()->fastGetAttribute(stepAttr);
+    const AtomicString& stepString = element().fastGetAttribute(stepAttr);
     if (!equalIgnoringCase(stepString, "any"))
         newValue = stepRange.alignValueForStep(current, newValue);
 
     if (newValue - stepRange.maximum() > acceptableErrorValue) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         return;
     }
     if (newValue > stepRange.maximum())
         newValue = stepRange.maximum();
 
     setValueAsDecimal(newValue, eventBehavior, es);
 
-    if (AXObjectCache* cache = element()->document().existingAXObjectCache())
-        cache->postNotification(element(), AXObjectCache::AXValueChanged, true);
+    if (AXObjectCache* cache = element().document().existingAXObjectCache())
+        cache->postNotification(&element(), AXObjectCache::AXValueChanged, true);
 }
 
 bool InputType::getAllowedValueStep(Decimal* step) const
 {
     StepRange stepRange(createStepRange(RejectAny));
     *step = stepRange.step();
     return stepRange.hasStep();
 }
 
 StepRange InputType::createStepRange(AnyStepHandling) const
@@ skipping 66 matching lines @@
     const Decimal step = stepRange.step();
 
     int sign;
     if (step > 0)
         sign = n;
     else if (step < 0)
         sign = -n;
     else
         sign = 0;
 
-    String currentStringValue = element()->value();
+    String currentStringValue = element().value();
     Decimal current = parseToNumberOrNaN(currentStringValue);
     if (!current.isFinite()) {
         current = defaultValueForStepUp();
         const Decimal nextDiff = step * n;
         if (current < stepRange.minimum() - nextDiff)
             current = stepRange.minimum() - nextDiff;
         if (current > stepRange.maximum() - nextDiff)
             current = stepRange.maximum() - nextDiff;
         setValueAsDecimal(current, DispatchNoEvent, IGNORE_EXCEPTION);
     }
     if ((sign > 0 && current < stepRange.minimum()) || (sign < 0 && current > stepRange.maximum())) {
         setValueAsDecimal(sign > 0 ? stepRange.minimum() : stepRange.maximum(), DispatchInputAndChangeEvent, IGNORE_EXCEPTION);
     } else {
-        if (stepMismatch(element()->value())) {
+        if (stepMismatch(element().value())) {
             ASSERT(!step.isZero());
             const Decimal base = stepRange.stepBase();
             Decimal newValue;
             if (sign < 0)
                 newValue = base + ((current - base) / step).floor() * step;
             else if (sign > 0)
                 newValue = base + ((current - base) / step).ceiling() * step;
             else
                 newValue = current;
 
             if (newValue < stepRange.minimum())
                 newValue = stepRange.minimum();
             if (newValue > stepRange.maximum())
                 newValue = stepRange.maximum();
 
             setValueAsDecimal(newValue, n == 1 || n == -1 ? DispatchInputAndChangeEvent : DispatchNoEvent, IGNORE_EXCEPTION);
             if (n > 1)
                 applyStep(n - 1, AnyIsDefaultStep, DispatchInputAndChangeEvent, IGNORE_EXCEPTION);
             else if (n < -1)
                 applyStep(n + 1, AnyIsDefaultStep, DispatchInputAndChangeEvent, IGNORE_EXCEPTION);
         } else {
             applyStep(n, AnyIsDefaultStep, DispatchInputAndChangeEvent, IGNORE_EXCEPTION);
         }
     }
 }
 
 void InputType::observeFeatureIfVisible(UseCounter::Feature feature) const
 {
-    if (RenderStyle* style = element()->renderStyle()) {
+    if (RenderStyle* style = element().renderStyle()) {
         if (style->visibility() != HIDDEN)
-            UseCounter::count(element()->document(), feature);
+            UseCounter::count(element().document(), feature);
     }
 }
 
 } // namespace WebCore