Add peer name to video quality analyzer interface.

Add peer name to video quality analyzer interface to make it possible to
add multipeer support.

Change-Id: I2570cd4481503c8634bdd91208b3dd2fa1d62029
Bug: webrtc:11631
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176329
Reviewed-by: Andrey Logvin <landrey@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31395}

16 files changed, 190 insertions, 82 deletions

diff --git a/test/pc/e2e/BUILD.gn b/test/pc/e2e/BUILD.gn
index d340f1a00c..f31bd2c414 100644
--- a/test/pc/e2e/BUILD.gn
+++ b/test/pc/e2e/BUILD.gn
@@ -147,6 +147,7 @@ rtc_library("quality_analyzing_video_decoder") {
     "../../../modules/video_coding:video_codec_interface",
     "../../../rtc_base:criticalsection",
     "../../../rtc_base:logging",
+    "//third_party/abseil-cpp/absl/strings",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
@@ -169,6 +170,7 @@ rtc_library("quality_analyzing_video_encoder") {
     "../../../modules/video_coding:video_codec_interface",
     "../../../rtc_base:criticalsection",
     "../../../rtc_base:logging",
+    "//third_party/abseil-cpp/absl/strings",
   ]
 }
 
@@ -197,6 +199,7 @@ if (rtc_include_tests) {
       "../../../test:video_test_common",
       "../../../test:video_test_support",
       "//third_party/abseil-cpp/absl/memory",
+      "//third_party/abseil-cpp/absl/strings",
     ]
   }
 
@@ -385,6 +388,7 @@ if (rtc_include_tests) {
       "../../../rtc_base:task_queue_for_test",
       "../../../system_wrappers",
       "../../../system_wrappers:field_trial",
+      "//third_party/abseil-cpp/absl/strings",
     ]
   }
 
