Extracted NetLog class's inner enum types into their own enum classes and

net/quic/chromium/quic_connection_logger.cc

 // Copyright (c) 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/quic/chromium/quic_connection_logger.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/ip_address.h"
 #include "net/cert/x509_certificate.h"
+#include "net/log/net_log_event_type.h"
 #include "net/quic/core/crypto/crypto_handshake_message.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/quic_address_mismatch.h"
 #include "net/quic/core/quic_protocol.h"
 #include "net/quic/core/quic_socket_address_coder.h"
 #include "net/quic/core/quic_time.h"
 
 using base::StringPiece;
 using std::string;
 
@@ skipping 313 matching lines @@
 
   RecordAggregatePacketLossRate();
 }
 
 void QuicConnectionLogger::OnFrameAddedToPacket(const QuicFrame& frame) {
   switch (frame.type) {
     case PADDING_FRAME:
       break;
     case STREAM_FRAME:
       net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_SENT,
+          NetLogEventType::QUIC_SESSION_STREAM_FRAME_SENT,
           base::Bind(&NetLogQuicStreamFrameCallback, frame.stream_frame));
       break;
     case ACK_FRAME: {
       net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_ACK_FRAME_SENT,
+          NetLogEventType::QUIC_SESSION_ACK_FRAME_SENT,
           base::Bind(&NetLogQuicAckFrameCallback, frame.ack_frame));
       break;
     }
     case RST_STREAM_FRAME:
       UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeClient",
                                   frame.rst_stream_frame->error_code);
-      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_SENT,
+      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_RST_STREAM_FRAME_SENT,
                         base::Bind(&NetLogQuicRstStreamFrameCallback,
                                    frame.rst_stream_frame));
       break;
     case CONNECTION_CLOSE_FRAME:
-      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_CONNECTION_CLOSE_FRAME_SENT,
-                        base::Bind(&NetLogQuicConnectionCloseFrameCallback,
-                                   frame.connection_close_frame));
+      net_log_.AddEvent(
+                    NetLogEventType::QUIC_SESSION_CONNECTION_CLOSE_FRAME_SENT,
+                    base::Bind(&NetLogQuicConnectionCloseFrameCallback,
+                               frame.connection_close_frame));
       break;
     case GOAWAY_FRAME:
       net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_GOAWAY_FRAME_SENT,
+          NetLogEventType::QUIC_SESSION_GOAWAY_FRAME_SENT,
           base::Bind(&NetLogQuicGoAwayFrameCallback, frame.goaway_frame));
       break;
     case WINDOW_UPDATE_FRAME:
-      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_SENT,
+      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_WINDOW_UPDATE_FRAME_SENT,
                         base::Bind(&NetLogQuicWindowUpdateFrameCallback,
                                    frame.window_update_frame));
       break;
     case BLOCKED_FRAME:
       ++num_blocked_frames_sent_;
       net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_BLOCKED_FRAME_SENT,
+          NetLogEventType::QUIC_SESSION_BLOCKED_FRAME_SENT,
           base::Bind(&NetLogQuicBlockedFrameCallback, frame.blocked_frame));
       break;
     case STOP_WAITING_FRAME:
-      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_SENT,
+      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_STOP_WAITING_FRAME_SENT,
                         base::Bind(&NetLogQuicStopWaitingFrameCallback,
                                    frame.stop_waiting_frame));
       break;
     case PING_FRAME:
       UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.ConnectionFlowControlBlocked",
                             session_->IsConnectionFlowControlBlocked());
       UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.StreamFlowControlBlocked",
                             session_->IsStreamFlowControlBlocked());
       // PingFrame has no contents to log, so just record that it was sent.
-      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PING_FRAME_SENT);
+      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PING_FRAME_SENT);
       break;
     case MTU_DISCOVERY_FRAME:
       // MtuDiscoveryFrame is PingFrame on wire, it does not have any payload.
-      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_MTU_DISCOVERY_FRAME_SENT);
+      net_log_.AddEvent(
+                    NetLogEventType::QUIC_SESSION_MTU_DISCOVERY_FRAME_SENT);
       break;
     default:
       DCHECK(false) << "Illegal frame type: " << frame.type;
   }
 }
 
 void QuicConnectionLogger::OnPacketSent(
     const SerializedPacket& serialized_packet,
     QuicPathId /* original_path_id */,
     QuicPacketNumber original_packet_number,
     TransmissionType transmission_type,
     QuicTime sent_time) {
   if (original_packet_number == 0) {
     net_log_.AddEvent(
-        NetLog::TYPE_QUIC_SESSION_PACKET_SENT,
+        NetLogEventType::QUIC_SESSION_PACKET_SENT,
         base::Bind(&NetLogQuicPacketSentCallback, serialized_packet,
                    transmission_type, sent_time));
   } else {
     net_log_.AddEvent(
-        NetLog::TYPE_QUIC_SESSION_PACKET_RETRANSMITTED,
+        NetLogEventType::QUIC_SESSION_PACKET_RETRANSMITTED,
         base::Bind(&NetLogQuicPacketRetransmittedCallback,
                    original_packet_number, serialized_packet.packet_number));
   }
 }
 
 void QuicConnectionLogger::OnPacketReceived(const IPEndPoint& self_address,
                                             const IPEndPoint& peer_address,
                                             const QuicEncryptedPacket& packet) {
   if (local_address_from_self_.GetFamily() == ADDRESS_FAMILY_UNSPECIFIED) {
     local_address_from_self_ = self_address;
     UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.ConnectionTypeFromSelf",
                               GetRealAddressFamily(self_address.address()),
                               ADDRESS_FAMILY_LAST);
   }
 
   previous_received_packet_size_ = last_received_packet_size_;
   last_received_packet_size_ = packet.length();
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PACKET_RECEIVED,
                     base::Bind(&NetLogQuicPacketCallback, &self_address,
                                &peer_address, packet.length()));
 }
 
 void QuicConnectionLogger::OnUnauthenticatedHeader(
     const QuicPacketHeader& header) {
   net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED,
+      NetLogEventType::QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED,
       base::Bind(&NetLogQuicPacketHeaderCallback, &header));
 }
 
 void QuicConnectionLogger::OnIncorrectConnectionId(
     QuicConnectionId connection_id) {
   ++num_incorrect_connection_ids_;
 }
 
 void QuicConnectionLogger::OnUndecryptablePacket() {
   ++num_undecryptable_packets_;
 }
 
 void QuicConnectionLogger::OnDuplicatePacket(QuicPacketNumber packet_number) {
   net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_DUPLICATE_PACKET_RECEIVED,
+      NetLogEventType::QUIC_SESSION_DUPLICATE_PACKET_RECEIVED,
       base::Bind(&NetLogQuicDuplicatePacketCallback, packet_number));
   ++num_duplicate_packets_;
 }
 
 void QuicConnectionLogger::OnProtocolVersionMismatch(
     QuicVersion received_version) {
   // TODO(rtenneti): Add logging.
 }
 
 void QuicConnectionLogger::OnPacketHeader(const QuicPacketHeader& header) {
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PACKET_AUTHENTICATED);
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PACKET_AUTHENTICATED);
   ++num_packets_received_;
   if (largest_received_packet_number_ < header.packet_number) {
     QuicPacketNumber delta =
         header.packet_number - largest_received_packet_number_;
     if (delta > 1) {
       // There is a gap between the largest packet previously received and
       // the current packet.  This indicates either loss, or out-of-order
       // delivery.
       UMA_HISTOGRAM_COUNTS("Net.QuicSession.PacketGapReceived",
                            static_cast<base::HistogramBase::Sample>(delta - 1));
     }
     largest_received_packet_number_ = header.packet_number;
   }
   if (header.packet_number < received_packets_.size()) {
     received_packets_[static_cast<size_t>(header.packet_number)] = true;
   }
   if (header.packet_number < last_received_packet_number_) {
     ++num_out_of_order_received_packets_;
     if (previous_received_packet_size_ < last_received_packet_size_)
       ++num_out_of_order_large_received_packets_;
     UMA_HISTOGRAM_COUNTS(
         "Net.QuicSession.OutOfOrderGapReceived",
         static_cast<base::HistogramBase::Sample>(last_received_packet_number_ -
                                                  header.packet_number));
   }
   last_received_packet_number_ = header.packet_number;
 }
 
 void QuicConnectionLogger::OnStreamFrame(const QuicStreamFrame& frame) {
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED,
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_STREAM_FRAME_RECEIVED,
                     base::Bind(&NetLogQuicStreamFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnAckFrame(const QuicAckFrame& frame) {
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_ACK_FRAME_RECEIVED,
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_ACK_FRAME_RECEIVED,
                     base::Bind(&NetLogQuicAckFrameCallback, &frame));
 
   const size_t kApproximateLargestSoloAckBytes = 100;
   if (last_received_packet_number_ < received_acks_.size() &&
       last_received_packet_size_ < kApproximateLargestSoloAckBytes) {
     received_acks_[static_cast<size_t>(last_received_packet_number_)] = true;
   }
 
   if (frame.packets.Empty())
     return;
@@ skipping 32 matching lines @@
       num_consecutive_missing_packets = interval_len;
     }
     previous_missing_packet = it->max() - 1;
   }
   UpdatePacketGapSentHistogram(num_consecutive_missing_packets);
   largest_received_missing_packet_number_ = missing_packets.Max();
 }
 
 void QuicConnectionLogger::OnStopWaitingFrame(
     const QuicStopWaitingFrame& frame) {
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_RECEIVED,
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_STOP_WAITING_FRAME_RECEIVED,
                     base::Bind(&NetLogQuicStopWaitingFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeServer",
                               frame.error_code);
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_RECEIVED,
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_RST_STREAM_FRAME_RECEIVED,
                     base::Bind(&NetLogQuicRstStreamFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnConnectionCloseFrame(
     const QuicConnectionCloseFrame& frame) {
   net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_CONNECTION_CLOSE_FRAME_RECEIVED,
+      NetLogEventType::QUIC_SESSION_CONNECTION_CLOSE_FRAME_RECEIVED,
       base::Bind(&NetLogQuicConnectionCloseFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnWindowUpdateFrame(
     const QuicWindowUpdateFrame& frame) {
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_RECEIVED,
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_WINDOW_UPDATE_FRAME_RECEIVED,
                     base::Bind(&NetLogQuicWindowUpdateFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnBlockedFrame(const QuicBlockedFrame& frame) {
   ++num_blocked_frames_received_;
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_BLOCKED_FRAME_RECEIVED,
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_BLOCKED_FRAME_RECEIVED,
                     base::Bind(&NetLogQuicBlockedFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
   UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.GoAwayReceivedForConnectionMigration",
                         frame.error_code == QUIC_ERROR_MIGRATING_PORT);
 
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_GOAWAY_FRAME_RECEIVED,
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_GOAWAY_FRAME_RECEIVED,
                     base::Bind(&NetLogQuicGoAwayFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnPingFrame(const QuicPingFrame& frame) {
   // PingFrame has no contents to log, so just record that it was received.
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PING_FRAME_RECEIVED);
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PING_FRAME_RECEIVED);
 }
 
 void QuicConnectionLogger::OnPublicResetPacket(
     const QuicPublicResetPacket& packet) {
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PUBLIC_RESET_PACKET_RECEIVED);
+  net_log_.AddEvent(
+                NetLogEventType::QUIC_SESSION_PUBLIC_RESET_PACKET_RECEIVED);
   UpdatePublicResetAddressMismatchHistogram(local_address_from_shlo_,
                                             packet.client_address);
 }
 
 void QuicConnectionLogger::OnVersionNegotiationPacket(
     const QuicVersionNegotiationPacket& packet) {
   net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_VERSION_NEGOTIATION_PACKET_RECEIVED,
+      NetLogEventType::QUIC_SESSION_VERSION_NEGOTIATION_PACKET_RECEIVED,
       base::Bind(&NetLogQuicVersionNegotiationPacketCallback, &packet));
 }
 
 void QuicConnectionLogger::OnCryptoHandshakeMessageReceived(
     const CryptoHandshakeMessage& message) {
   net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_RECEIVED,
+      NetLogEventType::QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_RECEIVED,
       base::Bind(&NetLogQuicCryptoHandshakeMessageCallback, &message));
 
   if (message.tag() == kSHLO) {
     StringPiece address;
     QuicSocketAddressCoder decoder;
     if (message.GetStringPiece(kCADR, &address) &&
         decoder.Decode(address.data(), address.size())) {
       local_address_from_shlo_ = IPEndPoint(decoder.ip(), decoder.port());
       UMA_HISTOGRAM_ENUMERATION(
           "Net.QuicSession.ConnectionTypeFromPeer",
           GetRealAddressFamily(local_address_from_shlo_.address()),
           ADDRESS_FAMILY_LAST);
     }
   }
 }
 
 void QuicConnectionLogger::OnCryptoHandshakeMessageSent(
     const CryptoHandshakeMessage& message) {
   net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_SENT,
+      NetLogEventType::QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_SENT,
       base::Bind(&NetLogQuicCryptoHandshakeMessageCallback, &message));
 }
 
 void QuicConnectionLogger::OnConnectionClosed(QuicErrorCode error,
                                               const string& error_details,
                                               ConnectionCloseSource source) {
   net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_CLOSED,
+      NetLogEventType::QUIC_SESSION_CLOSED,
       base::Bind(&NetLogQuicOnConnectionClosedCallback, error, source));
 }
 
 void QuicConnectionLogger::OnSuccessfulVersionNegotiation(
     const QuicVersion& version) {
   string quic_version = QuicVersionToString(version);
-  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_VERSION_NEGOTIATED,
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_VERSION_NEGOTIATED,
                     NetLog::StringCallback("version", &quic_version));
 }
 
 void QuicConnectionLogger::UpdateReceivedFrameCounts(
     QuicStreamId stream_id,
     int num_frames_received,
     int num_duplicate_frames_received) {
   if (stream_id != kCryptoStreamId) {
     num_frames_received_ += num_frames_received;
     num_duplicate_frames_received_ += num_duplicate_frames_received;
   }
 }
 
 void QuicConnectionLogger::OnCertificateVerified(
     const CertVerifyResult& result) {
   if (result.cert_status == CERT_STATUS_INVALID) {
-    net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_CERTIFICATE_VERIFY_FAILED);
+    net_log_.AddEvent(NetLogEventType::QUIC_SESSION_CERTIFICATE_VERIFY_FAILED);
     return;
   }
   net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_CERTIFICATE_VERIFIED,
+      NetLogEventType::QUIC_SESSION_CERTIFICATE_VERIFIED,
       base::Bind(&NetLogQuicCertificateVerifiedCallback, result.verified_cert));
 }
 
 base::HistogramBase* QuicConnectionLogger::Get6PacketHistogram(
     const char* which_6) const {
   // This histogram takes a binary encoding of the 6 consecutive packets
   // received.  As a result, there are 64 possible sample-patterns.
   string prefix("Net.QuicSession.6PacketsPatternsReceived_");
   return base::LinearHistogram::FactoryGet(
       prefix + which_6 + connection_description_, 1, 64, 65,
@@ skipping 31 matching lines @@
 
   string prefix("Net.QuicSession.PacketLossRate_");
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
       prefix + connection_description_, 1, 1000, 75,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(static_cast<base::HistogramBase::Sample>(
       ReceivedPacketLossRate() * 1000));
 }
 
 }  // namespace net