Use C++11 range-based for loop in Source/core/inspector

Source/core/inspector/InspectorDOMAgent.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 204 matching lines @@
 {
     m_contentDistributionInvalidatedElements.add(element);
     if (!m_timer.isActive())
         m_timer.startOneShot(0, FROM_HERE);
 }
 
 void InspectorRevalidateDOMTask::onTimer(Timer<InspectorRevalidateDOMTask>*)
 {
     // The timer is stopped on m_domAgent destruction, so this method will never be called after m_domAgent has been destroyed.
     WillBeHeapVector<RawPtrWillBeMember<Element> > elements;
-    WillBePersistentHeapHashSet<RefPtrWillBeMember<Element> >::iterator it;
-    for (it = m_styleAttrInvalidatedElements.begin(); it != m_styleAttrInvalidatedElements.end(); ++it)
-        elements.append(it->get());
+    for (auto& attribute : m_styleAttrInvalidatedElements)
+        elements.append(attribute.get());
     m_domAgent->styleAttributeInvalidated(elements);
 
     m_styleAttrInvalidatedElements.clear();
 
     elements.clear();
     for (const RefPtrWillBeMember<Element>& it : m_contentDistributionInvalidatedElements)
         elements.append(it.get());
     m_domAgent->contentDistributionInvalidated(elements);
 
     m_contentDistributionInvalidatedElements.clear();
@@ skipping 598 matching lines @@
 
     String caseAdjustedName = name ? (shouldIgnoreCase ? name->lower() : *name) : String();
 
     AttributeCollection attributes = parsedElement->attributes();
     if (attributes.isEmpty() && name) {
         m_domEditor->removeAttribute(element, caseAdjustedName, errorString);
         return;
     }
 
     bool foundOriginalAttribute = false;
-    AttributeCollection::iterator end = attributes.end();
-    for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
+    for (auto& attribute : attributes) {
         // Add attribute pair
-        String attributeName = it->name().toString();
+        String attributeName = attribute.name().toString();
         if (shouldIgnoreCase)
             attributeName = attributeName.lower();
         foundOriginalAttribute |= name && attributeName == caseAdjustedName;
-        if (!m_domEditor->setAttribute(element, attributeName, it->value(), errorString))
+        if (!m_domEditor->setAttribute(element, attributeName, attribute.value(), errorString))
             return;
     }
 
     if (!foundOriginalAttribute && name && !name->stripWhiteSpace().isEmpty())
         m_domEditor->removeAttribute(element, caseAdjustedName, errorString);
 }
 
 void InspectorDOMAgent::removeAttribute(ErrorString* errorString, int elementId, const String& name)
 {
     Element* element = assertEditableElement(errorString, elementId);
@@ skipping 240 matching lines @@
     if (endTagFound)
         tagNameQuery = tagNameQuery.left(tagNameQuery.length() - 1);
     if (startQuoteFound)
         attributeQuery = attributeQuery.right(attributeQuery.length() - 1);
     if (endQuoteFound)
         attributeQuery = attributeQuery.left(attributeQuery.length() - 1);
 
     WillBeHeapVector<RawPtrWillBeMember<Document> > docs = documents();
     WillBeHeapListHashSet<RawPtrWillBeMember<Node> > resultCollector;
 
-    for (WillBeHeapVector<RawPtrWillBeMember<Document> >::iterator it = docs.begin(); it != docs.end(); ++it) {
-        Document* document = *it;
+    for (Document* document : docs) {
         Node* documentElement = document->documentElement();
         Node* node = documentElement;
         if (!node)
             continue;
 
         // Manual plain text search.
         for (; node; node = nextNodeWithShadowDOMInMind(*node, documentElement, includeUserAgentShadowDOM)) {
             switch (node->nodeType()) {
             case Node::TEXT_NODE:
             case Node::COMMENT_NODE:
             case Node::CDATA_SECTION_NODE: {
                 String text = node->nodeValue();
                 if (text.findIgnoringCase(whitespaceTrimmedQuery) != kNotFound)
                     resultCollector.add(node);
                 break;
             }
             case Node::ELEMENT_NODE: {
                 if ((!startTagFound && !endTagFound && (node->nodeName().findIgnoringCase(tagNameQuery) != kNotFound))
                     || (startTagFound && endTagFound && equalIgnoringCase(node->nodeName(), tagNameQuery))
                     || (startTagFound && !endTagFound && node->nodeName().startsWith(tagNameQuery, false))
                     || (!startTagFound && endTagFound && node->nodeName().endsWith(tagNameQuery, false))) {
                     resultCollector.add(node);
                     break;
                 }
                 // Go through all attributes and serialize them.
                 const Element* element = toElement(node);
                 AttributeCollection attributes = element->attributes();
-                AttributeCollection::iterator end = attributes.end();
-                for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
+                for (auto& attribute : attributes) {
                     // Add attribute pair
-                    if (it->localName().find(whitespaceTrimmedQuery, 0, false) != kNotFound) {
+                    if (attribute.localName().find(whitespaceTrimmedQuery, 0, false) != kNotFound) {
                         resultCollector.add(node);
                         break;
                     }
-                    size_t foundPosition = it->value().find(attributeQuery, 0, false);
+                    size_t foundPosition = attribute.value().find(attributeQuery, 0, false);
                     if (foundPosition != kNotFound) {
-                        if (!exactAttributeMatch || (!foundPosition && it->value().length() == attributeQuery.length())) {
+                        if (!exactAttributeMatch || (!foundPosition && attribute.value().length() == attributeQuery.length())) {
                             resultCollector.add(node);
                             break;
                         }
                     }
                 }
                 break;
             }
             default:
                 break;
             }
         }
 
         // XPath evaluation
-        for (WillBeHeapVector<RawPtrWillBeMember<Document> >::iterator it = docs.begin(); it != docs.end(); ++it) {
-            Document* document = *it;
+        for (Document* document : docs) {
             ASSERT(document);
             TrackExceptionState exceptionState;
             RefPtrWillBeRawPtr<XPathResult> result = DocumentXPathEvaluator::evaluate(*document, whitespaceTrimmedQuery, document, nullptr, XPathResult::ORDERED_NODE_SNAPSHOT_TYPE, 0, exceptionState);
             if (exceptionState.hadException() || !result)
                 continue;
 
             unsigned long size = result->snapshotLength(exceptionState);
             for (unsigned long i = 0; !exceptionState.hadException() && i < size; ++i) {
                 Node* node = result->snapshotItem(i, exceptionState);
                 if (exceptionState.hadException())
                     break;
 
                 if (node->nodeType() == Node::ATTRIBUTE_NODE)
                     node = toAttr(node)->ownerElement();
                 resultCollector.add(node);
             }
         }
 
         // Selector evaluation
-        for (WillBeHeapVector<RawPtrWillBeMember<Document> >::iterator it = docs.begin(); it != docs.end(); ++it) {
-            Document* document = *it;
+        for (Document* document : docs) {
             TrackExceptionState exceptionState;
             RefPtrWillBeRawPtr<StaticElementList> elementList = document->querySelectorAll(AtomicString(whitespaceTrimmedQuery), exceptionState);
             if (exceptionState.hadException() || !elementList)
                 continue;
 
             unsigned size = elementList->length();
             for (unsigned i = 0; i < size; ++i)
                 resultCollector.add(elementList->item(i));
         }
     }
 
     *searchId = IdentifiersFactory::createIdentifier();
     WillBeHeapVector<RefPtrWillBeMember<Node> >* resultsIt = &m_searchResults.add(*searchId, WillBeHeapVector<RefPtrWillBeMember<Node> >()).storedValue->value;
 
-    for (WillBeHeapListHashSet<RawPtrWillBeMember<Node> >::iterator it = resultCollector.begin(); it != resultCollector.end(); ++it)
-        resultsIt->append(*it);
+    for (auto& result : resultCollector)
+        resultsIt->append(result);
 
     *resultCount = resultsIt->size();
 }
 
 void InspectorDOMAgent::getSearchResults(ErrorString* errorString, const String& searchId, int fromIndex, int toIndex, RefPtr<TypeBuilder::Array<int> >& nodeIds)
 {
     SearchResults::iterator it = m_searchResults.find(searchId);
     if (it == m_searchResults.end()) {
         *errorString = "No search session with given id found";
         return;
@@ skipping 321 matching lines @@
 {
     Node* node = assertNode(errorString, nodeId);
     if (!node)
         return;
     if (!isHTMLInputElement(*node) || toHTMLInputElement(*node).type() != InputTypeNames::file) {
         *errorString = "Node is not a file input element";
         return;
     }
 
     FileList* fileList = FileList::create();
-    for (JSONArray::const_iterator iter = files->begin(); iter != files->end(); ++iter) {
+    for (const auto& file : *files) {
         String path;
-        if (!(*iter)->asString(&path)) {
+        if (!(file)->asString(&path)) {
             *errorString = "Files must be strings";
             return;
         }
         fileList->append(File::create(path));
     }
     toHTMLInputElement(node)->setFiles(fileList);
 }
 
 void InspectorDOMAgent::getBoxModel(ErrorString* errorString, int nodeId, RefPtr<TypeBuilder::DOM::BoxModel>& model)
 {
@@ skipping 195 matching lines @@
     }
 
     return value.release();
 }
 
 PassRefPtr<TypeBuilder::Array<String> > InspectorDOMAgent::buildArrayForElementAttributes(Element* element)
 {
     RefPtr<TypeBuilder::Array<String> > attributesValue = TypeBuilder::Array<String>::create();
     // Go through all attributes and serialize them.
     AttributeCollection attributes = element->attributes();
-    AttributeCollection::iterator end = attributes.end();
-    for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
+    for (auto& attribute : attributes) {
         // Add attribute pair
-        attributesValue->addItem(it->name().toString());
-        attributesValue->addItem(it->value());
+        attributesValue->addItem(attribute.name().toString());
+        attributesValue->addItem(attribute.value());
     }
     return attributesValue.release();
 }
 
 PassRefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > InspectorDOMAgent::buildArrayForContainerChildren(Node* container, int depth, NodeToIdMap* nodesMap)
 {
     RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > children = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
     if (depth == 0) {
         // Special-case the only text child - pretend that container's children have been requested.
         Node* firstChild = container->firstChild();
@@ skipping 448 matching lines @@
 {
     if (Node* node = nodeForPath(path))
         *nodeId = pushNodePathToFrontend(node);
     else
         *errorString = "No node with given path found";
 }
 
 void InspectorDOMAgent::pushNodesByBackendIdsToFrontend(ErrorString* errorString, const RefPtr<JSONArray>& backendNodeIds, RefPtr<TypeBuilder::Array<int> >& result)
 {
     result = TypeBuilder::Array<int>::create();
-    for (JSONArray::const_iterator it = backendNodeIds->begin(); it != backendNodeIds->end(); ++it) {
+    for (const auto& backendNode : *backendNodeIds) {
         int backendNodeId;
 
-        if (!(*it)->asNumber(&backendNodeId)) {
+        if (!(backendNode)->asNumber(&backendNodeId)) {
             *errorString = "Invalid argument type";
             return;
         }
 
         Node* node = InspectorNodeIds::nodeForId(backendNodeId);
         if (node && node->document().page() == m_pageAgent->page())
             result->addItem(pushNodePathToFrontend(node));
         else
             result->addItem(0);
     }
@@ skipping 53 matching lines @@
     visitor->trace(m_revalidateTask);
     visitor->trace(m_searchResults);
 #endif
     visitor->trace(m_history);
     visitor->trace(m_domEditor);
     visitor->trace(m_listener);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink