Make the net logging code more compact.

net/base/net_log_logger.cc

 // Copyright 2013 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/base/net_log_logger.h"
 
 #include <stdio.h>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/address_family.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 
+namespace {
+
+struct StringToConstant {
+  const char* name;
+  const int constant;
+};
+
+const StringToConstant kCertStatusFlags[] = {
+#define CERT_STATUS_FLAG(label, value) { #label, value },
+#include "net/cert/cert_status_flags_list.h"
+#undef CERT_STATUS_FLAG
+};
+
+const StringToConstant kLoadFlags[] = {
+#define LOAD_FLAG(label, value) { #label, value },
+#include "net/base/load_flags_list.h"
+#undef LOAD_FLAG
+};
+
+const StringToConstant kLoadStateTable[] = {
+#define LOAD_STATE(label) { # label, net::LOAD_STATE_ ## label },
+#include "net/base/load_states_list.h"
+#undef LOAD_STATE
+};
+
+const short kNetErrors[] = {
+#define NET_ERROR(label, value) value,
+#include "net/base/net_error_list.h"
+#undef NET_ERROR
+};
+
+}

[mmenke, 2014/09/16 14:24:29]

nit:

}  // namespace

+
 namespace net {
 
 // This should be incremented when significant changes are made that will
 // invalidate the old loading code.
 static const int kLogFormatVersion = 1;
 
 NetLogLogger::NetLogLogger(FILE* file, const base::Value& constants)
     : file_(file), log_level_(NetLog::LOG_ALL_BUT_BYTES), added_events_(false) {
   DCHECK(file);
 
@@ skipping 45 matching lines @@
 
   // Add a dictionary with information on the relationship between event type
   // enums and their symbolic names.
   constants_dict->Set("logEventTypes", net::NetLog::GetEventTypesAsValue());
 
   // Add a dictionary with information about the relationship between CertStatus
   // flags and their symbolic names.
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
-#define CERT_STATUS_FLAG(label, value) dict->SetInteger(#label, value);
-#include "net/cert/cert_status_flags_list.h"
-#undef CERT_STATUS_FLAG
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kCertStatusFlags); i++)
+      dict->SetInteger(kCertStatusFlags[i].name, kCertStatusFlags[i].constant);
 
     constants_dict->Set("certStatusFlag", dict);
   }
 
   // Add a dictionary with information about the relationship between load flag
   // enums and their symbolic names.
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
-#define LOAD_FLAG(label, value) \
-    dict->SetInteger(# label, static_cast<int>(value));
-#include "net/base/load_flags_list.h"
-#undef LOAD_FLAG
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kLoadFlags); i++)
+      dict->SetInteger(kLoadFlags[i].name, kLoadFlags[i].constant);
 
     constants_dict->Set("loadFlag", dict);
   }
 
   // Add a dictionary with information about the relationship between load state
   // enums and their symbolic names.
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
-#define LOAD_STATE(label) \
-    dict->SetInteger(# label, net::LOAD_STATE_ ## label);
-#include "net/base/load_states_list.h"
-#undef LOAD_STATE
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kLoadStateTable); i++)
+      dict->SetInteger(kLoadStateTable[i].name, kLoadStateTable[i].constant);
 
     constants_dict->Set("loadState", dict);
   }
 
   // Add information on the relationship between net error codes and their
   // symbolic names.
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
-#define NET_ERROR(label, value) \
-    dict->SetInteger(ErrorToShortString(value), static_cast<int>(value));
-#include "net/base/net_error_list.h"
-#undef NET_ERROR
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kNetErrors); i++)
+      dict->SetInteger(ErrorToShortString(kNetErrors[i]), kNetErrors[i]);
 
     constants_dict->Set("netError", dict);
   }
 
   // Add information on the relationship between QUIC error codes and their
   // symbolic names.
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
     for (net::QuicErrorCode error = net::QUIC_NO_ERROR;
@@ skipping 90 matching lines @@
   }
 
   // "clientInfo" key is required for some NetLogLogger log readers.
   // Provide a default empty value for compatibility.
   constants_dict->Set("clientInfo", new base::DictionaryValue());
 
   return constants_dict;
 }
 
 }  // namespace net