Have InputType factories take an HTMLInputElement reference in parameter

Source/core/html/forms/ColorInputType.cpp

 /*
  * Copyright (C) 2010 Google 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 49 matching lines @@
     if (value[0] != '#')
         return false;
 
     // We don't accept #rgb and #aarrggbb formats.
     if (value.length() != 7)
         return false;
     Color color(value);
     return color.isValid() && !color.hasAlpha();
 }
 
-PassRefPtr<InputType> ColorInputType::create(HTMLInputElement* element)
+PassRefPtr<InputType> ColorInputType::create(HTMLInputElement& element)
 {
     return adoptRef(new ColorInputType(element));
 }
 
 ColorInputType::~ColorInputType()
 {
     endColorChooser();
 }
 
 void ColorInputType::countUsage()
@@ skipping 24 matching lines @@
 String ColorInputType::sanitizeValue(const String& proposedValue) const
 {
     if (!isValidColorString(proposedValue))
         return fallbackValue();
 
     return proposedValue.lower();
 }
 
 Color ColorInputType::valueAsColor() const
 {
-    return Color(element()->value());
+    return Color(element().value());
 }
 
 void ColorInputType::createShadowSubtree()
 {
-    ASSERT(element()->shadow());
+    ASSERT(element().shadow());
 
-    Document& document = element()->document();
+    Document& document = element().document();
     RefPtr<HTMLDivElement> wrapperElement = HTMLDivElement::create(document);
     wrapperElement->setPart(AtomicString("-webkit-color-swatch-wrapper", AtomicString::ConstructFromLiteral));
     RefPtr<HTMLDivElement> colorSwatch = HTMLDivElement::create(document);
     colorSwatch->setPart(AtomicString("-webkit-color-swatch", AtomicString::ConstructFromLiteral));
     wrapperElement->appendChild(colorSwatch.release());
-    element()->userAgentShadowRoot()->appendChild(wrapperElement.release());
+    element().userAgentShadowRoot()->appendChild(wrapperElement.release());
 
     updateColorSwatch();
 }
 
 void ColorInputType::setValue(const String& value, bool valueChanged, TextFieldEventBehavior eventBehavior)
 {
     InputType::setValue(value, valueChanged, eventBehavior);
 
     if (!valueChanged)
         return;
 
     updateColorSwatch();
     if (m_chooser)
         m_chooser->setSelectedColor(valueAsColor());
 }
 
 void ColorInputType::handleDOMActivateEvent(Event* event)
 {
-    if (element()->isDisabledFormControl() || !element()->renderer())
+    if (element().isDisabledFormControl() || !element().renderer())
         return;
 
     if (!UserGestureIndicator::processingUserGesture())
         return;
 
     Chrome* chrome = this->chrome();
     if (chrome && !m_chooser)
         m_chooser = chrome->createColorChooser(this, valueAsColor());
 
     event->setDefaultHandled();
 }
 
 void ColorInputType::detach()
 {
     endColorChooser();
 }
 
 bool ColorInputType::shouldRespectListAttribute()
 {
     return InputType::themeSupportsDataListUI(this);
 }
 
 bool ColorInputType::typeMismatchFor(const String& value) const
 {
     return !isValidColorString(value);
 }
 
 void ColorInputType::didChooseColor(const Color& color)
 {
-    if (element()->isDisabledFormControl() || color == valueAsColor())
+    if (element().isDisabledFormControl() || color == valueAsColor())
         return;
-    element()->setValueFromRenderer(color.serialized());
+    element().setValueFromRenderer(color.serialized());
     updateColorSwatch();
-    element()->dispatchFormControlChangeEvent();
+    element().dispatchFormControlChangeEvent();
 }
 
 void ColorInputType::didEndChooser()
 {
     m_chooser.clear();
 }
 
 void ColorInputType::endColorChooser()
 {
     if (m_chooser)
         m_chooser->endChooser();
 }
 
 void ColorInputType::updateColorSwatch()
 {
     HTMLElement* colorSwatch = shadowColorSwatch();
     if (!colorSwatch)
         return;
 
-    colorSwatch->setInlineStyleProperty(CSSPropertyBackgroundColor, element()->value());
+    colorSwatch->setInlineStyleProperty(CSSPropertyBackgroundColor, element().value());
 }
 
 HTMLElement* ColorInputType::shadowColorSwatch() const
 {
-    ShadowRoot* shadow = element()->userAgentShadowRoot();
+    ShadowRoot* shadow = element().userAgentShadowRoot();
     return shadow ? toHTMLElement(shadow->firstChild()->firstChild()) : 0;
 }
 
 IntRect ColorInputType::elementRectRelativeToRootView() const
 {
-    return element()->document().view()->contentsToRootView(element()->pixelSnappedBoundingBox());
+    return element().document().view()->contentsToRootView(element().pixelSnappedBoundingBox());
 }
 
 Color ColorInputType::currentColor()
 {
     return valueAsColor();
 }
 
 bool ColorInputType::shouldShowSuggestions() const
 {
     if (RuntimeEnabledFeatures::dataListElementEnabled())
-        return element()->fastHasAttribute(listAttr);
+        return element().fastHasAttribute(listAttr);
 
     return false;
 }
 
 Vector<Color> ColorInputType::suggestions() const
 {
     Vector<Color> suggestions;
     if (RuntimeEnabledFeatures::dataListElementEnabled()) {
-        HTMLDataListElement* dataList = element()->dataList();
+        HTMLDataListElement* dataList = element().dataList();
         if (dataList) {
             RefPtr<HTMLCollection> options = dataList->options();
             for (unsigned i = 0; HTMLOptionElement* option = toHTMLOptionElement(options->item(i)); i++) {
-                if (!element()->isValidValue(option->value()))
+                if (!element().isValidValue(option->value()))
                     continue;
                 Color color(option->value());
                 if (!color.isValid())
                     continue;
                 suggestions.append(color);
             }
         }
     }
     return suggestions;
 }
 
 } // namespace WebCore