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

Source/core/inspector/InspectorResourceContentLoader.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/inspector/InspectorResourceContentLoader.h"
 
 #include "core/FetchInitiatorTypeNames.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/StyleSheetContents.h"
@@ skipping 73 matching lines @@
 {
     m_started = true;
     Vector<Document*> documents;
     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
         if (!frame->isLocalFrame())
             continue;
         LocalFrame* localFrame = toLocalFrame(frame);
         documents.append(localFrame->document());
         documents.appendVector(InspectorPageAgent::importsForFrame(localFrame));
     }
-    for (Vector<Document*>::const_iterator documentIt = documents.begin(); documentIt != documents.end(); ++documentIt) {
-        Document* document = *documentIt;
+    for (const auto& documentIt : documents) {
+        Document* document = documentIt;
         HashSet<String> urlsToFetch;
 
         ResourceRequest resourceRequest;
         HistoryItem* item = document->frame() ? document->frame()->loader().currentItem() : 0;
         if (item) {
             resourceRequest = FrameLoader::requestFromHistoryItem(item, ReturnCacheDataDontLoad);
         } else {
             resourceRequest = document->url();
             resourceRequest.setCachePolicy(ReturnCacheDataDontLoad);
         }
         resourceRequest.setRequestContext(blink::WebURLRequest::RequestContextInternal);
 
         if (!resourceRequest.url().string().isEmpty()) {
             urlsToFetch.add(resourceRequest.url().string());
             FetchRequest request(resourceRequest, FetchInitiatorTypeNames::internal);
             ResourcePtr<Resource> resource = document->fetcher()->fetchRawResource(request);
             if (resource) {
                 // Prevent garbage collection by holding a reference to this resource.
                 m_resources.append(resource.get());
                 ResourceClient* resourceClient = new ResourceClient(this);
                 m_pendingResourceClients.add(resourceClient);
                 resourceClient->waitForResource(resource.get());
             }
         }
 
         WillBeHeapVector<RawPtrWillBeMember<CSSStyleSheet> > styleSheets;
         InspectorCSSAgent::collectAllDocumentStyleSheets(document, styleSheets);
-        for (WillBeHeapVector<RawPtrWillBeMember<CSSStyleSheet> >::const_iterator stylesheetIt = styleSheets.begin(); stylesheetIt != styleSheets.end(); ++stylesheetIt) {
-            CSSStyleSheet* styleSheet = *stylesheetIt;
+        for (const auto& stylesheetIt : styleSheets) {
+            CSSStyleSheet* styleSheet = stylesheetIt;
             if (styleSheet->isInline() || !styleSheet->contents()->loadCompleted())
                 continue;
             String url = styleSheet->baseURL().string();
             if (url.isEmpty() || urlsToFetch.contains(url))
                 continue;
             urlsToFetch.add(url);
             FetchRequest request(ResourceRequest(url), FetchInitiatorTypeNames::internal);
             request.mutableResourceRequest().setRequestContext(blink::WebURLRequest::RequestContextInternal);
             ResourcePtr<Resource> resource = document->fetcher()->fetchCSSStyleSheet(request);
             if (!resource)
@@ skipping 31 matching lines @@
 
 void InspectorResourceContentLoader::dispose()
 {
     stop();
 }
 
 void InspectorResourceContentLoader::stop()
 {
     HashSet<ResourceClient*> pendingResourceClients;
     m_pendingResourceClients.swap(pendingResourceClients);
-    for (HashSet<ResourceClient*>::const_iterator it = pendingResourceClients.begin(); it != pendingResourceClients.end(); ++it)
-        (*it)->m_loader = 0;
+    for (const auto& it : pendingResourceClients)
+        it->m_loader = 0;
     m_resources.clear();
     // Make sure all callbacks are called to prevent infinite waiting time.
     checkDone();
 }
 
 bool InspectorResourceContentLoader::hasFinished()
 {
     return m_allRequestsStarted && m_pendingResourceClients.size() == 0;
 }
 
 void InspectorResourceContentLoader::checkDone()
 {
     if (!hasFinished())
         return;
     PersistentHeapVectorWillBeHeapVector<Member<VoidCallback> > callbacks;
     callbacks.swap(m_callbacks);
-    for (PersistentHeapVectorWillBeHeapVector<Member<VoidCallback> >::const_iterator it = callbacks.begin(); it != callbacks.end(); ++it)
-        (*it)->handleEvent();
+    for (const auto& it : callbacks)
+        it->handleEvent();
 }
 
 void InspectorResourceContentLoader::resourceFinished(ResourceClient* client)
 {
     m_pendingResourceClients.remove(client);
     checkDone();
 }
 
 } // namespace blink