Avoid WTF::Vector::at() and operator[] in core/html.

third_party/WebKit/Source/core/html/HTMLFormElement.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 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
@@ skipping 176 matching lines @@
   if (event.eventPhase() != Event::kCapturingPhase && targetNode &&
       targetNode != this && (event.type() == EventTypeNames::submit ||
                              event.type() == EventTypeNames::reset)) {
     event.stopPropagation();
     return;
   }
   HTMLElement::handleLocalEvents(event);
 }
 
 unsigned HTMLFormElement::length() const {
-  const ListedElement::List& elements = listedElements();
   unsigned len = 0;
-  for (unsigned i = 0; i < elements.size(); ++i) {
-    if (elements[i]->isEnumeratable())
+  for (const auto& element : listedElements()) {
+    if (element->isEnumeratable())
       ++len;
   }
   return len;
 }
 
 HTMLElement* HTMLFormElement::item(unsigned index) {
   return elements()->item(index);
 }
 
 void HTMLFormElement::submitImplicitly(Event* event,
                                        bool fromImplicitSubmissionTrigger) {
   int submissionTriggerCount = 0;
   bool seenDefaultButton = false;
-  const ListedElement::List& elements = listedElements();
-  for (unsigned i = 0; i < elements.size(); ++i) {
-    ListedElement* ListedElement = elements[i];
-    if (!ListedElement->isFormControlElement())
+  for (const auto& element : listedElements()) {
+    if (!element->isFormControlElement())
       continue;
-    HTMLFormControlElement* control = toHTMLFormControlElement(ListedElement);
+    HTMLFormControlElement* control = toHTMLFormControlElement(element);
     if (!seenDefaultButton && control->canBeSuccessfulSubmitButton()) {
       if (fromImplicitSubmissionTrigger)
         seenDefaultButton = true;
       if (control->isSuccessfulSubmitButton()) {
         control->dispatchSimulatedClick(event);
         return;
       }
       if (fromImplicitSubmissionTrigger) {
         // Default (submit) button is not activated; no implicit submission.
         return;
       }
     } else if (control->canTriggerImplicitSubmission()) {
       ++submissionTriggerCount;
     }
   }
   if (fromImplicitSubmissionTrigger && submissionTriggerCount == 1)
     prepareForSubmission(event, nullptr);
 }
 
 bool HTMLFormElement::validateInteractively() {
   UseCounter::count(document(), UseCounter::FormValidationStarted);
-  const ListedElement::List& elements = listedElements();
-  for (unsigned i = 0; i < elements.size(); ++i) {
-    if (elements[i]->isFormControlElement())
-      toHTMLFormControlElement(elements[i])->hideVisibleValidationMessage();
+  for (const auto& element : listedElements()) {
+    if (element->isFormControlElement())
+      toHTMLFormControlElement(element)->hideVisibleValidationMessage();
   }
 
   HeapVector<Member<HTMLFormControlElement>> unhandledInvalidControls;
   if (!checkInvalidControlsAndCollectUnhandled(
           &unhandledInvalidControls, CheckValidityDispatchInvalidEvent))
     return true;
   UseCounter::count(document(), UseCounter::FormValidationAbortedSubmission);
   // Because the form has invalid controls, we abort the form submission and
   // show a validation message on a focusable form control.
 
   // Needs to update layout now because we'd like to call isFocusable(), which
   // has !layoutObject()->needsLayout() assertion.
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   // Focus on the first focusable control and show a validation message.
-  for (unsigned i = 0; i < unhandledInvalidControls.size(); ++i) {
-    HTMLFormControlElement* unhandled = unhandledInvalidControls[i].get();
+  for (const auto& unhandled : unhandledInvalidControls) {
     if (unhandled->isFocusable()) {
       unhandled->showValidationMessage();
       UseCounter::count(document(), UseCounter::FormValidationShowedMessage);
       break;
     }
   }
   // Warn about all of unfocusable controls.
   if (document().frame()) {
-    for (unsigned i = 0; i < unhandledInvalidControls.size(); ++i) {
-      HTMLFormControlElement* unhandled = unhandledInvalidControls[i].get();
+    for (const auto& unhandled : unhandledInvalidControls) {
       if (unhandled->isFocusable())
         continue;
       String message(
           "An invalid form control with name='%name' is not focusable.");
       message.replace("%name", unhandled->name());
       document().addConsoleMessage(ConsoleMessage::create(
           RenderingMessageSource, ErrorMessageLevel, message));
     }
   }
   return false;
@@ skipping 182 matching lines @@
     return;
 
   m_isInResetFunction = true;
 
   if (dispatchEvent(Event::createCancelableBubble(EventTypeNames::reset)) !=
       DispatchEventResult::NotCanceled) {
     m_isInResetFunction = false;
     return;
   }
 
-  const ListedElement::List& elements = listedElements();
-  for (unsigned i = 0; i < elements.size(); ++i) {
-    if (elements[i]->isFormControlElement())
-      toHTMLFormControlElement(elements[i])->reset();
+  for (const auto& element : listedElements()) {
+    if (element->isFormControlElement())
+      toHTMLFormControlElement(element)->reset();
   }
 
   m_isInResetFunction = false;
 }
 
 void HTMLFormElement::parseAttribute(const QualifiedName& name,
                                      const AtomicString& oldValue,
                                      const AtomicString& value) {
   if (name == actionAttr) {
     m_attributes.parseAction(value);
@@ skipping 169 matching lines @@
 }
 
 bool HTMLFormElement::checkInvalidControlsAndCollectUnhandled(
     HeapVector<Member<HTMLFormControlElement>>* unhandledInvalidControls,
     CheckValidityEventBehavior eventBehavior) {
   // Copy listedElements because event handlers called from
   // HTMLFormControlElement::checkValidity() might change listedElements.
   const ListedElement::List& listedElements = this->listedElements();
   HeapVector<Member<ListedElement>> elements;
   elements.reserveCapacity(listedElements.size());
-  for (unsigned i = 0; i < listedElements.size(); ++i)
-    elements.append(listedElements[i]);
+  for (const auto& element : listedElements)
+    elements.append(element);
   int invalidControlsCount = 0;
-  for (unsigned i = 0; i < elements.size(); ++i) {
-    if (elements[i]->form() == this && elements[i]->isFormControlElement()) {
-      HTMLFormControlElement* control =
-          toHTMLFormControlElement(elements[i].get());
+  for (const auto& element : elements) {
+    if (element->form() == this && element->isFormControlElement()) {
+      HTMLFormControlElement* control = toHTMLFormControlElement(element);
       if (control->isSubmittableElement() &&
           !control->checkValidity(unhandledInvalidControls, eventBehavior) &&
           control->formOwner() == this) {
         ++invalidControlsCount;
         if (!unhandledInvalidControls &&
             eventBehavior == CheckValidityDispatchNoEvent)
           return true;
       }
     }
   }
@@ skipping 128 matching lines @@
   for (const auto& control : listedElements()) {
     if (!control->isFormControlElement())
       continue;
     if (toHTMLFormControlElement(control)->canBeSuccessfulSubmitButton())
       toHTMLFormControlElement(control)->pseudoStateChanged(
           CSSSelector::PseudoDefault);
   }
 }
 
 }  // namespace blink