Have InputType factories take an HTMLInputElement reference in parameter

Source/core/html/forms/EmailInputType.cpp

 /*
  * This file is part of the WebKit project.
  *
  * Copyright (C) 2009 Michelangelo De Simone <micdesim@gmail.com>
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 115 matching lines @@
         return false;
 
     DEFINE_STATIC_LOCAL(const RegularExpression, regExp, (emailPattern, TextCaseInsensitive));
 
     int matchLength;
     int matchOffset = regExp.match(address, 0, &matchLength);
 
     return !matchOffset && matchLength == addressLength;
 }
 
-PassRefPtr<InputType> EmailInputType::create(HTMLInputElement* element)
+PassRefPtr<InputType> EmailInputType::create(HTMLInputElement& element)
 {
     return adoptRef(new EmailInputType(element));
 }
 
 void EmailInputType::countUsage()
 {
     observeFeatureIfVisible(UseCounter::InputTypeEmail);
 }
 
 const AtomicString& EmailInputType::formControlType() const
 {
     return InputTypeNames::email();
 }
 
 // The return value is an invalid email address string if the specified string
 // contains an invalid email address. Otherwise, null string is returned.
 // If an empty string is returned, it means empty address is specified.
 // e.g. "foo@example.com,,bar@example.com" for multiple case.
 String EmailInputType::findInvalidAddress(const String& value) const
 {
     if (value.isEmpty())
         return String();
-    if (!element()->multiple())
+    if (!element().multiple())
         return isValidEmailAddress(value) ? String() : value;
     Vector<String> addresses;
     value.split(',', true, addresses);
     for (unsigned i = 0; i < addresses.size(); ++i) {
         String stripped = stripLeadingAndTrailingHTMLSpaces(addresses[i]);
         if (!isValidEmailAddress(stripped))
             return stripped;
     }
     return String();
 }
 
 bool EmailInputType::typeMismatchFor(const String& value) const
 {
     return !findInvalidAddress(value).isNull();
 }
 
 bool EmailInputType::typeMismatch() const
 {
-    return typeMismatchFor(element()->value());
+    return typeMismatchFor(element().value());
 }
 
 String EmailInputType::typeMismatchText() const
 {
-    String invalidAddress = findInvalidAddress(element()->value());
+    String invalidAddress = findInvalidAddress(element().value());
     ASSERT(!invalidAddress.isNull());
     if (invalidAddress.isEmpty())
         return locale().queryString(WebLocalizedString::ValidationTypeMismatchForEmailEmpty);
     String atSign = String("@");
     size_t atIndex = invalidAddress.find('@');
     if (atIndex == kNotFound)
         return locale().queryString(WebLocalizedString::ValidationTypeMismatchForEmailNoAtSign, atSign, invalidAddress);
     // We check validity against an ASCII value because of difficulty to check
     // invalid characters. However we should show Unicode value.
     String unicodeAddress = convertEmailAddressToUnicode(invalidAddress);
@@ skipping 11 matching lines @@
     invalidCharIndex = domain.find(isInvalidDomainCharacter);
     if (invalidCharIndex != kNotFound) {
         unsigned charLength = U_IS_LEAD(domain[invalidCharIndex]) ? 2 : 1;
         return locale().queryString(WebLocalizedString::ValidationTypeMismatchForEmailInvalidDomain, atSign, domain.substring(invalidCharIndex, charLength));
     }
     if (!checkValidDotUsage(domain)) {
         size_t atIndexInUnicode = unicodeAddress.find('@');
         ASSERT(atIndexInUnicode != kNotFound);
         return locale().queryString(WebLocalizedString::ValidationTypeMismatchForEmailInvalidDots, String("."), unicodeAddress.substring(atIndexInUnicode + 1));
     }
-    if (element()->multiple())
+    if (element().multiple())
         return locale().queryString(WebLocalizedString::ValidationTypeMismatchForMultipleEmail);
     return locale().queryString(WebLocalizedString::ValidationTypeMismatchForEmail);
 }
 
 bool EmailInputType::isEmailField() const
 {
     return true;
 }
 
 bool EmailInputType::supportsSelectionAPI() const
 {
     return false;
 }
 
 String EmailInputType::sanitizeValue(const String& proposedValue) const
 {
     String noLineBreakValue = proposedValue.removeCharacters(isHTMLLineBreak);
-    if (!element()->multiple())
+    if (!element().multiple())
         return stripLeadingAndTrailingHTMLSpaces(noLineBreakValue);
     Vector<String> addresses;
     noLineBreakValue.split(',', true, addresses);
     StringBuilder strippedValue;
     for (size_t i = 0; i < addresses.size(); ++i) {
         if (i > 0)
             strippedValue.append(",");
         strippedValue.append(stripLeadingAndTrailingHTMLSpaces(addresses[i]));
     }
     return strippedValue.toString();
 }
 
 String EmailInputType::convertFromVisibleValue(const String& visibleValue) const
 {
     String sanitizedValue = sanitizeValue(visibleValue);
-    if (!element()->multiple())
+    if (!element().multiple())
         return convertEmailAddressToASCII(sanitizedValue);
     Vector<String> addresses;
     sanitizedValue.split(',', true, addresses);
     StringBuilder builder;
     builder.reserveCapacity(sanitizedValue.length());
     for (size_t i = 0; i < addresses.size(); ++i) {
         if (i > 0)
             builder.append(",");
         builder.append(convertEmailAddressToASCII(addresses[i]));
     }
     return builder.toString();
 }
 
 String EmailInputType::visibleValue() const
 {
-    String value = element()->value();
-    if (!element()->multiple())
+    String value = element().value();
+    if (!element().multiple())
         return convertEmailAddressToUnicode(value);
 
     Vector<String> addresses;
     value.split(',', true, addresses);
     StringBuilder builder;
     builder.reserveCapacity(value.length());
     for (size_t i = 0; i < addresses.size(); ++i) {
         if (i > 0)
             builder.append(",");
         builder.append(convertEmailAddressToUnicode(addresses[i]));
     }
     return builder.toString();
 }
 
 } // namespace WebCore