Replace for each loop

net/log/net_log_util.cc

 // 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 "net/log/net_log_util.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 140 matching lines @@
 
   // Add a dictionary with information on the relationship between event type
   // enums and their symbolic names.
   constants_dict->Set("logEventTypes", NetLog::GetEventTypesAsValue());
 
   // Add a dictionary with information about the relationship between CertStatus
   // flags and their symbolic names.
   {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
-    for (size_t i = 0; i < arraysize(kCertStatusFlags); i++)
-      dict->SetInteger(kCertStatusFlags[i].name, kCertStatusFlags[i].constant);
+    for (StringToConstant flag : kCertStatusFlags) {

[eroman, 2016/11/03 14:39:43]

Please use:
   for (const auto& flag : kCertStatusFlags) {

(Avoids unnecessary copies).

+      dict->SetInteger(flag.name, flag.constant);
+    }
 
     constants_dict->Set("certStatusFlag", std::move(dict));
   }
 
   // Add a dictionary with information about the relationship between load flag
   // enums and their symbolic names.
   {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
-    for (size_t i = 0; i < arraysize(kLoadFlags); i++)
-      dict->SetInteger(kLoadFlags[i].name, kLoadFlags[i].constant);
+    for (StringToConstant flag : kLoadFlags) {
+      dict->SetInteger(flag.name, flag.constant);
+    }
 
     constants_dict->Set("loadFlag", std::move(dict));
   }
 
   // Add a dictionary with information about the relationship between load state
   // enums and their symbolic names.
   {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
-    for (size_t i = 0; i < arraysize(kLoadStateTable); i++)
-      dict->SetInteger(kLoadStateTable[i].name, kLoadStateTable[i].constant);
+    for (StringToConstant flag : kLoadStateTable) {
+      dict->SetInteger(flag.name, flag.constant);
+    }
 
     constants_dict->Set("loadState", std::move(dict));
   }
 
   {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 #define NET_INFO_SOURCE(label, string, value) \
   dict->SetInteger(string, NET_INFO_##label);
 #include "net/base/net_info_source_list.h"
 #undef NET_INFO_SOURCE
     constants_dict->Set("netInfoSources", std::move(dict));
   }
 
   // Add information on the relationship between net error codes and their
   // symbolic names.
   {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
-    for (size_t i = 0; i < arraysize(kNetErrors); i++)
-      dict->SetInteger(ErrorToShortString(kNetErrors[i]), kNetErrors[i]);
+    for (short error : kNetErrors) {

[eroman, 2016/11/03 14:39:43]

(Side-note: kNetErrors should probably be defined as an Error instead of short.
Not sure if this was done intentionally to save space...)

+      dict->SetInteger(ErrorToShortString(error), error);
+    }
 
     constants_dict->Set("netError", std::move(dict));
   }
 
   // Add information on the relationship between QUIC error codes and their
   // symbolic names.
   {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
     for (QuicErrorCode error = QUIC_NO_ERROR; error < QUIC_LAST_ERROR;
@@ skipping 18 matching lines @@
     }
 
     constants_dict->Set("quicRstStreamError", std::move(dict));
   }
 
   // Add information on the relationship between SDCH problem codes and their
   // symbolic names.
   {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
-    for (size_t i = 0; i < arraysize(kSdchProblems); i++)
-      dict->SetInteger(kSdchProblems[i].name, kSdchProblems[i].constant);
+    for (StringToConstant problem : kSdchProblems) {
+      dict->SetInteger(problem.name, problem.constant);
+    }
 
     constants_dict->Set("sdchProblemCode", std::move(dict));
   }
 
   // Information about the relationship between event phase enums and their
   // symbolic names.
   {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
     dict->SetInteger("PHASE_BEGIN", static_cast<int>(NetLogEventPhase::BEGIN));
@@ skipping 275 matching lines @@
     // fine, since GetRequestStateAsValue() ignores the capture mode.
     NetLogEntryData entry_data(
         NetLogEventType::REQUEST_ALIVE, request->net_log().source(),
         NetLogEventPhase::BEGIN, request->creation_time(), &callback);
     NetLogEntry entry(&entry_data, NetLogCaptureMode::Default());
     observer->OnAddEntry(entry);
   }
 }
 
 }  // namespace net