Rename renderer() to layoutObject().

Source/core/html/HTMLFormControlElement.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 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * 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
@@ skipping 141 matching lines @@
         bool oldDisabled = m_disabled;
         m_disabled = !value.isNull();
         if (oldDisabled != m_disabled)
             disabledAttributeChanged();
     } else if (name == readonlyAttr) {
         bool wasReadOnly = m_isReadOnly;
         m_isReadOnly = !value.isNull();
         if (wasReadOnly != m_isReadOnly) {
             setNeedsWillValidateCheck();
             setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::fromAttribute(name));
-            if (renderer() && renderer()->style()->hasAppearance())
-                LayoutTheme::theme().stateChanged(renderer(), ReadOnlyControlState);
+            if (layoutObject() && layoutObject()->style()->hasAppearance())
+                LayoutTheme::theme().stateChanged(layoutObject(), ReadOnlyControlState);
         }
     } else if (name == requiredAttr) {
         bool wasRequired = m_isRequired;
         m_isRequired = !value.isNull();
         if (wasRequired != m_isRequired)
             requiredAttributeChanged();
         UseCounter::count(document(), UseCounter::RequiredAttribute);
     } else if (name == autofocusAttr) {
         HTMLElement::parseAttribute(name, value);
         UseCounter::count(document(), UseCounter::AutoFocusAttribute);
     } else
         HTMLElement::parseAttribute(name, value);
 }
 
 void HTMLFormControlElement::disabledAttributeChanged()
 {
     setNeedsWillValidateCheck();
     pseudoStateChanged(CSSSelector::PseudoDisabled);
     pseudoStateChanged(CSSSelector::PseudoEnabled);
-    if (renderer() && renderer()->style()->hasAppearance())
-        LayoutTheme::theme().stateChanged(renderer(), EnabledControlState);
+    if (layoutObject() && layoutObject()->style()->hasAppearance())
+        LayoutTheme::theme().stateChanged(layoutObject(), EnabledControlState);
     if (isDisabledFormControl() && treeScope().adjustedFocusedElement() == this) {
         // We might want to call blur(), but it's dangerous to dispatch events
         // here.
         document().setNeedsFocusedElementCheck();
     }
 }
 
 void HTMLFormControlElement::requiredAttributeChanged()
 {
     setNeedsValidityCheck();
@@ skipping 30 matching lines @@
         return false;
     }
 
     return true;
 }
 
 void HTMLFormControlElement::attach(const AttachContext& context)
 {
     HTMLElement::attach(context);
 
-    if (!renderer())
+    if (!layoutObject())
         return;
 
     // The call to updateFromElement() needs to go after the call through
     // to the base class's attach() because that can sometimes do a close
     // on the renderer.
-    renderer()->updateFromElement();
+    layoutObject()->updateFromElement();
 
     // FIXME: Autofocus handling should be moved to insertedInto according to
     // the standard.
     if (shouldAutofocusOnAttach(this))
         document().setAutofocusElement(this);
 }
 
 void HTMLFormControlElement::didMoveToNewDocument(Document& oldDocument)
 {
     FormAssociatedElement::didMoveToNewDocument(oldDocument);
@@ skipping 101 matching lines @@
     return m_isRequired;
 }
 
 String HTMLFormControlElement::resultForDialogSubmit()
 {
     return fastGetAttribute(valueAttr);
 }
 
 void HTMLFormControlElement::didRecalcStyle(StyleRecalcChange)
 {
-    if (LayoutObject* renderer = this->renderer())
+    if (LayoutObject* renderer = this->layoutObject())
         renderer->updateFromElement();
 }
 
 bool HTMLFormControlElement::supportsFocus() const
 {
     return !isDisabledFormControl();
 }
 
 bool HTMLFormControlElement::isKeyboardFocusable() const
 {
@@ skipping 18 matching lines @@
     HTMLElement::dispatchFocusEvent(oldFocusedElement, type);
 }
 
 void HTMLFormControlElement::willCallDefaultEventHandler(const Event& event)
 {
     if (!m_wasFocusedByMouse)
         return;
     if (!event.isKeyboardEvent() || event.type() != EventTypeNames::keydown)
         return;
     m_wasFocusedByMouse = false;
-    if (renderer())
-        renderer()->setShouldDoFullPaintInvalidation();
+    if (layoutObject())
+        layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 short HTMLFormControlElement::tabIndex() const
 {
     // Skip the supportsFocus check in HTMLElement.
     return Element::tabIndex();
 }
 
 bool HTMLFormControlElement::recalcWillValidate() const
 {
@@ skipping 35 matching lines @@
     if (!m_willValidate)
         hideVisibleValidationMessage();
 }
 
 void HTMLFormControlElement::findCustomValidationMessageTextDirection(const String& message, TextDirection &messageDir, String& subMessage, TextDirection &subMessageDir)
 {
     bool hasStrongDirection;
     subMessage = fastGetAttribute(titleAttr);
     messageDir = determineDirectionality(message, hasStrongDirection);
     if (!subMessage.isEmpty())
-        subMessageDir = renderer()->style()->direction();
+        subMessageDir = layoutObject()->style()->direction();
 }
 
 void HTMLFormControlElement::updateVisibleValidationMessage()
 {
     Page* page = document().page();
     if (!page)
         return;
     String message;
-    if (renderer() && willValidate())
+    if (layoutObject() && willValidate())
         message = validationMessage().stripWhiteSpace();
 
     m_hasValidationMessage = true;
     ValidationMessageClient* client = &page->validationMessageClient();
     TextDirection messageDir = LTR;
     TextDirection subMessageDir = LTR;
     String subMessage = String();
     if (message.isEmpty())
         client->hideValidationMessage(*this);
     else
@@ skipping 56 matching lines @@
 
 bool HTMLFormControlElement::reportValidity()
 {
     WillBeHeapVector<RefPtrWillBeMember<HTMLFormControlElement> > unhandledInvalidControls;
     bool isValid = checkValidity(&unhandledInvalidControls, CheckValidityDispatchInvalidEvent);
     if (isValid || unhandledInvalidControls.isEmpty())
         return isValid;
     ASSERT(unhandledInvalidControls.size() == 1);
     ASSERT(unhandledInvalidControls[0].get() == this);
     // Update layout now before calling isFocusable(), which has
-    // !renderer()->needsLayout() assertion.
+    // !layoutObject()->needsLayout() assertion.
     document().updateLayoutIgnorePendingStylesheets();
     if (isFocusable()) {
         showValidationMessage();
         return false;
     }
     if (document().frame()) {
         String message("An invalid form control with name='%name' is not focusable.");
         message.replace("%name", name());
         document().addConsoleMessage(ConsoleMessage::create(RenderingMessageSource, ErrorMessageLevel, message));
     }
@@ skipping 84 matching lines @@
         dispatchFormControlChangeEvent();
 }
 
 void HTMLFormControlElement::copyNonAttributePropertiesFromElement(const Element& source)
 {
     HTMLElement::copyNonAttributePropertiesFromElement(source);
     setNeedsValidityCheck();
 }
 
 } // namespace blink