Add rtc event generic packet sent and received.

Bug: webrtc:9719
Change-Id: I2f692d9c1b33ac390975a9e695c7652cdc1b1e6e
Reviewed-on: https://webrtc-review.googlesource.com/c/121680
Commit-Queue: Peter Slatala <psla@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Bjorn Mellem <mellem@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26616}

logging/BUILD.gn

@@ -114,6 +114,24 @@ rtc_source_set("rtc_event_bwe") {
   ]
 }
 
+rtc_source_set("rtc_event_generic_packet_events") {
+  visibility = [ "*" ]
+  sources = [
+    "rtc_event_log/events/rtc_event_generic_ack_received.cc",
+    "rtc_event_log/events/rtc_event_generic_ack_received.h",
+    "rtc_event_log/events/rtc_event_generic_packet_received.cc",
+    "rtc_event_log/events/rtc_event_generic_packet_received.h",
+    "rtc_event_log/events/rtc_event_generic_packet_sent.cc",
+    "rtc_event_log/events/rtc_event_generic_packet_sent.h",
+  ]
+  deps = [
+    ":rtc_event_log_api",
+  ]
+  if (!build_with_chromium && is_clang) {
+    suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
+  }
+}
+
 rtc_source_set("rtc_event_rtp_rtcp") {
   sources = [
     "rtc_event_log/events/rtc_event_rtcp_packet_incoming.cc",
@@ -186,6 +204,7 @@ rtc_static_library("rtc_event_log_impl_encoder") {
       ":ice_log",
       ":rtc_event_audio",
       ":rtc_event_bwe",
+      ":rtc_event_generic_packet_events",
       ":rtc_event_log2_proto",
       ":rtc_event_log_api",
       ":rtc_event_log_impl_output",
@@ -205,6 +224,10 @@ rtc_static_library("rtc_event_log_impl_encoder") {
       "rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc",
       "rtc_event_log/encoder/rtc_event_log_encoder_new_format.h",
     ]
+
+    if (!build_with_chromium && is_clang) {
+      suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
+    }
   }
 }
 

logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc

@@ -362,6 +362,10 @@ std::string RtcEventLogEncoderLegacy::Encode(const RtcEvent& event) {
           static_cast<const RtcEventVideoSendStreamConfig&>(event);
       return EncodeVideoSendStreamConfig(rtc_event);
     }
+    case RtcEvent::Type::GenericPacketReceived:
+    case RtcEvent::Type::GenericPacketSent:
+    case RtcEvent::Type::GenericAckReceived:
+      RTC_NOTREACHED();
   }
 
   int event_type = static_cast<int>(event.GetType());

logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc

@@ -24,6 +24,9 @@
 #include "logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h"
 #include "logging/rtc_event_log/events/rtc_event_dtls_transport_state.h"
 #include "logging/rtc_event_log/events/rtc_event_dtls_writable_state.h"
+#include "logging/rtc_event_log/events/rtc_event_generic_ack_received.h"
+#include "logging/rtc_event_log/events/rtc_event_generic_packet_received.h"
+#include "logging/rtc_event_log/events/rtc_event_generic_packet_sent.h"
 #include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h"
 #include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h"
 #include "logging/rtc_event_log/events/rtc_event_probe_cluster_created.h"
@@ -687,6 +690,9 @@ std::string RtcEventLogEncoderNewFormat::EncodeBatch(
     std::vector<const RtcEventVideoSendStreamConfig*> video_send_stream_configs;
     std::vector<const RtcEventIceCandidatePairConfig*> ice_candidate_configs;
     std::vector<const RtcEventIceCandidatePair*> ice_candidate_events;
+    std::vector<const RtcEventGenericPacketReceived*> generic_packets_received;
+    std::vector<const RtcEventGenericPacketSent*> generic_packets_sent;
+    std::vector<const RtcEventGenericAckReceived*> generic_acks_received;
 
     for (auto it = begin; it != end; ++it) {
       switch ((*it)->GetType()) {
@@ -818,6 +824,25 @@ std::string RtcEventLogEncoderNewFormat::EncodeBatch(
           ice_candidate_events.push_back(rtc_event);
           break;
         }
+        case RtcEvent::Type::GenericPacketReceived: {
+          auto* rtc_event =
+              static_cast<const RtcEventGenericPacketReceived* const>(
+                  it->get());
+          generic_packets_received.push_back(rtc_event);
+          break;
+        }
+        case RtcEvent::Type::GenericPacketSent: {
+          auto* rtc_event =
+              static_cast<const RtcEventGenericPacketSent* const>(it->get());
+          generic_packets_sent.push_back(rtc_event);
+          break;
+        }
+        case RtcEvent::Type::GenericAckReceived: {
+          auto* rtc_event =
+              static_cast<const RtcEventGenericAckReceived* const>(it->get());
+          generic_acks_received.push_back(rtc_event);
+          break;
+        }
       }
     }
 

logging/rtc_event_log/events/rtc_event.h

@@ -49,7 +49,10 @@ class RtcEvent {
     RtpPacketIncoming,
     RtpPacketOutgoing,
     VideoReceiveStreamConfig,
-    VideoSendStreamConfig
+    VideoSendStreamConfig,
+    GenericPacketSent,
+    GenericPacketReceived,
+    GenericAckReceived
   };
 
   RtcEvent() : timestamp_us_(rtc::TimeMicros()) {}

logging/rtc_event_log/events/rtc_event_generic_ack_received.cc

@@ -0,0 +1,50 @@
+/*
+ *  Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "logging/rtc_event_log/events/rtc_event_generic_ack_received.h"
+
+#include <vector>
+
+namespace webrtc {
+std::vector<std::unique_ptr<RtcEventGenericAckReceived>>
+RtcEventGenericAckReceived::CreateLogs(
+    int64_t packet_number,
+    const std::vector<AckedPacket> acked_packets) {
+  std::vector<std::unique_ptr<RtcEventGenericAckReceived>> result;
+  int64_t time_us = rtc::TimeMicros();
+  for (const AckedPacket& packet : acked_packets) {
+    result.push_back(absl::WrapUnique(new RtcEventGenericAckReceived(
+        time_us, packet_number, packet.packet_number,
+        packet.receive_timestamp_ms)));
+  }
+  return result;
+}
+
+RtcEventGenericAckReceived::RtcEventGenericAckReceived(
+    int64_t timestamp_us,
+    int64_t packet_number,
+    int64_t acked_packet_number,
+    absl::optional<int64_t> receive_timestamp_ms)
+    : RtcEvent(timestamp_us),
+      packet_number_(packet_number),
+      acked_packet_number_(acked_packet_number),
+      receive_timestamp_ms_(receive_timestamp_ms) {}
+
+RtcEventGenericAckReceived::~RtcEventGenericAckReceived() = default;
+
+RtcEvent::Type RtcEventGenericAckReceived::GetType() const {
+  return RtcEvent::Type::GenericAckReceived;
+}
+
+bool RtcEventGenericAckReceived::IsConfigEvent() const {
+  return false;
+}
+
+}  // namespace webrtc

logging/rtc_event_log/events/rtc_event_generic_ack_received.h

@@ -0,0 +1,73 @@
+/*
+ *  Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_GENERIC_ACK_RECEIVED_H_
+#define LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_GENERIC_ACK_RECEIVED_H_
+
+#include "logging/rtc_event_log/events/rtc_event.h"
+
+#include <memory>
+#include <vector>
+
+namespace webrtc {
+
+struct AckedPacket {
+  // The packet number that was acked.
+  int64_t packet_number;
+
+  // The time where the packet was received. Not every ACK will
+  // include the receive timestamp.
+  absl::optional<int64_t> receive_timestamp_ms;
+};
+
+class RtcEventGenericAckReceived final : public RtcEvent {
+ public:
+  // For a collection of acked packets, it creates a vector of logs to log with
+  // the same timestamp.
+  static std::vector<std::unique_ptr<RtcEventGenericAckReceived>> CreateLogs(
+      int64_t packet_number,
+      const std::vector<AckedPacket> acked_packets);
+
+  RtcEventGenericAckReceived(const RtcEventGenericAckReceived& packet);
+  ~RtcEventGenericAckReceived() override;
+
+  Type GetType() const override;
+
+  bool IsConfigEvent() const override;
+
+  // An identifier of the packet which contained an ack.
+  int64_t packet_number() const { return packet_number_; }
+
+  // An identifier of the acked packet.
+  int64_t acked_packet_number() const { return acked_packet_number_; }
+
+  // Collection of the received acks with their timestamps.
+  const absl::optional<int64_t> receive_timestamp_ms() const {
+    return receive_timestamp_ms_;
+  }
+
+ private:
+  // When the ack is received, |packet_number| identifies the packet which
+  // contained an ack for |acked_packet_number|, and contains the
+  // |receive_timestamp_ms| on which the |acked_packet_number| was received on
+  // the remote side. The |receive_timestamp_ms| may be null.
+  RtcEventGenericAckReceived(int64_t timestamp_us,
+                             int64_t packet_number,
+                             int64_t acked_packet_number,
+                             absl::optional<int64_t> receive_timestamp_ms);
+
+  const int64_t packet_number_;
+  const int64_t acked_packet_number_;
+  const absl::optional<int64_t> receive_timestamp_ms_;
+};
+
+}  // namespace webrtc
+
+#endif  // LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_GENERIC_ACK_RECEIVED_H_

logging/rtc_event_log/events/rtc_event_generic_packet_received.cc

@@ -0,0 +1,30 @@
+/*
+ *  Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "logging/rtc_event_log/events/rtc_event_generic_packet_received.h"
+
+namespace webrtc {
+
+RtcEventGenericPacketReceived::RtcEventGenericPacketReceived(
+    int64_t packet_number,
+    size_t packet_length)
+    : packet_number_(packet_number), packet_length_(packet_length) {}
+
+RtcEventGenericPacketReceived::~RtcEventGenericPacketReceived() = default;
+
+RtcEvent::Type RtcEventGenericPacketReceived::GetType() const {
+  return RtcEvent::Type::GenericPacketReceived;
+}
+
+bool RtcEventGenericPacketReceived::IsConfigEvent() const {
+  return false;
+}
+
+}  // namespace webrtc

logging/rtc_event_log/events/rtc_event_generic_packet_received.h

@@ -0,0 +1,42 @@
+/*
+ *  Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_GENERIC_PACKET_RECEIVED_H_
+#define LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_GENERIC_PACKET_RECEIVED_H_
+
+#include "logging/rtc_event_log/events/rtc_event.h"
+
+namespace webrtc {
+
+class RtcEventGenericPacketReceived final : public RtcEvent {
+ public:
+  RtcEventGenericPacketReceived(int64_t packet_number, size_t packet_length);
+  RtcEventGenericPacketReceived(const RtcEventGenericPacketReceived& packet);
+  ~RtcEventGenericPacketReceived() override;
+
+  Type GetType() const override;
+
+  bool IsConfigEvent() const override;
+
+  // An identifier of the packet.
+  int64_t packet_number() const { return packet_number_; }
+
+  // Total packet length, including all packetization overheads, but not
+  // including ICE/TURN/IP overheads.
+  size_t packet_length() const { return packet_length_; }
+
+ private:
+  const int64_t packet_number_;
+  const size_t packet_length_;
+};
+
+}  // namespace webrtc
+
+#endif  // LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_GENERIC_PACKET_RECEIVED_H_

logging/rtc_event_log/events/rtc_event_generic_packet_sent.cc

@@ -0,0 +1,34 @@
+/*
+ *  Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "logging/rtc_event_log/events/rtc_event_generic_packet_sent.h"
+
+namespace webrtc {
+
+RtcEventGenericPacketSent::RtcEventGenericPacketSent(int64_t packet_number,
+                                                     size_t overhead_length,
+                                                     size_t payload_length,
+                                                     size_t padding_length)
+    : packet_number_(packet_number),
+      overhead_length_(overhead_length),
+      payload_length_(payload_length),
+      padding_length_(padding_length) {}
+
+RtcEventGenericPacketSent::~RtcEventGenericPacketSent() = default;
+
+RtcEvent::Type RtcEventGenericPacketSent::GetType() const {
+  return RtcEvent::Type::GenericPacketSent;
+}
+
+bool RtcEventGenericPacketSent::IsConfigEvent() const {
+  return false;
+}
+
+}  // namespace webrtc

logging/rtc_event_log/events/rtc_event_generic_packet_sent.h

@@ -0,0 +1,59 @@
+/*
+ *  Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_GENERIC_PACKET_SENT_H_
+#define LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_GENERIC_PACKET_SENT_H_
+
+#include "logging/rtc_event_log/events/rtc_event.h"
+
+namespace webrtc {
+
+class RtcEventGenericPacketSent final : public RtcEvent {
+ public:
+  RtcEventGenericPacketSent(int64_t packet_number,
+                            size_t overhead_length,
+                            size_t payload_length,
+                            size_t padding_length);
+  RtcEventGenericPacketSent(const RtcEventGenericPacketSent& packet);
+  ~RtcEventGenericPacketSent() override;
+
+  Type GetType() const override;
+
+  bool IsConfigEvent() const override;
+
+  // An identifier of the packet.
+  int64_t packet_number() const { return packet_number_; }
+
+  // Total packet length, including all packetization overheads, but not
+  // including ICE/TURN/IP overheads.
+  size_t packet_length() const {
+    return overhead_length_ + payload_length_ + padding_length_;
+  }
+
+  // The number of bytes in overhead, including framing overheads, acks if
+  // present, etc.
+  size_t overhead_length() const { return overhead_length_; }
+
+  // Length of payload sent (size of raw audio/video/data), without
+  // packetization overheads. This may still include serialization overheads.
+  size_t payload_length() const { return payload_length_; }
+
+  size_t padding_length() const { return padding_length_; }
+
+ private:
+  const int64_t packet_number_;
+  const size_t overhead_length_;
+  const size_t payload_length_;
+  const size_t padding_length_;
+};
+
+}  // namespace webrtc
+
+#endif  // LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_GENERIC_PACKET_SENT_H_