diff --git a/test/pc/e2e/analyzer/video/default_video_quality_analyzer.cc b/test/pc/e2e/analyzer/video/default_video_quality_analyzer.cc
index 786509ddb7..b09292b541 100644
--- a/test/pc/e2e/analyzer/video/default_video_quality_analyzer.cc
+++ b/test/pc/e2e/analyzer/video/default_video_quality_analyzer.cc
@@ -98,6 +98,7 @@ void DefaultVideoQualityAnalyzer::Start(std::string test_case_name,
 }
 
 uint16_t DefaultVideoQualityAnalyzer::OnFrameCaptured(
+    absl::string_view peer_name,
     const std::string& stream_label,
     const webrtc::VideoFrame& frame) {
   // |next_frame_id| is atomic, so we needn't lock here.
@@ -172,6 +173,7 @@ uint16_t DefaultVideoQualityAnalyzer::OnFrameCaptured(
 }
 
 void DefaultVideoQualityAnalyzer::OnFramePreEncode(
+    absl::string_view peer_name,
     const webrtc::VideoFrame& frame) {
   rtc::CritScope crit(&lock_);
   auto it = frame_stats_.find(frame.id());
@@ -183,6 +185,7 @@ void DefaultVideoQualityAnalyzer::OnFramePreEncode(
 }
 
 void DefaultVideoQualityAnalyzer::OnFrameEncoded(
+    absl::string_view peer_name,
     uint16_t frame_id,
     const webrtc::EncodedImage& encoded_image,
     const EncoderStats& stats) {
@@ -202,11 +205,13 @@ void DefaultVideoQualityAnalyzer::OnFrameEncoded(
 }
 
 void DefaultVideoQualityAnalyzer::OnFrameDropped(
+    absl::string_view peer_name,
     webrtc::EncodedImageCallback::DropReason reason) {
   // Here we do nothing, because we will see this drop on renderer side.
 }
 
 void DefaultVideoQualityAnalyzer::OnFramePreDecode(
+    absl::string_view peer_name,
     uint16_t frame_id,
     const webrtc::EncodedImage& input_image) {
   rtc::CritScope crit(&lock_);
@@ -231,6 +236,7 @@ void DefaultVideoQualityAnalyzer::OnFramePreDecode(
 }
 
 void DefaultVideoQualityAnalyzer::OnFrameDecoded(
+    absl::string_view peer_name,
     const webrtc::VideoFrame& frame,
     const DecoderStats& stats) {
   rtc::CritScope crit(&lock_);
@@ -242,6 +248,7 @@ void DefaultVideoQualityAnalyzer::OnFrameDecoded(
 }
 
 void DefaultVideoQualityAnalyzer::OnFrameRendered(
+    absl::string_view peer_name,
     const webrtc::VideoFrame& raw_frame) {
   // Copy entire video frame including video buffer to ensure that analyzer
   // won't hold any WebRTC internal buffers.
@@ -326,13 +333,15 @@ void DefaultVideoQualityAnalyzer::OnFrameRendered(
 }
 
 void DefaultVideoQualityAnalyzer::OnEncoderError(
+    absl::string_view peer_name,
     const webrtc::VideoFrame& frame,
     int32_t error_code) {
   RTC_LOG(LS_ERROR) << "Encoder error for frame.id=" << frame.id()
                     << ", code=" << error_code;
 }
 
-void DefaultVideoQualityAnalyzer::OnDecoderError(uint16_t frame_id,
+void DefaultVideoQualityAnalyzer::OnDecoderError(absl::string_view peer_name,
+                                                 uint16_t frame_id,
                                                  int32_t error_code) {
   RTC_LOG(LS_ERROR) << "Decoder error for frame_id=" << frame_id
                     << ", code=" << error_code;
diff --git a/test/pc/e2e/analyzer/video/default_video_quality_analyzer.h b/test/pc/e2e/analyzer/video/default_video_quality_analyzer.h
index 6bebb0f02b..2f83f23cd3 100644
--- a/test/pc/e2e/analyzer/video/default_video_quality_analyzer.h
+++ b/test/pc/e2e/analyzer/video/default_video_quality_analyzer.h
@@ -135,20 +135,31 @@ class DefaultVideoQualityAnalyzer : public VideoQualityAnalyzerInterface {
   ~DefaultVideoQualityAnalyzer() override;
 
   void Start(std::string test_case_name, int max_threads_count) override;
-  uint16_t OnFrameCaptured(const std::string& stream_label,
+  uint16_t OnFrameCaptured(absl::string_view peer_name,
+                           const std::string& stream_label,
                            const VideoFrame& frame) override;
-  void OnFramePreEncode(const VideoFrame& frame) override;
-  void OnFrameEncoded(uint16_t frame_id,
+  void OnFramePreEncode(absl::string_view peer_name,
+                        const VideoFrame& frame) override;
+  void OnFrameEncoded(absl::string_view peer_name,
+                      uint16_t frame_id,
                       const EncodedImage& encoded_image,
                       const EncoderStats& stats) override;
-  void OnFrameDropped(EncodedImageCallback::DropReason reason) override;
-  void OnFramePreDecode(uint16_t frame_id,
+  void OnFrameDropped(absl::string_view peer_name,
+                      EncodedImageCallback::DropReason reason) override;
+  void OnFramePreDecode(absl::string_view peer_name,
+                        uint16_t frame_id,
                         const EncodedImage& input_image) override;
-  void OnFrameDecoded(const VideoFrame& frame,
+  void OnFrameDecoded(absl::string_view peer_name,
+                      const VideoFrame& frame,
                       const DecoderStats& stats) override;
-  void OnFrameRendered(const VideoFrame& frame) override;
-  void OnEncoderError(const VideoFrame& frame, int32_t error_code) override;
-  void OnDecoderError(uint16_t frame_id, int32_t error_code) override;
+  void OnFrameRendered(absl::string_view peer_name,
+                       const VideoFrame& frame) override;
+  void OnEncoderError(absl::string_view peer_name,
+                      const VideoFrame& frame,
+                      int32_t error_code) override;
+  void OnDecoderError(absl::string_view peer_name,
+                      uint16_t frame_id,
+                      int32_t error_code) override;
   void Stop() override;
   std::string GetStreamLabel(uint16_t frame_id) override;
   void OnStatsReports(const std::string& pc_label,
diff --git a/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc b/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc
index 1bc29c5f09..ef6baf9bd0 100644
--- a/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc
+++ b/test/pc/e2e/analyzer/video/default_video_quality_analyzer_test.cc
@@ -31,6 +31,8 @@ constexpr int kMaxFramesInFlightPerStream = 10;
 constexpr int kFrameWidth = 320;
 constexpr int kFrameHeight = 240;
 constexpr char kStreamLabel[] = "video-stream";
+constexpr char kSenderPeerName[] = "alice";
+constexpr char kReceiverPeerName[] = "bob";
 
 VideoFrame NextFrame(test::FrameGeneratorInterface* frame_generator,
                      int64_t timestamp_us) {
@@ -79,20 +81,22 @@ TEST(DefaultVideoQualityAnalyzerTest,
   std::vector<uint16_t> frames_order;
   for (int i = 0; i < kMaxFramesInFlightPerStream * 2; ++i) {
     VideoFrame frame = NextFrame(frame_generator.get(), i);
-    frame.set_id(analyzer.OnFrameCaptured(kStreamLabel, frame));
+    frame.set_id(
+        analyzer.OnFrameCaptured(kSenderPeerName, kStreamLabel, frame));
     frames_order.push_back(frame.id());
     captured_frames.insert({frame.id(), frame});
-    analyzer.OnFramePreEncode(frame);
-    analyzer.OnFrameEncoded(frame.id(), FakeEncode(frame),
+    analyzer.OnFramePreEncode(kSenderPeerName, frame);
+    analyzer.OnFrameEncoded(kSenderPeerName, frame.id(), FakeEncode(frame),
                             VideoQualityAnalyzerInterface::EncoderStats());
   }
 
   for (const uint16_t& frame_id : frames_order) {
     VideoFrame received_frame = DeepCopy(captured_frames.at(frame_id));
-    analyzer.OnFramePreDecode(received_frame.id(), FakeEncode(received_frame));
-    analyzer.OnFrameDecoded(received_frame,
+    analyzer.OnFramePreDecode(kReceiverPeerName, received_frame.id(),
+                              FakeEncode(received_frame));
+    analyzer.OnFrameDecoded(kReceiverPeerName, received_frame,
                             VideoQualityAnalyzerInterface::DecoderStats());
-    analyzer.OnFrameRendered(received_frame);
+    analyzer.OnFrameRendered(kReceiverPeerName, received_frame);
   }
 
   // Give analyzer some time to process frames on async thread. The computations
@@ -126,21 +130,23 @@ TEST(DefaultVideoQualityAnalyzerTest,
   std::vector<uint16_t> frames_order;
   for (int i = 0; i < kMaxFramesInFlightPerStream * 2; ++i) {
     VideoFrame frame = NextFrame(frame_generator.get(), i);
-    frame.set_id(analyzer.OnFrameCaptured(kStreamLabel, frame));
+    frame.set_id(
+        analyzer.OnFrameCaptured(kSenderPeerName, kStreamLabel, frame));
     frames_order.push_back(frame.id());
     captured_frames.insert({frame.id(), frame});
-    analyzer.OnFramePreEncode(frame);
-    analyzer.OnFrameEncoded(frame.id(), FakeEncode(frame),
+    analyzer.OnFramePreEncode(kSenderPeerName, frame);
+    analyzer.OnFrameEncoded(kSenderPeerName, frame.id(), FakeEncode(frame),
                             VideoQualityAnalyzerInterface::EncoderStats());
   }
 
   for (size_t i = kMaxFramesInFlightPerStream; i < frames_order.size(); ++i) {
     uint16_t frame_id = frames_order.at(i);
     VideoFrame received_frame = DeepCopy(captured_frames.at(frame_id));
-    analyzer.OnFramePreDecode(received_frame.id(), FakeEncode(received_frame));
-    analyzer.OnFrameDecoded(received_frame,
+    analyzer.OnFramePreDecode(kReceiverPeerName, received_frame.id(),
+                              FakeEncode(received_frame));
+    analyzer.OnFrameDecoded(kReceiverPeerName, received_frame,
                             VideoQualityAnalyzerInterface::DecoderStats());
-    analyzer.OnFrameRendered(received_frame);
+    analyzer.OnFrameRendered(kReceiverPeerName, received_frame);
   }
 
   // Give analyzer some time to process frames on async thread. The computations
@@ -172,21 +178,23 @@ TEST(DefaultVideoQualityAnalyzerTest, NormalScenario) {
   std::vector<uint16_t> frames_order;
   for (int i = 0; i < kMaxFramesInFlightPerStream; ++i) {
     VideoFrame frame = NextFrame(frame_generator.get(), i);
-    frame.set_id(analyzer.OnFrameCaptured(kStreamLabel, frame));
+    frame.set_id(
+        analyzer.OnFrameCaptured(kSenderPeerName, kStreamLabel, frame));
     frames_order.push_back(frame.id());
     captured_frames.insert({frame.id(), frame});
-    analyzer.OnFramePreEncode(frame);
-    analyzer.OnFrameEncoded(frame.id(), FakeEncode(frame),
+    analyzer.OnFramePreEncode(kSenderPeerName, frame);
+    analyzer.OnFrameEncoded(kSenderPeerName, frame.id(), FakeEncode(frame),
                             VideoQualityAnalyzerInterface::EncoderStats());
   }
 
   for (size_t i = 1; i < frames_order.size(); i += 2) {
     uint16_t frame_id = frames_order.at(i);
     VideoFrame received_frame = DeepCopy(captured_frames.at(frame_id));
-    analyzer.OnFramePreDecode(received_frame.id(), FakeEncode(received_frame));
-    analyzer.OnFrameDecoded(received_frame,
+    analyzer.OnFramePreDecode(kReceiverPeerName, received_frame.id(),
+                              FakeEncode(received_frame));
+    analyzer.OnFrameDecoded(kReceiverPeerName, received_frame,
                             VideoQualityAnalyzerInterface::DecoderStats());
-    analyzer.OnFrameRendered(received_frame);
+    analyzer.OnFrameRendered(kReceiverPeerName, received_frame);
   }
 
   // Give analyzer some time to process frames on async thread. The computations
diff --git a/test/pc/e2e/analyzer/video/example_video_quality_analyzer.cc b/test/pc/e2e/analyzer/video/example_video_quality_analyzer.cc
index d1d1bface7..4488234cc4 100644
--- a/test/pc/e2e/analyzer/video/example_video_quality_analyzer.cc
+++ b/test/pc/e2e/analyzer/video/example_video_quality_analyzer.cc
@@ -22,6 +22,7 @@ void ExampleVideoQualityAnalyzer::Start(std::string test_case_name,
                                         int max_threads_count) {}
 
 uint16_t ExampleVideoQualityAnalyzer::OnFrameCaptured(
+    absl::string_view peer_name,
     const std::string& stream_label,
     const webrtc::VideoFrame& frame) {
   rtc::CritScope crit(&lock_);
@@ -45,12 +46,14 @@ uint16_t ExampleVideoQualityAnalyzer::OnFrameCaptured(
 }
 
 void ExampleVideoQualityAnalyzer::OnFramePreEncode(
+    absl::string_view peer_name,
     const webrtc::VideoFrame& frame) {
   rtc::CritScope crit(&lock_);
   ++frames_pre_encoded_;
 }
 
 void ExampleVideoQualityAnalyzer::OnFrameEncoded(
+    absl::string_view peer_name,
     uint16_t frame_id,
     const webrtc::EncodedImage& encoded_image,
     const EncoderStats& stats) {
@@ -59,6 +62,7 @@ void ExampleVideoQualityAnalyzer::OnFrameEncoded(
 }
 
 void ExampleVideoQualityAnalyzer::OnFrameDropped(
+    absl::string_view peer_name,
     webrtc::EncodedImageCallback::DropReason reason) {
   RTC_LOG(INFO) << "Frame dropped by encoder";
   rtc::CritScope crit(&lock_);
@@ -66,6 +70,7 @@ void ExampleVideoQualityAnalyzer::OnFrameDropped(
 }
 
 void ExampleVideoQualityAnalyzer::OnFramePreDecode(
+    absl::string_view peer_name,
     uint16_t frame_id,
     const webrtc::EncodedImage& encoded_image) {
   rtc::CritScope crit(&lock_);
@@ -73,6 +78,7 @@ void ExampleVideoQualityAnalyzer::OnFramePreDecode(
 }
 
 void ExampleVideoQualityAnalyzer::OnFrameDecoded(
+    absl::string_view peer_name,
     const webrtc::VideoFrame& frame,
     const DecoderStats& stats) {
   rtc::CritScope crit(&lock_);
@@ -80,6 +86,7 @@ void ExampleVideoQualityAnalyzer::OnFrameDecoded(
 }
 
 void ExampleVideoQualityAnalyzer::OnFrameRendered(
+    absl::string_view peer_name,
     const webrtc::VideoFrame& frame) {
   rtc::CritScope crit(&lock_);
   frames_in_flight_.erase(frame.id());
@@ -87,13 +94,15 @@ void ExampleVideoQualityAnalyzer::OnFrameRendered(
 }
 
 void ExampleVideoQualityAnalyzer::OnEncoderError(
+    absl::string_view peer_name,
     const webrtc::VideoFrame& frame,
     int32_t error_code) {
   RTC_LOG(LS_ERROR) << "Failed to encode frame " << frame.id()
                     << ". Code: " << error_code;
 }
 
-void ExampleVideoQualityAnalyzer::OnDecoderError(uint16_t frame_id,
+void ExampleVideoQualityAnalyzer::OnDecoderError(absl::string_view peer_name,
+                                                 uint16_t frame_id,
                                                  int32_t error_code) {
   RTC_LOG(LS_ERROR) << "Failed to decode frame " << frame_id
                     << ". Code: " << error_code;
diff --git a/test/pc/e2e/analyzer/video/example_video_quality_analyzer.h b/test/pc/e2e/analyzer/video/example_video_quality_analyzer.h
index 0d6169f9fa..a4a1104e07 100644
--- a/test/pc/e2e/analyzer/video/example_video_quality_analyzer.h
+++ b/test/pc/e2e/analyzer/video/example_video_quality_analyzer.h
@@ -34,20 +34,31 @@ class ExampleVideoQualityAnalyzer : public VideoQualityAnalyzerInterface {
   ~ExampleVideoQualityAnalyzer() override;
 
   void Start(std::string test_case_name, int max_threads_count) override;
-  uint16_t OnFrameCaptured(const std::string& stream_label,
+  uint16_t OnFrameCaptured(absl::string_view peer_name,
+                           const std::string& stream_label,
                            const VideoFrame& frame) override;
-  void OnFramePreEncode(const VideoFrame& frame) override;
-  void OnFrameEncoded(uint16_t frame_id,
+  void OnFramePreEncode(absl::string_view peer_name,
+                        const VideoFrame& frame) override;
+  void OnFrameEncoded(absl::string_view peer_name,
+                      uint16_t frame_id,
                       const EncodedImage& encoded_image,
                       const EncoderStats& stats) override;
-  void OnFrameDropped(EncodedImageCallback::DropReason reason) override;
-  void OnFramePreDecode(uint16_t frame_id,
+  void OnFrameDropped(absl::string_view peer_name,
+                      EncodedImageCallback::DropReason reason) override;
+  void OnFramePreDecode(absl::string_view peer_name,
+                        uint16_t frame_id,
                         const EncodedImage& encoded_image) override;
-  void OnFrameDecoded(const VideoFrame& frame,
+  void OnFrameDecoded(absl::string_view peer_name,
+                      const VideoFrame& frame,
                       const DecoderStats& stats) override;
-  void OnFrameRendered(const VideoFrame& frame) override;
-  void OnEncoderError(const VideoFrame& frame, int32_t error_code) override;
-  void OnDecoderError(uint16_t frame_id, int32_t error_code) override;
+  void OnFrameRendered(absl::string_view peer_name,
+                       const VideoFrame& frame) override;
+  void OnEncoderError(absl::string_view peer_name,
+                      const VideoFrame& frame,
+                      int32_t error_code) override;
+  void OnDecoderError(absl::string_view peer_name,
+                      uint16_t frame_id,
+                      int32_t error_code) override;
   void Stop() override;
   std::string GetStreamLabel(uint16_t frame_id) override;
 
diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc
index 228ab8ac02..9e81c8728b 100644
--- a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc
+++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc
@@ -15,6 +15,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "api/video/i420_buffer.h"
 #include "modules/video_coding/include/video_error_codes.h"
@@ -26,10 +27,12 @@ namespace webrtc_pc_e2e {
 
 QualityAnalyzingVideoDecoder::QualityAnalyzingVideoDecoder(
     int id,
+    absl::string_view peer_name,
     std::unique_ptr<VideoDecoder> delegate,
     EncodedImageDataExtractor* extractor,
     VideoQualityAnalyzerInterface* analyzer)
     : id_(id),
+      peer_name_(peer_name),
       implementation_name_("AnalyzingDecoder-" +
                            std::string(delegate->ImplementationName())),
       delegate_(std::move(delegate)),
@@ -87,7 +90,7 @@ int32_t QualityAnalyzingVideoDecoder::Decode(const EncodedImage& input_image,
   // We can safely dereference |origin_image|, because it can be removed from
   // the map only after |delegate_| Decode method will be invoked. Image will be
   // removed inside DecodedImageCallback, which can be done on separate thread.
-  analyzer_->OnFramePreDecode(out.id, *origin_image);
+  analyzer_->OnFramePreDecode(peer_name_, out.id, *origin_image);
   int32_t result =
       delegate_->Decode(*origin_image, missing_frames, render_time_ms);
   if (result != WEBRTC_VIDEO_CODEC_OK) {
@@ -97,7 +100,7 @@ int32_t QualityAnalyzingVideoDecoder::Decode(const EncodedImage& input_image,
       timestamp_to_frame_id_.erase(input_image.Timestamp());
       decoding_images_.erase(out.id);
     }
-    analyzer_->OnDecoderError(out.id, result);
+    analyzer_->OnDecoderError(peer_name_, out.id, result);
   }
   return result;
 }
@@ -224,15 +227,17 @@ void QualityAnalyzingVideoDecoder::OnFrameDecoded(
   frame->set_id(frame_id);
   VideoQualityAnalyzerInterface::DecoderStats stats;
   stats.decode_time_ms = decode_time_ms;
-  analyzer_->OnFrameDecoded(*frame, stats);
+  analyzer_->OnFrameDecoded(peer_name_, *frame, stats);
 }
 
 QualityAnalyzingVideoDecoderFactory::QualityAnalyzingVideoDecoderFactory(
+    absl::string_view peer_name,
     std::unique_ptr<VideoDecoderFactory> delegate,
     IdGenerator<int>* id_generator,
     EncodedImageDataExtractor* extractor,
     VideoQualityAnalyzerInterface* analyzer)
-    : delegate_(std::move(delegate)),
+    : peer_name_(peer_name),
+      delegate_(std::move(delegate)),
       id_generator_(id_generator),
       extractor_(extractor),
       analyzer_(analyzer) {}
@@ -249,7 +254,8 @@ QualityAnalyzingVideoDecoderFactory::CreateVideoDecoder(
     const SdpVideoFormat& format) {
   std::unique_ptr<VideoDecoder> decoder = delegate_->CreateVideoDecoder(format);
   return std::make_unique<QualityAnalyzingVideoDecoder>(
-      id_generator_->GetNextId(), std::move(decoder), extractor_, analyzer_);
+      id_generator_->GetNextId(), peer_name_, std::move(decoder), extractor_,
+      analyzer_);
 }
 
 std::unique_ptr<VideoDecoder>
@@ -259,7 +265,8 @@ QualityAnalyzingVideoDecoderFactory::LegacyCreateVideoDecoder(
   std::unique_ptr<VideoDecoder> decoder =
       delegate_->LegacyCreateVideoDecoder(format, receive_stream_id);
   return std::make_unique<QualityAnalyzingVideoDecoder>(
-      id_generator_->GetNextId(), std::move(decoder), extractor_, analyzer_);
+      id_generator_->GetNextId(), peer_name_, std::move(decoder), extractor_,
+      analyzer_);
 }
 
 }  // namespace webrtc_pc_e2e
diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h
index 5cbc882226..29fff1832e 100644
--- a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h
+++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h
@@ -16,6 +16,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "api/test/video_quality_analyzer_interface.h"
 #include "api/video/encoded_image.h"
 #include "api/video/video_frame.h"
@@ -53,6 +54,7 @@ class QualityAnalyzingVideoDecoder : public VideoDecoder {
   // be used to distinguish all encoders and decoders inside
   // EncodedImageDataInjector and EncodedImageIdExtracor.
   QualityAnalyzingVideoDecoder(int id,
+                               absl::string_view peer_name,
                                std::unique_ptr<VideoDecoder> delegate,
                                EncodedImageDataExtractor* extractor,
                                VideoQualityAnalyzerInterface* analyzer);
@@ -104,6 +106,7 @@ class QualityAnalyzingVideoDecoder : public VideoDecoder {
                       absl::optional<uint8_t> qp);
 
   const int id_;
+  const std::string peer_name_;
   const std::string implementation_name_;
   std::unique_ptr<VideoDecoder> delegate_;
   EncodedImageDataExtractor* const extractor_;
@@ -129,6 +132,7 @@ class QualityAnalyzingVideoDecoder : public VideoDecoder {
 class QualityAnalyzingVideoDecoderFactory : public VideoDecoderFactory {
  public:
   QualityAnalyzingVideoDecoderFactory(
+      absl::string_view peer_name,
       std::unique_ptr<VideoDecoderFactory> delegate,
       IdGenerator<int>* id_generator,
       EncodedImageDataExtractor* extractor,
@@ -144,6 +148,7 @@ class QualityAnalyzingVideoDecoderFactory : public VideoDecoderFactory {
       const std::string& receive_stream_id) override;
 
  private:
+  const std::string peer_name_;
   std::unique_ptr<VideoDecoderFactory> delegate_;
   IdGenerator<int>* const id_generator_;
   EncodedImageDataExtractor* const extractor_;
diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc
index 2e7b8f4152..4d04a2ccbb 100644
--- a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc
+++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc
@@ -14,6 +14,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "api/video/video_codec_type.h"
 #include "api/video_codecs/video_encoder.h"
 #include "modules/video_coding/include/video_error_codes.h"
@@ -54,12 +55,14 @@ std::pair<uint32_t, uint32_t> GetMinMaxBitratesBps(const VideoCodec& codec,
 
 QualityAnalyzingVideoEncoder::QualityAnalyzingVideoEncoder(
     int id,
+    absl::string_view peer_name,
     std::unique_ptr<VideoEncoder> delegate,
     double bitrate_multiplier,
     std::map<std::string, absl::optional<int>> stream_required_spatial_index,
     EncodedImageDataInjector* injector,
     VideoQualityAnalyzerInterface* analyzer)
     : id_(id),
+      peer_name_(peer_name),
       delegate_(std::move(delegate)),
       bitrate_multiplier_(bitrate_multiplier),
       stream_required_spatial_index_(std::move(stream_required_spatial_index)),
@@ -134,7 +137,7 @@ int32_t QualityAnalyzingVideoEncoder::Encode(
     // images from encoder. So it should be a bug in setup on in the encoder.
     RTC_DCHECK_LT(timestamp_to_frame_id_list_.size(), kMaxFrameInPipelineCount);
   }
-  analyzer_->OnFramePreEncode(frame);
+  analyzer_->OnFramePreEncode(peer_name_, frame);
   int32_t result = delegate_->Encode(frame, frame_types);
   if (result != WEBRTC_VIDEO_CODEC_OK) {
     // If origin encoder failed, then cleanup data for this frame.
@@ -152,7 +155,7 @@ int32_t QualityAnalyzingVideoEncoder::Encode(
         }
       }
     }
-    analyzer_->OnEncoderError(frame, result);
+    analyzer_->OnEncoderError(peer_name_, frame, result);
   }
   return result;
 }
@@ -277,7 +280,7 @@ EncodedImageCallback::Result QualityAnalyzingVideoEncoder::OnEncodedImage(
     // not discarded layers have to be passed.
     VideoQualityAnalyzerInterface::EncoderStats stats;
     stats.target_encode_bitrate = target_encode_bitrate;
-    analyzer_->OnFrameEncoded(frame_id, encoded_image, stats);
+    analyzer_->OnFrameEncoded(peer_name_, frame_id, encoded_image, stats);
   }
 
   // Image data injector injects frame id and discard flag into provided
@@ -298,7 +301,7 @@ EncodedImageCallback::Result QualityAnalyzingVideoEncoder::OnEncodedImage(
 void QualityAnalyzingVideoEncoder::OnDroppedFrame(
     EncodedImageCallback::DropReason reason) {
   rtc::CritScope crit(&lock_);
-  analyzer_->OnFrameDropped(reason);
+  analyzer_->OnFrameDropped(peer_name_, reason);
   RTC_DCHECK(delegate_callback_);
   delegate_callback_->OnDroppedFrame(reason);
 }
@@ -348,13 +351,15 @@ bool QualityAnalyzingVideoEncoder::ShouldDiscard(
 }
 
 QualityAnalyzingVideoEncoderFactory::QualityAnalyzingVideoEncoderFactory(
+    absl::string_view peer_name,
     std::unique_ptr<VideoEncoderFactory> delegate,
     double bitrate_multiplier,
     std::map<std::string, absl::optional<int>> stream_required_spatial_index,
     IdGenerator<int>* id_generator,
     EncodedImageDataInjector* injector,
     VideoQualityAnalyzerInterface* analyzer)
-    : delegate_(std::move(delegate)),
+    : peer_name_(peer_name),
+      delegate_(std::move(delegate)),
       bitrate_multiplier_(bitrate_multiplier),
       stream_required_spatial_index_(std::move(stream_required_spatial_index)),
       id_generator_(id_generator),
@@ -378,9 +383,9 @@ std::unique_ptr<VideoEncoder>
 QualityAnalyzingVideoEncoderFactory::CreateVideoEncoder(
     const SdpVideoFormat& format) {
   return std::make_unique<QualityAnalyzingVideoEncoder>(
-      id_generator_->GetNextId(), delegate_->CreateVideoEncoder(format),
-      bitrate_multiplier_, stream_required_spatial_index_, injector_,
-      analyzer_);
+      id_generator_->GetNextId(), peer_name_,
+      delegate_->CreateVideoEncoder(format), bitrate_multiplier_,
+      stream_required_spatial_index_, injector_, analyzer_);
 }
 
 }  // namespace webrtc_pc_e2e
diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h
index 3307dc7325..fe9e6bb13c 100644
--- a/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h
+++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h
@@ -16,6 +16,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "api/test/video_quality_analyzer_interface.h"
 #include "api/video/video_frame.h"
 #include "api/video_codecs/sdp_video_format.h"
@@ -59,6 +60,7 @@ class QualityAnalyzingVideoEncoder : public VideoEncoder,
   // EncodedImageDataInjector and EncodedImageIdExtracor.
   QualityAnalyzingVideoEncoder(
       int id,
+      absl::string_view peer_name,
       std::unique_ptr<VideoEncoder> delegate,
       double bitrate_multiplier,
       std::map<std::string, absl::optional<int>> stream_required_spatial_index,
@@ -139,6 +141,7 @@ class QualityAnalyzingVideoEncoder : public VideoEncoder,
       RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_);
 
   const int id_;
+  const std::string peer_name_;
   std::unique_ptr<VideoEncoder> delegate_;
   const double bitrate_multiplier_;
   // Contains mapping from stream label to optional spatial index.
@@ -170,6 +173,7 @@ class QualityAnalyzingVideoEncoder : public VideoEncoder,
 class QualityAnalyzingVideoEncoderFactory : public VideoEncoderFactory {
  public:
   QualityAnalyzingVideoEncoderFactory(
+      absl::string_view peer_name,
       std::unique_ptr<VideoEncoderFactory> delegate,
       double bitrate_multiplier,
       std::map<std::string, absl::optional<int>> stream_required_spatial_index,
@@ -186,6 +190,7 @@ class QualityAnalyzingVideoEncoderFactory : public VideoEncoderFactory {
       const SdpVideoFormat& format) override;
 
  private:
+  const std::string peer_name_;
   std::unique_ptr<VideoEncoderFactory> delegate_;
   const double bitrate_multiplier_;
   std::map<std::string, absl::optional<int>> stream_required_spatial_index_;
diff --git a/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.cc b/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.cc
index 074188439b..7410954512 100644
--- a/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.cc
+++ b/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.cc
@@ -14,6 +14,7 @@
 #include <vector>
 
 #include "absl/memory/memory.h"
+#include "absl/strings/string_view.h"
 #include "test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h"
 #include "test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h"
 #include "test/pc/e2e/analyzer/video/simulcast_dummy_buffer_helper.h"
@@ -43,10 +44,12 @@ class AnalyzingFramePreprocessor
     : public test::TestVideoCapturer::FramePreprocessor {
  public:
   AnalyzingFramePreprocessor(
-      std::string stream_label,
+      absl::string_view peer_name,
+      absl::string_view stream_label,
       VideoQualityAnalyzerInterface* analyzer,
       std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>> sinks)
-      : stream_label_(std::move(stream_label)),
+      : peer_name_(peer_name),
+        stream_label_(stream_label),
         analyzer_(analyzer),
         sinks_(std::move(sinks)) {}
   ~AnalyzingFramePreprocessor() override = default;
@@ -54,7 +57,8 @@ class AnalyzingFramePreprocessor
   VideoFrame Preprocess(const VideoFrame& source_frame) override {
     // Copy VideoFrame to be able to set id on it.
     VideoFrame frame = source_frame;
-    uint16_t frame_id = analyzer_->OnFrameCaptured(stream_label_, frame);
+    uint16_t frame_id =
+        analyzer_->OnFrameCaptured(peer_name_, stream_label_, frame);
     frame.set_id(frame_id);
 
     for (auto& sink : sinks_) {
@@ -64,6 +68,7 @@ class AnalyzingFramePreprocessor
   }
 
  private:
+  const std::string peer_name_;
   const std::string stream_label_;
   VideoQualityAnalyzerInterface* const analyzer_;
   const std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>>
@@ -88,26 +93,29 @@ VideoQualityAnalyzerInjectionHelper::~VideoQualityAnalyzerInjectionHelper() =
 
 std::unique_ptr<VideoEncoderFactory>
 VideoQualityAnalyzerInjectionHelper::WrapVideoEncoderFactory(
+    absl::string_view peer_name,
     std::unique_ptr<VideoEncoderFactory> delegate,
     double bitrate_multiplier,
     std::map<std::string, absl::optional<int>> stream_required_spatial_index)
     const {
   return std::make_unique<QualityAnalyzingVideoEncoderFactory>(
-      std::move(delegate), bitrate_multiplier,
+      peer_name, std::move(delegate), bitrate_multiplier,
       std::move(stream_required_spatial_index),
       encoding_entities_id_generator_.get(), injector_, analyzer_.get());
 }
 
 std::unique_ptr<VideoDecoderFactory>
 VideoQualityAnalyzerInjectionHelper::WrapVideoDecoderFactory(
+    absl::string_view peer_name,
     std::unique_ptr<VideoDecoderFactory> delegate) const {
   return std::make_unique<QualityAnalyzingVideoDecoderFactory>(
-      std::move(delegate), encoding_entities_id_generator_.get(), extractor_,
-      analyzer_.get());
+      peer_name, std::move(delegate), encoding_entities_id_generator_.get(),
+      extractor_, analyzer_.get());
 }
 
 std::unique_ptr<test::TestVideoCapturer::FramePreprocessor>
 VideoQualityAnalyzerInjectionHelper::CreateFramePreprocessor(
+    absl::string_view peer_name,
     const VideoConfig& config) {
   std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>> sinks;
   test::VideoFrameWriter* writer =
@@ -125,12 +133,14 @@ VideoQualityAnalyzerInjectionHelper::CreateFramePreprocessor(
     known_video_configs_.insert({*config.stream_label, config});
   }
   return std::make_unique<AnalyzingFramePreprocessor>(
-      std::move(*config.stream_label), analyzer_.get(), std::move(sinks));
+      peer_name, std::move(*config.stream_label), analyzer_.get(),
+      std::move(sinks));
 }
 
 std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>
-VideoQualityAnalyzerInjectionHelper::CreateVideoSink() {
-  return std::make_unique<AnalyzingVideoSink>(this);
+VideoQualityAnalyzerInjectionHelper::CreateVideoSink(
+    absl::string_view peer_name) {
+  return std::make_unique<AnalyzingVideoSink>(peer_name, this);
 }
 
 void VideoQualityAnalyzerInjectionHelper::Start(std::string test_case_name,
@@ -169,12 +179,13 @@ VideoQualityAnalyzerInjectionHelper::MaybeCreateVideoWriter(
   return out;
 }
 
-void VideoQualityAnalyzerInjectionHelper::OnFrame(const VideoFrame& frame) {
+void VideoQualityAnalyzerInjectionHelper::OnFrame(absl::string_view peer_name,
+                                                  const VideoFrame& frame) {
   if (IsDummyFrameBuffer(frame.video_frame_buffer()->ToI420())) {
     // This is dummy frame, so we  don't need to process it further.
     return;
   }
-  analyzer_->OnFrameRendered(frame);
+  analyzer_->OnFrameRendered(peer_name, frame);
   std::string stream_label = analyzer_->GetStreamLabel(frame.id());
   std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>>* sinks =
       PopulateSinks(stream_label);
diff --git a/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h b/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h
index a0daa9ff18..3dfc0af5da 100644
--- a/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h
+++ b/test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h
@@ -15,6 +15,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "api/test/peerconnection_quality_test_fixture.h"
 #include "api/test/stats_observer_interface.h"
 #include "api/test/video_quality_analyzer_interface.h"
@@ -46,6 +47,7 @@ class VideoQualityAnalyzerInjectionHelper : public StatsObserverInterface {
   // Wraps video encoder factory to give video quality analyzer access to frames
   // before encoding and encoded images after.
   std::unique_ptr<VideoEncoderFactory> WrapVideoEncoderFactory(
+      absl::string_view peer_name,
       std::unique_ptr<VideoEncoderFactory> delegate,
       double bitrate_multiplier,
       std::map<std::string, absl::optional<int>> stream_required_spatial_index)
@@ -53,18 +55,24 @@ class VideoQualityAnalyzerInjectionHelper : public StatsObserverInterface {
   // Wraps video decoder factory to give video quality analyzer access to
   // received encoded images and frames, that were decoded from them.
   std::unique_ptr<VideoDecoderFactory> WrapVideoDecoderFactory(
+      absl::string_view peer_name,
       std::unique_ptr<VideoDecoderFactory> delegate) const;
 
   // Creates VideoFrame preprocessor, that will allow video quality analyzer to
   // get access to the captured frames. If provided config also specifies
   // |input_dump_file_name|, video will be written into that file.
   std::unique_ptr<test::TestVideoCapturer::FramePreprocessor>
-  CreateFramePreprocessor(const VideoConfig& config);
+  CreateFramePreprocessor(absl::string_view peer_name,
+                          const VideoConfig& config);
   // Creates sink, that will allow video quality analyzer to get access to
   // the rendered frames. If corresponding video track has
   // |output_dump_file_name| in its VideoConfig, then video also will be written
   // into that file.
-  std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> CreateVideoSink();
+  std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> CreateVideoSink(
+      absl::string_view peer_name);
+  std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> CreateVideoSink() {
+    return CreateVideoSink("unknown");
+  }
 
   void Start(std::string test_case_name, int max_threads_count);
 
@@ -80,20 +88,24 @@ class VideoQualityAnalyzerInjectionHelper : public StatsObserverInterface {
  private:
   class AnalyzingVideoSink final : public rtc::VideoSinkInterface<VideoFrame> {
    public:
-    explicit AnalyzingVideoSink(VideoQualityAnalyzerInjectionHelper* helper)
-        : helper_(helper) {}
+    explicit AnalyzingVideoSink(absl::string_view peer_name,
+                                VideoQualityAnalyzerInjectionHelper* helper)
+        : peer_name_(peer_name), helper_(helper) {}
     ~AnalyzingVideoSink() override = default;
 
-    void OnFrame(const VideoFrame& frame) override { helper_->OnFrame(frame); }
+    void OnFrame(const VideoFrame& frame) override {
+      helper_->OnFrame(peer_name_, frame);
+    }
 
    private:
+    const std::string peer_name_;
     VideoQualityAnalyzerInjectionHelper* const helper_;
   };
 
   test::VideoFrameWriter* MaybeCreateVideoWriter(
       absl::optional<std::string> file_name,
       const PeerConnectionE2EQualityTestFixture::VideoConfig& config);
-  void OnFrame(const VideoFrame& frame);
+  void OnFrame(absl::string_view peer_name, const VideoFrame& frame);
   std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>>*
   PopulateSinks(const std::string& stream_label);
 
diff --git a/test/pc/e2e/media/media_helper.cc b/test/pc/e2e/media/media_helper.cc
index d3fa6ffe03..d1c27838a6 100644
--- a/test/pc/e2e/media/media_helper.cc
+++ b/test/pc/e2e/media/media_helper.cc
@@ -58,7 +58,7 @@ MediaHelper::MaybeAddVideo(TestPeer* peer) {
     std::unique_ptr<test::TestVideoCapturer> capturer = CreateVideoCapturer(
         video_config, peer->ReleaseVideoSource(i),
         video_quality_analyzer_injection_helper_->CreateFramePreprocessor(
-            video_config));
+            params->name.value(), video_config));
     bool is_screencast =
         video_config.content_hint == VideoTrackInterface::ContentHint::kText ||
         video_config.content_hint ==
diff --git a/test/pc/e2e/peer_connection_quality_test.cc b/test/pc/e2e/peer_connection_quality_test.cc
index 17104a90aa..cea4955601 100644
--- a/test/pc/e2e/peer_connection_quality_test.cc
+++ b/test/pc/e2e/peer_connection_quality_test.cc
@@ -14,6 +14,7 @@
 #include <set>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "api/jsep.h"
 #include "api/media_stream_interface.h"
 #include "api/peer_connection_interface.h"
@@ -205,18 +206,21 @@ void PeerConnectionE2EQualityTest::Run(RunParams run_params) {
       RemotePeerAudioConfig::Create(bob_configurer->params()->audio_config);
   absl::optional<RemotePeerAudioConfig> bob_remote_audio_config =
       RemotePeerAudioConfig::Create(alice_configurer->params()->audio_config);
-  // Copy Alice and Bob video configs to correctly pass them into lambdas.
+  // Copy Alice and Bob video configs and names to correctly pass them into
+  // lambdas.
   std::vector<VideoConfig> alice_video_configs =
       alice_configurer->params()->video_configs;
+  std::string alice_name = alice_configurer->params()->name.value();
   std::vector<VideoConfig> bob_video_configs =
       bob_configurer->params()->video_configs;
+  std::string bob_name = bob_configurer->params()->name.value();
 
   alice_ = TestPeerFactory::CreateTestPeer(
       std::move(alice_configurer),
       std::make_unique<FixturePeerConnectionObserver>(
-          [this, bob_video_configs](
+          [this, bob_video_configs, alice_name](
               rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
-            OnTrackCallback(transceiver, bob_video_configs);
+            OnTrackCallback(alice_name, transceiver, bob_video_configs);
           },
           [this]() { StartVideo(alice_video_sources_); }),
       video_quality_analyzer_injection_helper_.get(), signaling_thread.get(),
@@ -225,9 +229,9 @@ void PeerConnectionE2EQualityTest::Run(RunParams run_params) {
   bob_ = TestPeerFactory::CreateTestPeer(
       std::move(bob_configurer),
       std::make_unique<FixturePeerConnectionObserver>(
-          [this, alice_video_configs](
-              rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
-            OnTrackCallback(transceiver, alice_video_configs);
+          [this, alice_video_configs,
+           bob_name](rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+            OnTrackCallback(bob_name, transceiver, alice_video_configs);
           },
           [this]() { StartVideo(bob_video_sources_); }),
       video_quality_analyzer_injection_helper_.get(), signaling_thread.get(),
@@ -371,6 +375,7 @@ void PeerConnectionE2EQualityTest::SetupRequiredFieldTrials(
 }
 
 void PeerConnectionE2EQualityTest::OnTrackCallback(
+    absl::string_view peer_name,
     rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
     std::vector<VideoConfig> remote_video_configs) {
   const rtc::scoped_refptr<MediaStreamTrackInterface>& track =
@@ -387,7 +392,7 @@ void PeerConnectionE2EQualityTest::OnTrackCallback(
   // track->kind() is kVideoKind.
   auto* video_track = static_cast<VideoTrackInterface*>(track.get());
   std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>> video_sink =
-      video_quality_analyzer_injection_helper_->CreateVideoSink();
+      video_quality_analyzer_injection_helper_->CreateVideoSink(peer_name);
   video_track->AddOrUpdateSink(video_sink.get(), rtc::VideoSinkWants());
   output_video_sinks_.push_back(std::move(video_sink));
 }
diff --git a/test/pc/e2e/peer_connection_quality_test.h b/test/pc/e2e/peer_connection_quality_test.h
index 2eb7e708c6..b302e5c51b 100644
--- a/test/pc/e2e/peer_connection_quality_test.h
+++ b/test/pc/e2e/peer_connection_quality_test.h
@@ -15,6 +15,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "api/test/audio_quality_analyzer_interface.h"
 #include "api/test/peerconnection_quality_test_fixture.h"
@@ -80,7 +81,8 @@ class PeerConnectionE2EQualityTest
   // For some functionality some field trials have to be enabled, so we will
   // enable them here.
   void SetupRequiredFieldTrials(const RunParams& run_params);
-  void OnTrackCallback(rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
+  void OnTrackCallback(absl::string_view peer_name,
+                       rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
                        std::vector<VideoConfig> remote_video_configs);
   // Have to be run on the signaling thread.
   void SetupCallOnSignalingThread(const RunParams& run_params);
diff --git a/test/pc/e2e/test_peer_factory.cc b/test/pc/e2e/test_peer_factory.cc
index 455337ef3a..e845dc7e84 100644
--- a/test/pc/e2e/test_peer_factory.cc
+++ b/test/pc/e2e/test_peer_factory.cc
@@ -12,6 +12,7 @@
 #include <utility>
 
 #include "absl/memory/memory.h"
+#include "absl/strings/string_view.h"
 #include "api/task_queue/default_task_queue_factory.h"
 #include "api/video_codecs/builtin_video_decoder_factory.h"
 #include "api/video_codecs/builtin_video_encoder_factory.h"
@@ -172,6 +173,7 @@ std::unique_ptr<cricket::MediaEngineInterface> CreateMediaEngine(
 }
 
 void WrapVideoEncoderFactory(
+    absl::string_view peer_name,
     double bitrate_multiplier,
     std::map<std::string, absl::optional<int>> stream_required_spatial_index,
     PeerConnectionFactoryComponents* pcf_dependencies,
@@ -184,11 +186,12 @@ void WrapVideoEncoderFactory(
   }
   pcf_dependencies->video_encoder_factory =
       video_analyzer_helper->WrapVideoEncoderFactory(
-          std::move(video_encoder_factory), bitrate_multiplier,
+          peer_name, std::move(video_encoder_factory), bitrate_multiplier,
           std::move(stream_required_spatial_index));
 }
 
 void WrapVideoDecoderFactory(
+    absl::string_view peer_name,
     PeerConnectionFactoryComponents* pcf_dependencies,
     VideoQualityAnalyzerInjectionHelper* video_analyzer_helper) {
   std::unique_ptr<VideoDecoderFactory> video_decoder_factory;
@@ -199,7 +202,7 @@ void WrapVideoDecoderFactory(
   }
   pcf_dependencies->video_decoder_factory =
       video_analyzer_helper->WrapVideoDecoderFactory(
-          std::move(video_decoder_factory));
+          peer_name, std::move(video_decoder_factory));
 }
 
 // Creates PeerConnectionFactoryDependencies objects, providing entities
@@ -309,10 +312,11 @@ std::unique_ptr<TestPeer> TestPeerFactory::CreateTestPeer(
           params->audio_config, remote_audio_config, echo_emulation_config,
           components->pcf_dependencies->task_queue_factory.get());
   WrapVideoEncoderFactory(
-      bitrate_multiplier,
+      params->name.value(), bitrate_multiplier,
       CalculateRequiredSpatialIndexPerStream(params->video_configs),
       components->pcf_dependencies.get(), video_analyzer_helper);
-  WrapVideoDecoderFactory(components->pcf_dependencies.get(),
+  WrapVideoDecoderFactory(params->name.value(),
+                          components->pcf_dependencies.get(),
                           video_analyzer_helper);
   std::unique_ptr<cricket::MediaEngineInterface> media_engine =
       CreateMediaEngine(components->pcf_dependencies.get(), audio_device_module,