Use C++11 features in core/html

Source/core/html/forms/FormController.cpp

 /*
  * Copyright (C) 2006, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010, 2011, 2012 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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 211 matching lines @@
         if (type.isEmpty() || type.find(isNotFormControlTypeCharacter) != kNotFound || state.isFailure())
             return nullptr;
         savedFormState->appendControlState(AtomicString(name), AtomicString(type), state);
     }
     return savedFormState.release();
 }
 
 void SavedFormState::serializeTo(Vector<String>& stateVector) const
 {
     stateVector.append(String::number(m_controlStateCount));
-    for (FormElementStateMap::const_iterator it = m_stateForNewFormElements.begin(); it != m_stateForNewFormElements.end(); ++it) {
-        const FormElementKey& key = it->key;
-        const Deque<FormControlState>& queue = it->value;
-        for (Deque<FormControlState>::const_iterator queIterator = queue.begin(); queIterator != queue.end(); ++queIterator) {
+    for (const auto& formControl : m_stateForNewFormElements) {
+        const FormElementKey& key = formControl.key;
+        const Deque<FormControlState>& queue = formControl.value;
+        for (const FormControlState& formControlState : queue) {
             stateVector.append(key.name());
             stateVector.append(key.type());
-            queIterator->serializeTo(stateVector);
+            formControlState.serializeTo(stateVector);
         }
     }
 }
 
 void SavedFormState::appendControlState(const AtomicString& name, const AtomicString& type, const FormControlState& state)
 {
     FormElementKey key(name.impl(), type.impl());
     FormElementStateMap::iterator it = m_stateForNewFormElements.find(key);
     if (it != m_stateForNewFormElements.end()) {
         it->value.append(state);
@@ skipping 16 matching lines @@
     FormControlState state = it->value.takeFirst();
     m_controlStateCount--;
     if (!it->value.size())
         m_stateForNewFormElements.remove(it);
     return state;
 }
 
 Vector<String> SavedFormState::getReferencedFilePaths() const
 {
     Vector<String> toReturn;
-    for (FormElementStateMap::const_iterator it = m_stateForNewFormElements.begin(); it != m_stateForNewFormElements.end(); ++it) {
-        const FormElementKey& key = it->key;
+    for (const auto& formControl : m_stateForNewFormElements) {
+        const FormElementKey& key = formControl.key;
         if (!equal(key.type(), "file", 4))
             continue;
-        const Deque<FormControlState>& queue = it->value;
-        for (Deque<FormControlState>::const_iterator queIterator = queue.begin(); queIterator != queue.end(); ++queIterator) {
-            const Vector<FileChooserFileInfo>& selectedFiles = HTMLInputElement::filesFromFileInputFormControlState(*queIterator);
+        const Deque<FormControlState>& queue = formControl.value;
+        for (const FormControlState& formControlState : queue) {
+            const Vector<FileChooserFileInfo>& selectedFiles = HTMLInputElement::filesFromFileInputFormControlState(formControlState);
             for (size_t i = 0; i < selectedFiles.size(); ++i)
                 toReturn.append(selectedFiles[i].path);
         }
     }
     return toReturn;
 }
 
 // ----------------------------------------------------------------------------
 
 class FormKeyGenerator final : public NoBaseWillBeGarbageCollectedFinalized<FormKeyGenerator> {
@@ skipping 122 matching lines @@
     // attribute value of a form control. The following string literal should
     // contain some characters which are rarely used for name attribute values.
     DEFINE_STATIC_LOCAL(String, signature, ("\n\r?% Blink serialized form state version 9 \n\r=&"));
     return signature;
 }
 
 Vector<String> DocumentState::toStateVector()
 {
     OwnPtrWillBeRawPtr<FormKeyGenerator> keyGenerator = FormKeyGenerator::create();
     OwnPtr<SavedFormStateMap> stateMap = adoptPtr(new SavedFormStateMap);
-    for (FormElementListHashSet::const_iterator it = m_formControls.begin(); it != m_formControls.end(); ++it) {
-        HTMLFormControlElementWithState* control = it->get();
+    for (const auto& formControl : m_formControls) {
+        HTMLFormControlElementWithState* control = formControl.get();
         ASSERT(control->inDocument());
         if (!control->shouldSaveAndRestoreFormControlState())
             continue;
         SavedFormStateMap::AddResult result = stateMap->add(keyGenerator->formKey(*control), nullptr);
         if (result.isNewEntry)
             result.storedValue->value = SavedFormState::create();
         result.storedValue->value->appendControlState(control->name(), control->type(), control->saveFormControlState());
     }
 
     Vector<String> stateVector;
     stateVector.reserveInitialCapacity(m_formControls.size() * 4);
     stateVector.append(formStateSignature());
-    for (SavedFormStateMap::const_iterator it = stateMap->begin(); it != stateMap->end(); ++it) {
-        stateVector.append(it->key);
-        it->value->serializeTo(stateVector);
+    for (const auto& savedFormState : *stateMap) {
+        stateVector.append(savedFormState.key);
+        savedFormState.value->serializeTo(stateVector);
     }
     bool hasOnlySignature = stateVector.size() == 1;
     if (hasOnlySignature)
         stateVector.clear();
     return stateVector;
 }
 
 // ----------------------------------------------------------------------------
 
 FormController::FormController()
@@ skipping 74 matching lines @@
     if (ownerFormForState(control))
         return;
     FormControlState state = takeStateForFormElement(control);
     if (state.valueSize() > 0)
         control.restoreFormControlState(state);
 }
 
 void FormController::restoreControlStateIn(HTMLFormElement& form)
 {
     const FormAssociatedElement::List& elements = form.associatedElements();
-    for (size_t i = 0; i < elements.size(); ++i) {
-        if (!elements[i]->isFormControlElementWithState())
+    for (const auto& element : elements) {
+        if (!element->isFormControlElementWithState())
             continue;
-        HTMLFormControlElementWithState* control = toHTMLFormControlElementWithState(elements[i]);
+        HTMLFormControlElementWithState* control = toHTMLFormControlElementWithState(element);
         if (!control->shouldSaveAndRestoreFormControlState())
             continue;
         if (ownerFormForState(*control) != &form)
             continue;
         FormControlState state = takeStateForFormElement(*control);
         if (state.valueSize() > 0)
             control->restoreFormControlState(state);
     }
 }
 
 Vector<String> FormController::getReferencedFilePaths(const Vector<String>& stateVector)
 {
     Vector<String> toReturn;
     SavedFormStateMap map;
     formStatesFromStateVector(stateVector, map);
-    for (SavedFormStateMap::const_iterator it = map.begin(); it != map.end(); ++it)
-        toReturn.appendVector(it->value->getReferencedFilePaths());
+    for (const auto& savedFormState : map)
+        toReturn.appendVector(savedFormState.value->getReferencedFilePaths());
     return toReturn;
 }
 
 void FormController::registerStatefulFormControl(HTMLFormControlElementWithState& control)
 {
     m_documentState->addControl(&control);
 }
 
 void FormController::unregisterStatefulFormControl(HTMLFormControlElementWithState& control)
 {
     m_documentState->removeControl(&control);
 }
 
 } // namespace blink