reflow comments in core/html/*.{cpp,h},core/html/imports

third_party/WebKit/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.
+ * 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) 2008 Torch Mobile Inc. All rights reserved.
+ * (http://www.torchmobile.com/)
  * Copyright (C) 2012 Samsung Electronics. 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ skipping 91 matching lines @@
       m_isIndeterminate(false),
       m_isActivatedSubmit(false),
       m_autocomplete(Uninitialized),
       m_hasNonEmptyList(false),
       m_stateRestored(false),
       m_parsingInProgress(createdByParser),
       m_valueAttributeWasUpdatedAfterParsing(false),
       m_canReceiveDroppedFiles(false),
       m_shouldRevealPassword(false),
       m_needsToUpdateViewValue(true),
-      m_isPlaceholderVisible(false)
+      m_isPlaceholderVisible(false),
       // |m_inputType| is lazily created when constructed by the parser to avoid
-      // constructing unnecessarily a text inputType and its shadow subtree, just
-      // to destroy them when the |type| attribute gets set by the parser to
-      // something else than 'text'.
-      ,
+      // constructing unnecessarily a text inputType and its shadow subtree,
+      // just to destroy them when the |type| attribute gets set by the parser
+      // to something else than 'text'.
       m_inputType(createdByParser ? nullptr : InputType::createText(*this)),
       m_inputTypeView(m_inputType ? m_inputType->createView() : nullptr) {
   setHasCustomStyleCallbacks();
 }
 
 HTMLInputElement* HTMLInputElement::create(Document& document,
                                            HTMLFormElement* form,
                                            bool createdByParser) {
   HTMLInputElement* inputElement =
       new HTMLInputElement(document, form, createdByParser);
@@ skipping 176 matching lines @@
         break;
       case SelectionBehaviorOnFocus::None:
         return;
     }
     // TODO(tkent): scrollRectToVisible is a workaround of a bug of
     // FrameSelection::revealSelection().  It doesn't scroll correctly in a
     // case of RangeSelection. crbug.com/443061.
     if (layoutObject())
       layoutObject()->scrollRectToVisible(boundingBox());
     if (document().frame()) {
-      // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
-      // needs to be audited.  See http://crbug.com/590369 for more details.
+      // TODO(xiaochengh): The use of
+      // updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.  See
+      // http://crbug.com/590369 for more details.
       document().updateStyleAndLayoutIgnorePendingStylesheets();
 
       document().frame()->selection().revealSelection();
     }
   } else {
     HTMLTextFormControlElement::updateFocusAppearance(selectionBehavior);
   }
 }
 
 void HTMLInputElement::beginEditing() {
@@ skipping 139 matching lines @@
 
   setNeedsValidityCheck();
   if ((couldBeSuccessfulSubmitButton || canBeSuccessfulSubmitButton()) &&
       formOwner() && isConnected())
     formOwner()->invalidateDefaultButtonStyle();
   notifyFormStateChanged();
 }
 
 void HTMLInputElement::subtreeHasChanged() {
   m_inputTypeView->subtreeHasChanged();
-  // When typing in an input field, childrenChanged is not called, so we need to force the directionality check.
+  // When typing in an input field, childrenChanged is not called, so we need to
+  // force the directionality check.
   calculateAndAdjustDirectionality();
 }
 
 const AtomicString& HTMLInputElement::formControlType() const {
   return m_inputType->formControlType();
 }
 
 bool HTMLInputElement::shouldSaveAndRestoreFormControlState() const {
   if (!m_inputType->shouldSaveAndRestoreFormControlState())
     return false;
@@ skipping 181 matching lines @@
       m_autocomplete = Off;
     } else {
       if (value.isEmpty())
         m_autocomplete = Uninitialized;
       else
         m_autocomplete = On;
     }
   } else if (name == typeAttr) {
     updateType();
   } else if (name == valueAttr) {
-    // We only need to setChanged if the form is looking at the default value right now.
+    // We only need to setChanged if the form is looking at the default value
+    // right now.
     if (!hasDirtyValue()) {
       updatePlaceholderVisibility();
       setNeedsStyleRecalc(
           SubtreeStyleChange,
           StyleChangeReasonForTracing::fromAttribute(valueAttr));
     }
     m_needsToUpdateViewValue = true;
     setNeedsValidityCheck();
     m_valueAttributeWasUpdatedAfterParsing = !m_parsingInProgress;
     m_inputType->warnIfValueIsInvalidAndElementIsVisible(value);
@@ skipping 24 matching lines @@
     if (m_size != oldSize && layoutObject())
       layoutObject()->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
           LayoutInvalidationReason::AttributeChanged);
   } else if (name == altAttr) {
     m_inputTypeView->altAttributeChanged();
   } else if (name == srcAttr) {
     m_inputTypeView->srcAttributeChanged();
   } else if (name == usemapAttr || name == accesskeyAttr) {
     // FIXME: ignore for the moment
   } else if (name == onsearchAttr) {
-    // Search field and slider attributes all just cause updateFromElement to be called through style recalcing.
+    // Search field and slider attributes all just cause updateFromElement to be
+    // called through style recalcing.
     setAttributeEventListener(
         EventTypeNames::search,
         createAttributeEventListener(this, name, value, eventParameterName()));
   } else if (name == incrementalAttr) {
     UseCounter::count(document(), UseCounter::IncrementalAttribute);
   } else if (name == minAttr) {
     m_inputTypeView->minOrMaxAttributeChanged();
     m_inputType->sanitizeValueInResponseToMinOrMaxAttributeChange();
     setNeedsValidityCheck();
     UseCounter::count(document(), UseCounter::MinAttribute);
@@ skipping 294 matching lines @@
   m_inputType->warnIfValueIsInvalidAndElementIsVisible(value);
   if (!m_inputType->canSetValue(value))
     return;
 
   EventQueueScope scope;
   String sanitizedValue = sanitizeValue(value);
   bool valueChanged = sanitizedValue != this->value();
 
   setLastChangeWasNotUserEdit();
   m_needsToUpdateViewValue = true;
-  m_suggestedValue =
-      String();  // Prevent TextFieldInputType::setValue from using the suggested value.
+  // Prevent TextFieldInputType::setValue from using the suggested value.
+  m_suggestedValue = String();
 
   m_inputType->setValue(sanitizedValue, valueChanged, eventBehavior);
   m_inputTypeView->didSetValue(sanitizedValue, valueChanged);
 
   if (valueChanged && eventBehavior == DispatchNoEvent)
     setTextAsOfLastFormControlChangeEvent(
         sanitizedValue.isNull() ? defaultValue() : sanitizedValue);
 
   if (!valueChanged)
     return;
@@ skipping 62 matching lines @@
 
   // Renderer and our event handler are responsible for sanitizing values.
   DCHECK(value == m_inputType->sanitizeUserInputValue(value) ||
          m_inputType->sanitizeUserInputValue(value).isEmpty());
 
   DCHECK(!value.isNull());
   m_valueIfDirty = value;
   m_hasDirtyValue = true;
   m_needsToUpdateViewValue = false;
 
-  // Input event is fired by the Node::defaultEventHandler for editable controls.
+  // Input event is fired by the Node::defaultEventHandler for editable
+  // controls.
   if (!isTextField())
     dispatchInputEvent();
   notifyFormStateChanged();
 
   setNeedsValidityCheck();
 
   // Clear autofill flag (and yellow background) on user edit.
   setAutofilled(false);
 }
 
@@ skipping 30 matching lines @@
     if (evt->defaultHandled())
       return;
   }
 
   if (evt->isKeyboardEvent() && evt->type() == EventTypeNames::keydown) {
     m_inputTypeView->handleKeydownEvent(toKeyboardEvent(evt));
     if (evt->defaultHandled())
       return;
   }
 
-  // Call the base event handler before any of our own event handling for almost all events in text fields.
-  // Makes editing keyboard handling take precedence over the keydown and keypress handling in this function.
+  // Call the base event handler before any of our own event handling for almost
+  // all events in text fields.  Makes editing keyboard handling take precedence
+  // over the keydown and keypress handling in this function.
   bool callBaseClassEarly =
       isTextField() && (evt->type() == EventTypeNames::keydown ||
                         evt->type() == EventTypeNames::keypress);
   if (callBaseClassEarly) {
     HTMLTextFormControlElement::defaultEventHandler(evt);
     if (evt->defaultHandled())
       return;
   }
 
-  // DOMActivate events cause the input to be "activated" - in the case of image and submit inputs, this means
-  // actually submitting the form. For reset inputs, the form is reset. These events are sent when the user clicks
-  // on the element, or presses enter while it is the active element. JavaScript code wishing to activate the element
-  // must dispatch a DOMActivate event - a click event will not do the job.
+  // DOMActivate events cause the input to be "activated" - in the case of image
+  // and submit inputs, this means actually submitting the form. For reset
+  // inputs, the form is reset. These events are sent when the user clicks on
+  // the element, or presses enter while it is the active element. JavaScript
+  // code wishing to activate the element must dispatch a DOMActivate event - a
+  // click event will not do the job.
   if (evt->type() == EventTypeNames::DOMActivate) {
     m_inputTypeView->handleDOMActivateEvent(evt);
     if (evt->defaultHandled())
       return;
   }
 
   // Use key press event here since sending simulated mouse events
   // on key down blocks the proper sending of the key press event.
   if (evt->isKeyboardEvent() && evt->type() == EventTypeNames::keypress) {
     m_inputTypeView->handleKeypressEvent(toKeyboardEvent(evt));
@@ skipping 12 matching lines @@
     if (type() == InputTypeNames::search)
       document().postTask(BLINK_FROM_HERE,
                           createSameThreadTask(&HTMLInputElement::onSearch,
                                                wrapPersistent(this)));
     // Form submission finishes editing, just as loss of focus does.
     // If there was a change, send the event now.
     if (wasChangedSinceLastFormControlChangeEvent())
       dispatchFormControlChangeEvent();
 
     HTMLFormElement* formForSubmission = m_inputTypeView->formForSubmission();
-    // Form may never have been present, or may have been destroyed by code responding to the change event.
+    // Form may never have been present, or may have been destroyed by code
+    // responding to the change event.
     if (formForSubmission)
       formForSubmission->submitImplicitly(evt, canTriggerImplicitSubmission());
 
     evt->setDefaultHandled();
     return;
   }
 
   if (evt->isBeforeTextInsertedEvent())
     m_inputTypeView->handleBeforeTextInsertedEvent(
         static_cast<BeforeTextInsertedEvent*>(evt));
 
   if (evt->isMouseEvent() && evt->type() == EventTypeNames::mousedown) {
     m_inputTypeView->handleMouseDownEvent(toMouseEvent(evt));
     if (evt->defaultHandled())
       return;
   }
 
   m_inputTypeView->forwardEvent(evt);
 
   if (!callBaseClassEarly && !evt->defaultHandled())
     HTMLTextFormControlElement::defaultEventHandler(evt);
 }
 
 bool HTMLInputElement::willRespondToMouseClickEvents() {
-  // FIXME: Consider implementing willRespondToMouseClickEvents() in InputType if more accurate results are necessary.
+  // FIXME: Consider implementing willRespondToMouseClickEvents() in InputType
+  // if more accurate results are necessary.
   if (!isDisabledFormControl())
     return true;
 
   return HTMLTextFormControlElement::willRespondToMouseClickEvents();
 }
 
 bool HTMLInputElement::isURLAttribute(const Attribute& attribute) const {
   return attribute.name() == srcAttr || attribute.name() == formactionAttr ||
          HTMLTextFormControlElement::isURLAttribute(attribute);
 }
@@ skipping 638 matching lines @@
 
 bool HTMLInputElement::hasFallbackContent() const {
   return m_inputTypeView->hasFallbackContent();
 }
 
 void HTMLInputElement::setFilesFromPaths(const Vector<String>& paths) {
   return m_inputType->setFilesFromPaths(paths);
 }
 
 }  // namespace blink