[PCLF] Add possibility to use new perf metrics api in StatsBasedNetworkQualityMetricsReporter

Bug: b/246095034
Change-Id: Iaba2b0656978552482754d8170afe356f3715f6a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/276200
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38143}
diff --git a/test/pc/e2e/BUILD.gn b/test/pc/e2e/BUILD.gn
index 0ace4cc..93e8800 100644
--- a/test/pc/e2e/BUILD.gn
+++ b/test/pc/e2e/BUILD.gn
@@ -849,6 +849,8 @@
       "../../../api:rtc_stats_api",
       "../../../api:scoped_refptr",
       "../../../api/numerics",
+      "../../../api/test/metrics:metric",
+      "../../../api/test/metrics:metrics_logger_and_exporter",
       "../../../api/test/network_emulation",
       "../../../api/units:data_rate",
       "../../../api/units:data_size",
diff --git a/test/pc/e2e/stats_based_network_quality_metrics_reporter.cc b/test/pc/e2e/stats_based_network_quality_metrics_reporter.cc
index 5e54e0e..a4e046e 100644
--- a/test/pc/e2e/stats_based_network_quality_metrics_reporter.cc
+++ b/test/pc/e2e/stats_based_network_quality_metrics_reporter.cc
@@ -24,6 +24,7 @@
 #include "api/scoped_refptr.h"
 #include "api/stats/rtc_stats.h"
 #include "api/stats/rtcstats_objects.h"
+#include "api/test/metrics/metric.h"
 #include "api/test/network_emulation/network_emulation_interfaces.h"
 #include "api/test/network_emulation_manager.h"
 #include "api/units/data_rate.h"
@@ -39,6 +40,9 @@
 namespace webrtc_pc_e2e {
 namespace {
 
+using ::webrtc::test::ImprovementDirection;
+using ::webrtc::test::Unit;
+
 constexpr TimeDelta kStatsWaitTimeout = TimeDelta::Seconds(1);
 
 // Field trial which controls whether to report standard-compliant bytes
@@ -237,32 +241,75 @@
     const NetworkLayerStats& network_layer_stats,
     int64_t packet_loss,
     const Timestamp& end_time) {
-  ReportResult("bytes_discarded_no_receiver", pc_label,
-               network_layer_stats.stats->BytesDropped().bytes(),
-               "sizeInBytes");
-  ReportResult("packets_discarded_no_receiver", pc_label,
-               network_layer_stats.stats->PacketsDropped(), "unitless");
+  if (metrics_logger_ == nullptr) {
+    ReportResult("bytes_discarded_no_receiver", pc_label,
+                 network_layer_stats.stats->BytesDropped().bytes(),
+                 "sizeInBytes");
+    ReportResult("packets_discarded_no_receiver", pc_label,
+                 network_layer_stats.stats->PacketsDropped(), "unitless");
 
-  ReportResult("payload_bytes_received", pc_label,
-               pc_stats.payload_received.bytes(), "sizeInBytes");
-  ReportResult("payload_bytes_sent", pc_label, pc_stats.payload_sent.bytes(),
-               "sizeInBytes");
+    ReportResult("payload_bytes_received", pc_label,
+                 pc_stats.payload_received.bytes(), "sizeInBytes");
+    ReportResult("payload_bytes_sent", pc_label, pc_stats.payload_sent.bytes(),
+                 "sizeInBytes");
 
-  ReportResult("bytes_sent", pc_label, pc_stats.total_sent.bytes(),
-               "sizeInBytes");
-  ReportResult("packets_sent", pc_label, pc_stats.packets_sent, "unitless");
-  ReportResult("average_send_rate", pc_label,
-               (pc_stats.total_sent / (end_time - start_time_)).bytes_per_sec(),
-               "bytesPerSecond");
-  ReportResult("bytes_received", pc_label, pc_stats.total_received.bytes(),
-               "sizeInBytes");
-  ReportResult("packets_received", pc_label, pc_stats.packets_received,
-               "unitless");
-  ReportResult(
-      "average_receive_rate", pc_label,
-      (pc_stats.total_received / (end_time - start_time_)).bytes_per_sec(),
-      "bytesPerSecond");
-  ReportResult("sent_packets_loss", pc_label, packet_loss, "unitless");
+    ReportResult("bytes_sent", pc_label, pc_stats.total_sent.bytes(),
+                 "sizeInBytes");
+    ReportResult("packets_sent", pc_label, pc_stats.packets_sent, "unitless");
+    ReportResult(
+        "average_send_rate", pc_label,
+        (pc_stats.total_sent / (end_time - start_time_)).bytes_per_sec(),
+        "bytesPerSecond");
+    ReportResult("bytes_received", pc_label, pc_stats.total_received.bytes(),
+                 "sizeInBytes");
+    ReportResult("packets_received", pc_label, pc_stats.packets_received,
+                 "unitless");
+    ReportResult(
+        "average_receive_rate", pc_label,
+        (pc_stats.total_received / (end_time - start_time_)).bytes_per_sec(),
+        "bytesPerSecond");
+    ReportResult("sent_packets_loss", pc_label, packet_loss, "unitless");
+  } else {
+    metrics_logger_->LogSingleValueMetric(
+        "bytes_discarded_no_receiver", pc_label,
+        network_layer_stats.stats->BytesDropped().bytes(), Unit::kBytes,
+        ImprovementDirection::kNeitherIsBetter);
+    metrics_logger_->LogSingleValueMetric(
+        "packets_discarded_no_receiver", pc_label,
+        network_layer_stats.stats->PacketsDropped(), Unit::kUnitless,
+        ImprovementDirection::kNeitherIsBetter);
+
+    metrics_logger_->LogSingleValueMetric(
+        "payload_bytes_received", pc_label, pc_stats.payload_received.bytes(),
+        Unit::kBytes, ImprovementDirection::kNeitherIsBetter);
+    metrics_logger_->LogSingleValueMetric(
+        "payload_bytes_sent", pc_label, pc_stats.payload_sent.bytes(),
+        Unit::kBytes, ImprovementDirection::kNeitherIsBetter);
+
+    metrics_logger_->LogSingleValueMetric(
+        "bytes_sent", pc_label, pc_stats.total_sent.bytes(), Unit::kBytes,
+        ImprovementDirection::kNeitherIsBetter);
+    metrics_logger_->LogSingleValueMetric(
+        "packets_sent", pc_label, pc_stats.packets_sent, Unit::kUnitless,
+        ImprovementDirection::kNeitherIsBetter);
+    metrics_logger_->LogSingleValueMetric(
+        "average_send_rate", pc_label,
+        (pc_stats.total_sent / (end_time - start_time_)).kbps(),
+        Unit::kKilobitsPerSecond, ImprovementDirection::kNeitherIsBetter);
+    metrics_logger_->LogSingleValueMetric(
+        "bytes_received", pc_label, pc_stats.total_received.bytes(),
+        Unit::kBytes, ImprovementDirection::kNeitherIsBetter);
+    metrics_logger_->LogSingleValueMetric(
+        "packets_received", pc_label, pc_stats.packets_received,
+        Unit::kUnitless, ImprovementDirection::kNeitherIsBetter);
+    metrics_logger_->LogSingleValueMetric(
+        "average_receive_rate", pc_label,
+        (pc_stats.total_received / (end_time - start_time_)).kbps(),
+        Unit::kKilobitsPerSecond, ImprovementDirection::kNeitherIsBetter);
+    metrics_logger_->LogSingleValueMetric(
+        "sent_packets_loss", pc_label, packet_loss, Unit::kUnitless,
+        ImprovementDirection::kNeitherIsBetter);
+  }
 }
 
 void StatsBasedNetworkQualityMetricsReporter::ReportResult(
@@ -309,20 +356,47 @@
     log << "  " << local_ips[i].ToString() << "\n";
   }
   if (!stats.stats->SentPacketsSizeCounter().IsEmpty()) {
-    ReportResult("sent_packets_size", peer_name,
-                 stats.stats->SentPacketsSizeCounter(), "sizeInBytes");
+    if (metrics_logger_ == nullptr) {
+      ReportResult("sent_packets_size", peer_name,
+                   stats.stats->SentPacketsSizeCounter(), "sizeInBytes");
+    } else {
+      metrics_logger_->LogMetric(
+          "sent_packets_size", peer_name, stats.stats->SentPacketsSizeCounter(),
+          Unit::kBytes, ImprovementDirection::kNeitherIsBetter);
+    }
   }
   if (!stats.stats->ReceivedPacketsSizeCounter().IsEmpty()) {
-    ReportResult("received_packets_size", peer_name,
-                 stats.stats->ReceivedPacketsSizeCounter(), "sizeInBytes");
+    if (metrics_logger_ == nullptr) {
+      ReportResult("received_packets_size", peer_name,
+                   stats.stats->ReceivedPacketsSizeCounter(), "sizeInBytes");
+    } else {
+      metrics_logger_->LogMetric("received_packets_size", peer_name,
+                                 stats.stats->ReceivedPacketsSizeCounter(),
+                                 Unit::kBytes,
+                                 ImprovementDirection::kNeitherIsBetter);
+    }
   }
   if (!stats.stats->DroppedPacketsSizeCounter().IsEmpty()) {
-    ReportResult("dropped_packets_size", peer_name,
-                 stats.stats->DroppedPacketsSizeCounter(), "sizeInBytes");
+    if (metrics_logger_ == nullptr) {
+      ReportResult("dropped_packets_size", peer_name,
+                   stats.stats->DroppedPacketsSizeCounter(), "sizeInBytes");
+    } else {
+      metrics_logger_->LogMetric("dropped_packets_size", peer_name,
+                                 stats.stats->DroppedPacketsSizeCounter(),
+                                 Unit::kBytes,
+                                 ImprovementDirection::kNeitherIsBetter);
+    }
   }
   if (!stats.stats->SentPacketsQueueWaitTimeUs().IsEmpty()) {
-    ReportResult("sent_packets_queue_wait_time_us", peer_name,
-                 stats.stats->SentPacketsQueueWaitTimeUs(), "unitless");
+    if (metrics_logger_ == nullptr) {
+      ReportResult("sent_packets_queue_wait_time_us", peer_name,
+                   stats.stats->SentPacketsQueueWaitTimeUs(), "unitless");
+    } else {
+      metrics_logger_->LogMetric("sent_packets_queue_wait_time_us", peer_name,
+                                 stats.stats->SentPacketsQueueWaitTimeUs(),
+                                 Unit::kUnitless,
+                                 ImprovementDirection::kNeitherIsBetter);
+    }
   }
 
   log << "Send statistic:\n"
@@ -342,9 +416,16 @@
         << " avg_rate (bytes/sec): " << source_average_send_rate.bytes_per_sec()
         << " avg_rate (bps): " << source_average_send_rate.bps() << "\n";
     if (!entry.second->SentPacketsSizeCounter().IsEmpty()) {
-      ReportResult("sent_packets_size",
-                   peer_name + "/" + entry.first.ToString(),
-                   stats.stats->SentPacketsSizeCounter(), "sizeInBytes");
+      if (metrics_logger_ == nullptr) {
+        ReportResult("sent_packets_size",
+                     peer_name + "/" + entry.first.ToString(),
+                     stats.stats->SentPacketsSizeCounter(), "sizeInBytes");
+      } else {
+        metrics_logger_->LogMetric(
+            "sent_packets_size", peer_name + "/" + entry.first.ToString(),
+            stats.stats->SentPacketsSizeCounter(), Unit::kBytes,
+            ImprovementDirection::kNeitherIsBetter);
+      }
     }
   }
 
@@ -367,14 +448,28 @@
         << source_average_receive_rate.bytes_per_sec()
         << " avg_rate (bps): " << source_average_receive_rate.bps() << "\n";
     if (!entry.second->ReceivedPacketsSizeCounter().IsEmpty()) {
-      ReportResult("received_packets_size",
-                   peer_name + "/" + entry.first.ToString(),
-                   stats.stats->ReceivedPacketsSizeCounter(), "sizeInBytes");
+      if (metrics_logger_ == nullptr) {
+        ReportResult("received_packets_size",
+                     peer_name + "/" + entry.first.ToString(),
+                     stats.stats->ReceivedPacketsSizeCounter(), "sizeInBytes");
+      } else {
+        metrics_logger_->LogMetric(
+            "received_packets_size", peer_name + "/" + entry.first.ToString(),
+            stats.stats->ReceivedPacketsSizeCounter(), Unit::kBytes,
+            ImprovementDirection::kNeitherIsBetter);
+      }
     }
     if (!entry.second->DroppedPacketsSizeCounter().IsEmpty()) {
-      ReportResult("dropped_packets_size",
-                   peer_name + "/" + entry.first.ToString(),
-                   stats.stats->DroppedPacketsSizeCounter(), "sizeInBytes");
+      if (metrics_logger_ == nullptr) {
+        ReportResult("dropped_packets_size",
+                     peer_name + "/" + entry.first.ToString(),
+                     stats.stats->DroppedPacketsSizeCounter(), "sizeInBytes");
+      } else {
+        metrics_logger_->LogMetric(
+            "dropped_packets_size", peer_name + "/" + entry.first.ToString(),
+            stats.stats->DroppedPacketsSizeCounter(), Unit::kBytes,
+            ImprovementDirection::kNeitherIsBetter);
+      }
     }
   }
 
diff --git a/test/pc/e2e/stats_based_network_quality_metrics_reporter.h b/test/pc/e2e/stats_based_network_quality_metrics_reporter.h
index a940d81..f362c76 100644
--- a/test/pc/e2e/stats_based_network_quality_metrics_reporter.h
+++ b/test/pc/e2e/stats_based_network_quality_metrics_reporter.h
@@ -21,6 +21,7 @@
 
 #include "absl/strings/string_view.h"
 #include "api/numerics/samples_stats_counter.h"
+#include "api/test/metrics/metrics_logger_and_exporter.h"
 #include "api/test/network_emulation/network_emulation_interfaces.h"
 #include "api/test/network_emulation_manager.h"
 #include "api/test/peerconnection_quality_test_fixture.h"
@@ -41,8 +42,16 @@
   StatsBasedNetworkQualityMetricsReporter(
       std::map<std::string, std::vector<EmulatedEndpoint*>> peer_endpoints,
       NetworkEmulationManager* network_emulation)
+      : StatsBasedNetworkQualityMetricsReporter(std::move(peer_endpoints),
+                                                network_emulation,
+                                                /*metrics_logger=*/nullptr) {}
+  StatsBasedNetworkQualityMetricsReporter(
+      std::map<std::string, std::vector<EmulatedEndpoint*>> peer_endpoints,
+      NetworkEmulationManager* network_emulation,
+      test::MetricsLoggerAndExporter* metrics_logger)
       : collector_(std::move(peer_endpoints), network_emulation),
-        clock_(network_emulation->time_controller()->GetClock()) {}
+        clock_(network_emulation->time_controller()->GetClock()),
+        metrics_logger_(metrics_logger) {}
   ~StatsBasedNetworkQualityMetricsReporter() override = default;
 
   void AddPeer(absl::string_view peer_name,
@@ -116,6 +125,7 @@
 
   NetworkLayerStatsCollector collector_;
   Clock* const clock_;
+  test::MetricsLoggerAndExporter* const metrics_logger_;
 
   std::string test_case_name_;
   Timestamp start_time_ = Timestamp::MinusInfinity();