// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/quic/quic_event_logger.h"

#include "base/containers/span.h"
#include "base/strings/string_number_conversions.h"
#include "net/cert/x509_certificate.h"
#include "net/log/net_log_values.h"
#include "net/quic/address_utils.h"
#include "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_protocol.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_socket_address_coder.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"

namespace net {

namespace {

base::Value::Dict NetLogQuicPacketParams(
    const quic::QuicSocketAddress& self_address,
    const quic::QuicSocketAddress& peer_address,
    size_t packet_size) {
  return base::Value::Dict()
      .Set("self_address", self_address.ToString())
      .Set("peer_address", peer_address.ToString())
      .Set("size", static_cast<int>(packet_size));
}

base::Value::Dict NetLogQuicPacketSentParams(
    quic::QuicPacketNumber packet_number,
    quic::QuicPacketLength packet_length,
    quic::TransmissionType transmission_type,
    quic::EncryptionLevel encryption_level,
    quic::QuicTime sent_time,
    uint32_t batch_id) {
  return base::Value::Dict()
      .Set("transmission_type",
           quic::TransmissionTypeToString(transmission_type))
      .Set("packet_number", NetLogNumberValue(packet_number.ToUint64()))
      .Set("size", packet_length)
      .Set("sent_time_us", NetLogNumberValue(sent_time.ToDebuggingValue()))
      .Set("encryption_level", quic::EncryptionLevelToString(encryption_level))
      .Set("batch_id", NetLogNumberValue(batch_id));
}

base::Value::Dict NetLogQuicPacketLostParams(
    quic::QuicPacketNumber packet_number,
    quic::TransmissionType transmission_type,
    quic::QuicTime detection_time) {
  return base::Value::Dict()
      .Set("transmission_type",
           quic::TransmissionTypeToString(transmission_type))
      .Set("packet_number", NetLogNumberValue(packet_number.ToUint64()))
      .Set("detection_time_us",
           NetLogNumberValue(detection_time.ToDebuggingValue()));
}

base::Value::Dict NetLogQuicConfigProcessed(
    const quic::QuicSentPacketManager::DebugDelegate::SendParameters&
        parameters) {
  return base::Value::Dict()
      .Set("congestion_control_type", quic::CongestionControlTypeToString(
                                          parameters.congestion_control_type))
      .Set("use_pacing", parameters.use_pacing)
      .Set("initial_congestion_window",
           NetLogNumberValue(parameters.initial_congestion_window));
}

base::Value::Dict NetLogQuicDuplicatePacketParams(
    quic::QuicPacketNumber packet_number) {
  return base::Value::Dict().Set("packet_number",
                                 NetLogNumberValue(packet_number.ToUint64()));
}

base::Value::Dict NetLogReceivedQuicPacketHeaderParams(
    const quic::QuicPacketHeader& header,
    const quic::ParsedQuicVersion& session_version,
    const quic::QuicConnectionId& connection_id,
    const quic::QuicConnectionId& client_connection_id) {
  base::Value::Dict dict;
  quic::ParsedQuicVersion version = session_version;
  if (header.version_flag &&
      header.version != quic::ParsedQuicVersion::Unsupported()) {
    version = header.version;
    if (version != session_version) {
      dict.Set("version", quic::ParsedQuicVersionToString(version));
    }
  }
  dict.Set("connection_id", connection_id.ToString());
  if (!client_connection_id.IsEmpty()) {
    dict.Set("client_connection_id", client_connection_id.ToString());
  }
  if (header.destination_connection_id_included ==
          quic::CONNECTION_ID_PRESENT &&
      header.destination_connection_id != client_connection_id &&
      !header.destination_connection_id.IsEmpty()) {
    dict.Set("destination_connection_id",
             header.destination_connection_id.ToString());
  }
  if (header.source_connection_id_included == quic::CONNECTION_ID_PRESENT &&
      header.source_connection_id != connection_id &&
      !header.source_connection_id.IsEmpty()) {
    dict.Set("source_connection_id", header.source_connection_id.ToString());
  }
  dict.Set("packet_number", NetLogNumberValue(header.packet_number.ToUint64()));
  dict.Set("header_format", quic::PacketHeaderFormatToString(header.form));
  if (header.form == quic::IETF_QUIC_LONG_HEADER_PACKET) {
    dict.Set("long_header_type",
             quic::QuicLongHeaderTypeToString(header.long_packet_type));
  }
  return dict;
}

base::Value::Dict NetLogQuicStreamFrameParams(
    const quic::QuicStreamFrame& frame) {
  return base::Value::Dict()
      .Set("stream_id", static_cast<int>(frame.stream_id))
      .Set("fin", frame.fin)
      .Set("offset", NetLogNumberValue(frame.offset))
      .Set("length", frame.data_length);
}

base::Value::Dict NetLogQuicAckFrameParams(const quic::QuicAckFrame* frame) {
  base::Value::List missing;
  quic::QuicPacketNumber smallest_observed;
  if (!frame->packets.Empty()) {
    // V34 and above express acked packets, but only print
    // missing packets, because it's typically a shorter list.
    smallest_observed = frame->packets.Min();
    for (quic::QuicPacketNumber packet = smallest_observed;
         packet < frame->largest_acked; ++packet) {
      if (!frame->packets.Contains(packet)) {
        missing.Append(NetLogNumberValue(packet.ToUint64()));
      }
    }
  } else {
    smallest_observed = frame->largest_acked;
  }

  base::Value::List received;
  for (const auto& packet_time : frame->received_packet_times) {
    received.Append(
        base::Value::Dict()
            .Set("packet_number",
                 NetLogNumberValue(packet_time.first.ToUint64()))
            .Set("received",
                 NetLogNumberValue(packet_time.second.ToDebuggingValue())));
  }

  base::Value::Dict rv;
  rv.Set("largest_observed",
         NetLogNumberValue(frame->largest_acked.ToUint64()));
  rv.Set("delta_time_largest_observed_us",
         NetLogNumberValue(frame->ack_delay_time.ToMicroseconds()));
  rv.Set("smallest_observed", NetLogNumberValue(smallest_observed.ToUint64()));
  rv.Set("missing_packets", std::move(missing));
  rv.Set("received_packet_times", std::move(received));
  if (frame->ecn_counters.has_value()) {
    rv.Set("ECT0", NetLogNumberValue(frame->ecn_counters->ect0));
    rv.Set("ECT1", NetLogNumberValue(frame->ecn_counters->ect1));
    rv.Set("CE", NetLogNumberValue(frame->ecn_counters->ce));
  }
  return rv;
}

base::Value::Dict NetLogQuicRstStreamFrameParams(
    const quic::QuicRstStreamFrame* frame) {
  return base::Value::Dict()
      .Set("stream_id", static_cast<int>(frame->stream_id))
      .Set("quic_rst_stream_error", static_cast<int>(frame->error_code))
      .Set("ietf_error_code", static_cast<int>(frame->ietf_error_code))
      .Set("offset", NetLogNumberValue(frame->byte_offset));
}

base::Value::Dict NetLogQuicConnectionCloseFrameParams(
    const quic::QuicConnectionCloseFrame* frame) {
  base::Value::Dict dict;
  dict.Set("quic_error", static_cast<int>(frame->quic_error_code));
  if (frame->wire_error_code != frame->quic_error_code) {
    dict.Set("quic_wire_error", static_cast<int>(frame->wire_error_code));
  }
  std::string close_type;
  switch (frame->close_type) {
    case quic::GOOGLE_QUIC_CONNECTION_CLOSE:
      close_type = "gQUIC";
      break;
    case quic::IETF_QUIC_TRANSPORT_CONNECTION_CLOSE:
      close_type = "Transport";
      break;
    case quic::IETF_QUIC_APPLICATION_CONNECTION_CLOSE:
      close_type = "Application";
      break;
  }
  dict.Set("close_type", close_type);
  if (frame->transport_close_frame_type != 0) {
    dict.Set("transport_close_frame_type",
             NetLogNumberValue(frame->transport_close_frame_type));
  }
  dict.Set("details", frame->error_details);
  return dict;
}

base::Value::Dict NetLogQuicWindowUpdateFrameParams(
    const quic::QuicWindowUpdateFrame& frame) {
  return base::Value::Dict()
      .Set("stream_id", static_cast<int>(frame.stream_id))
      .Set("byte_offset", NetLogNumberValue(frame.max_data));
}

base::Value::Dict NetLogQuicBlockedFrameParams(
    const quic::QuicBlockedFrame& frame) {
  return base::Value::Dict().Set("stream_id",
                                 static_cast<int>(frame.stream_id));
}

base::Value::Dict NetLogQuicGoAwayFrameParams(
    const quic::QuicGoAwayFrame* frame) {
  return base::Value::Dict()
      .Set("quic_error", static_cast<int>(frame->error_code))
      .Set("last_good_stream_id", static_cast<int>(frame->last_good_stream_id))
      .Set("reason_phrase", frame->reason_phrase);
}

base::Value::Dict NetLogQuicStopWaitingFrameParams(
    const quic::QuicStopWaitingFrame* frame) {
  return base::Value::Dict().Set(
      "least_unacked", NetLogNumberValue(frame->least_unacked.ToUint64()));
}

base::Value::Dict NetLogQuicVersionNegotiationPacketParams(
    const quic::QuicVersionNegotiationPacket* packet) {
  base::Value::List versions;
  for (const auto& version : packet->versions) {
    versions.Append(ParsedQuicVersionToString(version));
  }
  return base::Value::Dict().Set("versions", std::move(versions));
}

base::Value::Dict NetLogQuicPathData(const quic::QuicPathFrameBuffer& buffer) {
  return base::Value::Dict().Set("data", NetLogBinaryValue(buffer));
}

base::Value::Dict NetLogQuicCryptoHandshakeMessageParams(
    const quic::CryptoHandshakeMessage* message) {
  return base::Value::Dict().Set("quic_crypto_handshake_message",
                                 message->DebugString());
}

base::Value::Dict NetLogQuicTransportParametersParams(
    const quic::TransportParameters& transport_parameters) {
  return base::Value::Dict().Set("quic_transport_parameters",
                                 transport_parameters.ToString());
}

base::Value::Dict NetLogQuicZeroRttRejectReason(int reason) {
  base::Value::Dict dict;
  const char* reason_detail = SSL_early_data_reason_string(
      static_cast<ssl_early_data_reason_t>(reason));
  if (reason_detail) {
    dict.Set("reason", reason_detail);
  } else {
    dict.Set("reason", "Unknown reason " + base::NumberToString(reason));
  }
  return dict;
}

base::Value::Dict NetLogQuicOnConnectionClosedParams(
    quic::QuicErrorCode error,
    std::string error_details,
    quic::ConnectionCloseSource source) {
  return base::Value::Dict()
      .Set("quic_error", static_cast<int>(error))
      .Set("details", error_details)
      .Set("from_peer",
           source == quic::ConnectionCloseSource::FROM_PEER ? true : false);
}

base::Value::Dict NetLogQuicCertificateVerifiedParams(
    scoped_refptr<X509Certificate> cert) {
  // Only the subjects are logged so that we can investigate connection pooling.
  // More fields could be logged in the future.
  std::vector<std::string> dns_names;
  cert->GetSubjectAltName(&dns_names, nullptr);
  base::Value::List subjects;
  for (auto& dns_name : dns_names) {
    subjects.Append(std::move(dns_name));
  }
  return base::Value::Dict().Set("subjects", std::move(subjects));
}

base::Value::Dict NetLogQuicCryptoFrameParams(
    const quic::QuicCryptoFrame* frame,
    bool has_buffer) {
  auto dict =
      base::Value::Dict()
          .Set("encryption_level", quic::EncryptionLevelToString(frame->level))
          .Set("data_length", frame->data_length)
          .Set("offset", NetLogNumberValue(frame->offset));
  if (has_buffer) {
    dict.Set("bytes", NetLogBinaryValue(
                          reinterpret_cast<const void*>(frame->data_buffer),
                          frame->data_length));
  }
  return dict;
}

base::Value::Dict NetLogQuicStopSendingFrameParams(
    const quic::QuicStopSendingFrame& frame) {
  return base::Value::Dict()
      .Set("stream_id", static_cast<int>(frame.stream_id))
      .Set("quic_rst_stream_error", static_cast<int>(frame.error_code))
      .Set("ietf_error_code", static_cast<int>(frame.ietf_error_code));
}

base::Value::Dict NetLogQuicStreamsBlockedFrameParams(
    const quic::QuicStreamsBlockedFrame& frame) {
  return base::Value::Dict()
      .Set("stream_count", static_cast<int>(frame.stream_count))
      .Set("is_unidirectional", frame.unidirectional);
}

base::Value::Dict NetLogQuicMaxStreamsFrameParams(
    const quic::QuicMaxStreamsFrame& frame) {
  return base::Value::Dict()
      .Set("stream_count", static_cast<int>(frame.stream_count))
      .Set("is_unidirectional", frame.unidirectional);
}

base::Value::Dict NetLogQuicNewConnectionIdFrameParams(
    const quic::QuicNewConnectionIdFrame* frame) {
  return base::Value::Dict()
      .Set("connection_id", frame->connection_id.ToString())
      .Set("sequence_number", NetLogNumberValue(frame->sequence_number))
      .Set("retire_prior_to", NetLogNumberValue(frame->retire_prior_to));
}

base::Value::Dict NetLogQuicRetireConnectionIdFrameParams(
    const quic::QuicRetireConnectionIdFrame* frame) {
  return base::Value::Dict().Set("sequence_number",
                                 NetLogNumberValue(frame->sequence_number));
}

base::Value::Dict NetLogQuicNewTokenFrameParams(
    const quic::QuicNewTokenFrame* frame) {
  return base::Value::Dict().Set(
      "token",
      NetLogBinaryValue(reinterpret_cast<const void*>(frame->token.data()),
                        frame->token.length()));
}

}  // namespace

QuicEventLogger::QuicEventLogger(quic::QuicSession* session,
                                 const NetLogWithSource& net_log)
    : session_(session), net_log_(net_log) {}

void QuicEventLogger::OnFrameAddedToPacket(const quic::QuicFrame& frame) {
  if (!net_log_.IsCapturing())
    return;
  switch (frame.type) {
    case quic::PADDING_FRAME:
      net_log_.AddEventWithIntParams(
          NetLogEventType::QUIC_SESSION_PADDING_FRAME_SENT, "num_padding_bytes",
          frame.padding_frame.num_padding_bytes);
      break;
    case quic::STREAM_FRAME:
      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_STREAM_FRAME_SENT, [&] {
        return NetLogQuicStreamFrameParams(frame.stream_frame);
      });
      break;
    case quic::ACK_FRAME: {
      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_ACK_FRAME_SENT, [&] {
        return NetLogQuicAckFrameParams(frame.ack_frame);
      });
      break;
    }
    case quic::RST_STREAM_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_RST_STREAM_FRAME_SENT, [&] {
            return NetLogQuicRstStreamFrameParams(frame.rst_stream_frame);
          });
      break;
    case quic::CONNECTION_CLOSE_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_CONNECTION_CLOSE_FRAME_SENT, [&] {
            return NetLogQuicConnectionCloseFrameParams(
                frame.connection_close_frame);
          });
      break;
    case quic::GOAWAY_FRAME:
      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_GOAWAY_FRAME_SENT, [&] {
        return NetLogQuicGoAwayFrameParams(frame.goaway_frame);
      });
      break;
    case quic::WINDOW_UPDATE_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_WINDOW_UPDATE_FRAME_SENT, [&] {
            return NetLogQuicWindowUpdateFrameParams(frame.window_update_frame);
          });
      break;
    case quic::BLOCKED_FRAME:
      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_BLOCKED_FRAME_SENT, [&] {
        return NetLogQuicBlockedFrameParams(frame.blocked_frame);
      });
      break;
    case quic::STOP_WAITING_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_STOP_WAITING_FRAME_SENT, [&] {
            return NetLogQuicStopWaitingFrameParams(&frame.stop_waiting_frame);
          });
      break;
    case quic::PING_FRAME:
      // PingFrame has no contents to log, so just record that it was sent.
      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PING_FRAME_SENT);
      break;
    case quic::MTU_DISCOVERY_FRAME:
      // MtuDiscoveryFrame is PingFrame on wire, it does not have any payload.
      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_MTU_DISCOVERY_FRAME_SENT);
      break;
    case quic::NEW_CONNECTION_ID_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_NEW_CONNECTION_ID_FRAME_SENT, [&] {
            return NetLogQuicNewConnectionIdFrameParams(
                frame.new_connection_id_frame);
          });
      break;
    case quic::MAX_STREAMS_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_MAX_STREAMS_FRAME_SENT, [&] {
            return NetLogQuicMaxStreamsFrameParams(frame.max_streams_frame);
          });
      break;
    case quic::STREAMS_BLOCKED_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_STREAMS_BLOCKED_FRAME_SENT, [&] {
            return NetLogQuicStreamsBlockedFrameParams(
                frame.streams_blocked_frame);
          });
      break;
    case quic::PATH_RESPONSE_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_PATH_RESPONSE_FRAME_SENT, [&] {
            return NetLogQuicPathData(frame.path_response_frame.data_buffer);
          });
      break;
    case quic::PATH_CHALLENGE_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_PATH_CHALLENGE_FRAME_SENT, [&] {
            return NetLogQuicPathData(frame.path_challenge_frame.data_buffer);
          });
      break;
    case quic::STOP_SENDING_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_STOP_SENDING_FRAME_SENT, [&] {
            return NetLogQuicStopSendingFrameParams(frame.stop_sending_frame);
          });
      break;
    case quic::MESSAGE_FRAME:
      net_log_.AddEventWithIntParams(
          NetLogEventType::QUIC_SESSION_MESSAGE_FRAME_SENT, "message_length",
          frame.message_frame->message_length);
      break;
    case quic::CRYPTO_FRAME:
      net_log_.AddEvent(NetLogEventType::QUIC_SESSION_CRYPTO_FRAME_SENT, [&] {
        return NetLogQuicCryptoFrameParams(frame.crypto_frame,
                                           /*has_buffer = */ false);
      });
      break;
    case quic::NEW_TOKEN_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_NEW_TOKEN_FRAME_SENT,
          [&] { return NetLogQuicNewTokenFrameParams(frame.new_token_frame); });
      break;
    case quic::RETIRE_CONNECTION_ID_FRAME:
      net_log_.AddEvent(
          NetLogEventType::QUIC_SESSION_RETIRE_CONNECTION_ID_FRAME_SENT, [&] {
            return NetLogQuicRetireConnectionIdFrameParams(
                frame.retire_connection_id_frame);
          });
      break;
    default:
      DCHECK(false) << "Illegal frame type: " << frame.type;
  }
}

void QuicEventLogger::OnStreamFrameCoalesced(
    const quic::QuicStreamFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_STREAM_FRAME_COALESCED,
                    [&] { return NetLogQuicStreamFrameParams(frame); });
}

void QuicEventLogger::OnPacketSent(
    quic::QuicPacketNumber packet_number,
    quic::QuicPacketLength packet_length,
    bool /*has_crypto_handshake*/,
    quic::TransmissionType transmission_type,
    quic::EncryptionLevel encryption_level,
    const quic::QuicFrames& /*retransmittable_frames*/,
    const quic::QuicFrames& /*nonretransmittable_frames*/,
    quic::QuicTime sent_time,
    uint32_t batch_id) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PACKET_SENT, [&] {
    return NetLogQuicPacketSentParams(packet_number, packet_length,
                                      transmission_type, encryption_level,
                                      sent_time, batch_id);
  });
}

void QuicEventLogger::OnIncomingAck(
    quic::QuicPacketNumber ack_packet_number,
    quic::EncryptionLevel /*ack_decrypted_level*/,
    const quic::QuicAckFrame& frame,
    quic::QuicTime ack_receive_time,
    quic::QuicPacketNumber largest_observed,
    bool rtt_updated,
    quic::QuicPacketNumber least_unacked_sent_packet) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_ACK_FRAME_RECEIVED,
                    [&] { return NetLogQuicAckFrameParams(&frame); });
}

void QuicEventLogger::OnPacketLoss(quic::QuicPacketNumber lost_packet_number,
                                   quic::EncryptionLevel /*encryption_level*/,
                                   quic::TransmissionType transmission_type,
                                   quic::QuicTime detection_time) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PACKET_LOST, [&] {
    return NetLogQuicPacketLostParams(lost_packet_number, transmission_type,
                                      detection_time);
  });
}

void QuicEventLogger::OnConfigProcessed(
    const quic::QuicSentPacketManager::DebugDelegate::SendParameters&
        parameters) {
  net_log_.AddEvent(NetLogEventType::QUIC_CONGESTION_CONTROL_CONFIGURED,
                    [&] { return NetLogQuicConfigProcessed(parameters); });
}

void QuicEventLogger::OnPacketReceived(
    const quic::QuicSocketAddress& self_address,
    const quic::QuicSocketAddress& peer_address,
    const quic::QuicEncryptedPacket& packet) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PACKET_RECEIVED, [&] {
    return NetLogQuicPacketParams(self_address, peer_address, packet.length());
  });
}

void QuicEventLogger::OnUnauthenticatedHeader(
    const quic::QuicPacketHeader& header) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED,
      [&] {
        return NetLogReceivedQuicPacketHeaderParams(
            header, session_->version(),
            session_->connection()->connection_id(),
            session_->connection()->client_connection_id());
      });
}

void QuicEventLogger::OnUndecryptablePacket(
    quic::EncryptionLevel decryption_level,
    bool dropped) {
  if (dropped) {
    net_log_.AddEventWithStringParams(
        NetLogEventType::QUIC_SESSION_DROPPED_UNDECRYPTABLE_PACKET,
        "encryption_level", quic::EncryptionLevelToString(decryption_level));
    return;
  }
  net_log_.AddEventWithStringParams(
      NetLogEventType::QUIC_SESSION_BUFFERED_UNDECRYPTABLE_PACKET,
      "encryption_level", quic::EncryptionLevelToString(decryption_level));
}

void QuicEventLogger::OnAttemptingToProcessUndecryptablePacket(
    quic::EncryptionLevel decryption_level) {
  net_log_.AddEventWithStringParams(
      NetLogEventType::QUIC_SESSION_ATTEMPTING_TO_PROCESS_UNDECRYPTABLE_PACKET,
      "encryption_level", quic::EncryptionLevelToString(decryption_level));
}

void QuicEventLogger::OnDuplicatePacket(quic::QuicPacketNumber packet_number) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_DUPLICATE_PACKET_RECEIVED,
      [&] { return NetLogQuicDuplicatePacketParams(packet_number); });
}

void QuicEventLogger::OnPacketHeader(const quic::QuicPacketHeader& header,
                                     quic::QuicTime /*receive_time*/,
                                     quic::EncryptionLevel /*level*/) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PACKET_AUTHENTICATED);
}

void QuicEventLogger::OnStreamFrame(const quic::QuicStreamFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_STREAM_FRAME_RECEIVED,
                    [&] { return NetLogQuicStreamFrameParams(frame); });
}

void QuicEventLogger::OnPathChallengeFrame(
    const quic::QuicPathChallengeFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PATH_CHALLENGE_FRAME_RECEIVED,
                    [&] { return NetLogQuicPathData(frame.data_buffer); });
}

void QuicEventLogger::OnPathResponseFrame(
    const quic::QuicPathResponseFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PATH_RESPONSE_FRAME_RECEIVED,
                    [&] { return NetLogQuicPathData(frame.data_buffer); });
}

void QuicEventLogger::OnCryptoFrame(const quic::QuicCryptoFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_CRYPTO_FRAME_RECEIVED, [&] {
    return NetLogQuicCryptoFrameParams(&frame, /*has_buffer = */ true);
  });
}

void QuicEventLogger::OnStopSendingFrame(
    const quic::QuicStopSendingFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_STOP_SENDING_FRAME_RECEIVED,
                    [&] { return NetLogQuicStopSendingFrameParams(frame); });
}

void QuicEventLogger::OnStreamsBlockedFrame(
    const quic::QuicStreamsBlockedFrame& frame) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_STREAMS_BLOCKED_FRAME_RECEIVED,
      [&] { return NetLogQuicStreamsBlockedFrameParams(frame); });
}

void QuicEventLogger::OnMaxStreamsFrame(
    const quic::QuicMaxStreamsFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_MAX_STREAMS_FRAME_RECEIVED,
                    [&] { return NetLogQuicMaxStreamsFrameParams(frame); });
}

void QuicEventLogger::OnRstStreamFrame(const quic::QuicRstStreamFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_RST_STREAM_FRAME_RECEIVED,
                    [&] { return NetLogQuicRstStreamFrameParams(&frame); });
}

void QuicEventLogger::OnConnectionCloseFrame(
    const quic::QuicConnectionCloseFrame& frame) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_CONNECTION_CLOSE_FRAME_RECEIVED,
      [&] { return NetLogQuicConnectionCloseFrameParams(&frame); });
}

void QuicEventLogger::OnWindowUpdateFrame(
    const quic::QuicWindowUpdateFrame& frame,
    const quic::QuicTime& receive_time) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_WINDOW_UPDATE_FRAME_RECEIVED,
                    [&] { return NetLogQuicWindowUpdateFrameParams(frame); });
}

void QuicEventLogger::OnBlockedFrame(const quic::QuicBlockedFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_BLOCKED_FRAME_RECEIVED,
                    [&] { return NetLogQuicBlockedFrameParams(frame); });
}

void QuicEventLogger::OnGoAwayFrame(const quic::QuicGoAwayFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_GOAWAY_FRAME_RECEIVED,
                    [&] { return NetLogQuicGoAwayFrameParams(&frame); });
}

void QuicEventLogger::OnPingFrame(
    const quic::QuicPingFrame& frame,
    quic::QuicTime::Delta /*ping_received_delay*/) {
  // PingFrame has no contents to log, so just record that it was received.
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PING_FRAME_RECEIVED);
}

void QuicEventLogger::OnPaddingFrame(const quic::QuicPaddingFrame& frame) {
  net_log_.AddEventWithIntParams(
      NetLogEventType::QUIC_SESSION_PADDING_FRAME_RECEIVED, "num_padding_bytes",
      frame.num_padding_bytes);
}

void QuicEventLogger::OnNewConnectionIdFrame(
    const quic::QuicNewConnectionIdFrame& frame) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_NEW_CONNECTION_ID_FRAME_RECEIVED,
      [&] { return NetLogQuicNewConnectionIdFrameParams(&frame); });
}

void QuicEventLogger::OnNewTokenFrame(const quic::QuicNewTokenFrame& frame) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_NEW_TOKEN_FRAME_RECEIVED,
                    [&] { return NetLogQuicNewTokenFrameParams(&frame); });
}

void QuicEventLogger::OnRetireConnectionIdFrame(
    const quic::QuicRetireConnectionIdFrame& frame) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_RETIRE_CONNECTION_ID_FRAME_RECEIVED,
      [&] { return NetLogQuicRetireConnectionIdFrameParams(&frame); });
}

void QuicEventLogger::OnMessageFrame(const quic::QuicMessageFrame& frame) {
  net_log_.AddEventWithIntParams(
      NetLogEventType::QUIC_SESSION_MESSAGE_FRAME_RECEIVED, "message_length",
      frame.message_length);
}

void QuicEventLogger::OnHandshakeDoneFrame(
    const quic::QuicHandshakeDoneFrame& frame) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_HANDSHAKE_DONE_FRAME_RECEIVED);
}

void QuicEventLogger::OnCoalescedPacketSent(
    const quic::QuicCoalescedPacket& coalesced_packet,
    size_t length) {
  net_log_.AddEventWithStringParams(
      NetLogEventType::QUIC_SESSION_COALESCED_PACKET_SENT, "info",
      coalesced_packet.ToString(length));
}

void QuicEventLogger::OnVersionNegotiationPacket(
    const quic::QuicVersionNegotiationPacket& packet) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_VERSION_NEGOTIATION_PACKET_RECEIVED,
      [&] { return NetLogQuicVersionNegotiationPacketParams(&packet); });
}

void QuicEventLogger::OnCryptoHandshakeMessageReceived(
    const quic::CryptoHandshakeMessage& message) {
  if (message.tag() == quic::kSHLO) {
    std::string_view address;
    quic::QuicSocketAddressCoder decoder;
    if (message.GetStringPiece(quic::kCADR, &address) &&
        decoder.Decode(address.data(), address.size())) {
      local_address_from_shlo_ =
          IPEndPoint(ToIPAddress(decoder.ip()), decoder.port());
    }
  }

  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_RECEIVED,
      [&] { return NetLogQuicCryptoHandshakeMessageParams(&message); });
}

void QuicEventLogger::OnCryptoHandshakeMessageSent(
    const quic::CryptoHandshakeMessage& message) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_SENT,
      [&] { return NetLogQuicCryptoHandshakeMessageParams(&message); });
}

void QuicEventLogger::OnConnectionClosed(
    const quic::QuicConnectionCloseFrame& frame,
    quic::ConnectionCloseSource source) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_CLOSED, [&] {
    return NetLogQuicOnConnectionClosedParams(frame.quic_error_code,
                                              frame.error_details, source);
  });
}

void QuicEventLogger::OnSuccessfulVersionNegotiation(
    const quic::ParsedQuicVersion& version) {
  if (!net_log_.IsCapturing())
    return;
  std::string quic_version = quic::ParsedQuicVersionToString(version);
  net_log_.AddEventWithStringParams(
      NetLogEventType::QUIC_SESSION_VERSION_NEGOTIATED, "version",
      quic_version);
}

void QuicEventLogger::OnCertificateVerified(const CertVerifyResult& result) {
  if (result.cert_status == CERT_STATUS_INVALID) {
    net_log_.AddEvent(NetLogEventType::QUIC_SESSION_CERTIFICATE_VERIFY_FAILED);
    return;
  }
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_CERTIFICATE_VERIFIED, [&] {
    return NetLogQuicCertificateVerifiedParams(result.verified_cert);
  });
}

void QuicEventLogger::OnTransportParametersSent(
    const quic::TransportParameters& transport_parameters) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_TRANSPORT_PARAMETERS_SENT, [&] {
        return NetLogQuicTransportParametersParams(transport_parameters);
      });
}

void QuicEventLogger::OnTransportParametersReceived(
    const quic::TransportParameters& transport_parameters) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_TRANSPORT_PARAMETERS_RECEIVED, [&] {
        return NetLogQuicTransportParametersParams(transport_parameters);
      });
}

void QuicEventLogger::OnTransportParametersResumed(
    const quic::TransportParameters& transport_parameters) {
  net_log_.AddEvent(
      NetLogEventType::QUIC_SESSION_TRANSPORT_PARAMETERS_RESUMED, [&] {
        return NetLogQuicTransportParametersParams(transport_parameters);
      });
}

void QuicEventLogger::OnZeroRttRejected(int reason) {
  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_ZERO_RTT_REJECTED,
                    [reason] { return NetLogQuicZeroRttRejectReason(reason); });
}

void QuicEventLogger::OnEncryptedClientHelloSent(
    std::string_view client_hello) {
  net_log_.AddEvent(NetLogEventType::SSL_ENCRYPTED_CLIENT_HELLO, [&] {
    return base::Value::Dict().Set(
        "bytes", NetLogBinaryValue(base::as_byte_span(client_hello)));
  });
}

}  // namespace net