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

Source/core/inspector/InspectorCSSAgent.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * 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
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 464 matching lines @@
     if (m_state->getBoolean(CSSAgentState::cssAgentEnabled))
         wasEnabled();
 }
 
 void InspectorCSSAgent::flushPendingFrontendMessages()
 {
     if (!m_invalidatedDocuments.size())
         return;
     WillBeHeapHashSet<RawPtrWillBeMember<Document> > invalidatedDocuments;
     m_invalidatedDocuments.swap(&invalidatedDocuments);
-    for (WillBeHeapHashSet<RawPtrWillBeMember<Document> >::iterator it = invalidatedDocuments.begin(); it != invalidatedDocuments.end(); ++it)
-        updateActiveStyleSheets(*it, ExistingFrontendRefresh);
+    for (auto it : invalidatedDocuments)

[pfeldman, 2014/12/16 16:52:10]

Here and below:

Document* document: docs

[zhaoze.zhou, 2014/12/16 18:56:39]

Done.

+        updateActiveStyleSheets(it, ExistingFrontendRefresh);
 }
 
 void InspectorCSSAgent::reset()
 {
     m_idToInspectorStyleSheet.clear();
     m_idToInspectorStyleSheetForInlineStyle.clear();
     m_cssStyleSheetToInspectorStyleSheet.clear();
     m_documentToCSSStyleSheets.clear();
     m_invalidatedDocuments.clear();
     m_nodeToInspectorStyleSheet.clear();
@@ skipping 23 matching lines @@
 
 void InspectorCSSAgent::wasEnabled()
 {
     if (!m_state->getBoolean(CSSAgentState::cssAgentEnabled)) {
         // We were disabled while fetching resources.
         return;
     }
 
     m_instrumentingAgents->setInspectorCSSAgent(this);
     WillBeHeapVector<RawPtrWillBeMember<Document> > documents = m_domAgent->documents();
-    for (WillBeHeapVector<RawPtrWillBeMember<Document> >::iterator it = documents.begin(); it != documents.end(); ++it)
-        updateActiveStyleSheets(*it, InitialFrontendLoad);
+    for (auto it : documents)
+        updateActiveStyleSheets(it, InitialFrontendLoad);
 }
 
 void InspectorCSSAgent::disable(ErrorString*)
 {
     reset();
     m_instrumentingAgents->setInspectorCSSAgent(0);
     m_state->setBoolean(CSSAgentState::cssAgentEnabled, false);
 }
 
 void InspectorCSSAgent::didCommitLoadForMainFrame()
@@ skipping 65 matching lines @@
 
     WillBeHeapHashSet<RawPtrWillBeMember<CSSStyleSheet> >* documentCSSStyleSheets = m_documentToCSSStyleSheets.get(document);
     if (!documentCSSStyleSheets) {
         documentCSSStyleSheets = new WillBeHeapHashSet<RawPtrWillBeMember<CSSStyleSheet> >();
         OwnPtrWillBeRawPtr<WillBeHeapHashSet<RawPtrWillBeMember<CSSStyleSheet> > > documentCSSStyleSheetsPtr = adoptPtrWillBeNoop(documentCSSStyleSheets);
         m_documentToCSSStyleSheets.set(document, documentCSSStyleSheetsPtr.release());
     }
 
     WillBeHeapHashSet<RawPtrWillBeMember<CSSStyleSheet> > removedSheets(*documentCSSStyleSheets);
     WillBeHeapVector<RawPtrWillBeMember<CSSStyleSheet> > addedSheets;
-    for (WillBeHeapVector<RawPtrWillBeMember<CSSStyleSheet> >::const_iterator it = allSheetsVector.begin(); it != allSheetsVector.end(); ++it) {
-        CSSStyleSheet* cssStyleSheet = *it;
+    for (const auto& it : allSheetsVector) {

[pfeldman, 2014/12/16 16:52:10]

Here and below:

CSSStyleSheet* sheet :

[zhaoze.zhou, 2014/12/16 18:56:39]

Done.

+        CSSStyleSheet* cssStyleSheet = it;
         if (removedSheets.contains(cssStyleSheet)) {
             removedSheets.remove(cssStyleSheet);
             if (isInitialFrontendLoad)
                 addedSheets.append(cssStyleSheet);
         } else {
             addedSheets.append(cssStyleSheet);
         }
     }
 
-    for (WillBeHeapHashSet<RawPtrWillBeMember<CSSStyleSheet> >::iterator it = removedSheets.begin(); it != removedSheets.end(); ++it) {
-        CSSStyleSheet* cssStyleSheet = *it;
+    for (auto it : removedSheets) {
+        CSSStyleSheet* cssStyleSheet = it;
         RefPtrWillBeRawPtr<InspectorStyleSheet> inspectorStyleSheet = m_cssStyleSheetToInspectorStyleSheet.get(cssStyleSheet);
         ASSERT(inspectorStyleSheet);
 
         documentCSSStyleSheets->remove(cssStyleSheet);
         if (m_idToInspectorStyleSheet.contains(inspectorStyleSheet->id())) {
             String id = unbindStyleSheet(inspectorStyleSheet.get());
             if (m_frontend && !isInitialFrontendLoad)
                 m_frontend->styleSheetRemoved(id);
         }
     }
 
-    for (WillBeHeapVector<RawPtrWillBeMember<CSSStyleSheet> >::iterator it = addedSheets.begin(); it != addedSheets.end(); ++it) {
-        CSSStyleSheet* cssStyleSheet = *it;
+    for (auto it : addedSheets) {
+        CSSStyleSheet* cssStyleSheet = it;
         bool isNew = isInitialFrontendLoad || !m_cssStyleSheetToInspectorStyleSheet.contains(cssStyleSheet);
         if (isNew) {
             InspectorStyleSheet* newStyleSheet = bindStyleSheet(cssStyleSheet);
             documentCSSStyleSheets->add(cssStyleSheet);
             if (m_frontend)
                 m_frontend->styleSheetAdded(newStyleSheet->buildObjectForStyleSheetInfo());
         }
     }
 
     if (documentCSSStyleSheets->isEmpty())
@@ skipping 30 matching lines @@
     case CSSSelector::PseudoVisited:
         return forcedPseudoState & PseudoVisited;
     default:
         return false;
     }
 }
 
 void InspectorCSSAgent::getMediaQueries(ErrorString* errorString, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSMedia> >& medias)
 {
     medias = TypeBuilder::Array<TypeBuilder::CSS::CSSMedia>::create();
-    for (IdToInspectorStyleSheet::iterator it = m_idToInspectorStyleSheet.begin(); it != m_idToInspectorStyleSheet.end(); ++it) {
-        RefPtrWillBeRawPtr<InspectorStyleSheet> styleSheet = it->value;
+    for (auto it : m_idToInspectorStyleSheet) {
+        RefPtrWillBeRawPtr<InspectorStyleSheet> styleSheet = it.value;
         collectMediaQueriesFromStyleSheet(styleSheet->pageStyleSheet(), medias.get());
         const CSSRuleVector& flatRules = styleSheet->flatRules();
         for (unsigned i = 0; i < flatRules.size(); ++i) {
             CSSRule* rule = flatRules.at(i).get();
             if (rule->type() == CSSRule::MEDIA_RULE || rule->type() == CSSRule::IMPORT_RULE)
                 collectMediaQueriesFromRule(rule, medias.get());
         }
     }
 }
 
@@ skipping 150 matching lines @@
 
         if (!previous->isPseudoElement() || !previous->node()->isFirstLetterPseudoElement())
             continue;
 
         // The first-letter pseudoElement only has one child, which is the
         // first-letter renderer.
         collectPlatformFontsForRenderer(toRenderText(previous->slowFirstChild()), &fontStats);
     }
 
     platformFonts = TypeBuilder::Array<TypeBuilder::CSS::PlatformFontUsage>::create();
-    for (HashCountedSet<String>::iterator it = fontStats.begin(), end = fontStats.end(); it != end; ++it) {
+    for (auto it : fontStats) {
         RefPtr<TypeBuilder::CSS::PlatformFontUsage> platformFont = TypeBuilder::CSS::PlatformFontUsage::create()
-            .setFamilyName(it->key)
-            .setGlyphCount(it->value);
+            .setFamilyName(it.key)
+            .setGlyphCount(it.value);
         platformFonts->addItem(platformFont);
     }
 }
 
 void InspectorCSSAgent::getStyleSheetText(ErrorString* errorString, const String& styleSheetId, String* result)
 {
     InspectorStyleSheetBase* inspectorStyleSheet = assertStyleSheetForId(errorString, styleSheetId);
     if (!inspectorStyleSheet)
         return;
 
@@ skipping 392 matching lines @@
         *errorString = "Not an element node";
         return 0;
     }
     return toElement(node);
 }
 
 // static
 void InspectorCSSAgent::collectAllDocumentStyleSheets(Document* document, WillBeHeapVector<RawPtrWillBeMember<CSSStyleSheet> >& result)
 {
     const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> > activeStyleSheets = document->styleEngine()->activeStyleSheetsForInspector();
-    for (WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> >::const_iterator it = activeStyleSheets.begin(); it != activeStyleSheets.end(); ++it) {
-        CSSStyleSheet* styleSheet = it->get();
+    for (const auto& it : activeStyleSheets) {
+        CSSStyleSheet* styleSheet = it.get();
         InspectorCSSAgent::collectStyleSheets(styleSheet, result);
     }
 }
 
 // static
 void InspectorCSSAgent::collectStyleSheets(CSSStyleSheet* styleSheet, WillBeHeapVector<RawPtrWillBeMember<CSSStyleSheet> >& result)
 {
     result.append(styleSheet);
     for (unsigned i = 0, size = styleSheet->length(); i < size; ++i) {
         CSSRule* rule = styleSheet->item(i);
@@ skipping 239 matching lines @@
 
 void InspectorCSSAgent::didReparseStyleSheet()
 {
     ASSERT(m_isSettingStyleSheetText);
     m_isSettingStyleSheetText = false;
 }
 
 void InspectorCSSAgent::resetPseudoStates()
 {
     WillBeHeapHashSet<RawPtrWillBeMember<Document> > documentsToChange;
-    for (NodeIdToForcedPseudoState::iterator it = m_nodeIdToForcedPseudoState.begin(), end = m_nodeIdToForcedPseudoState.end(); it != end; ++it) {
-        Element* element = toElement(m_domAgent->nodeForId(it->key));
+    for (auto it : m_nodeIdToForcedPseudoState) {
+        Element* element = toElement(m_domAgent->nodeForId(it.key));
         if (element && element->ownerDocument())
             documentsToChange.add(element->ownerDocument());
     }
 
     m_nodeIdToForcedPseudoState.clear();
-    for (WillBeHeapHashSet<RawPtrWillBeMember<Document> >::iterator it = documentsToChange.begin(), end = documentsToChange.end(); it != end; ++it)
-        (*it)->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Inspector));
+    for (auto it : documentsToChange)
+        it->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Inspector));
 }
 
 void InspectorCSSAgent::trace(Visitor* visitor)
 {
     visitor->trace(m_domAgent);
     visitor->trace(m_pageAgent);
     visitor->trace(m_resourceAgent);
 #if ENABLE(OILPAN)
     visitor->trace(m_idToInspectorStyleSheet);
     visitor->trace(m_idToInspectorStyleSheetForInlineStyle);
     visitor->trace(m_cssStyleSheetToInspectorStyleSheet);
     visitor->trace(m_documentToCSSStyleSheets);
     visitor->trace(m_invalidatedDocuments);
     visitor->trace(m_nodeToInspectorStyleSheet);
     visitor->trace(m_documentToViaInspectorStyleSheet);
 #endif
     visitor->trace(m_inspectorUserAgentStyleSheet);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink