Ensure the RtcEventLog parser is backwards compatible

webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc

 /*
  *  Copyright (c) 2016 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 "webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h"
 
 #include <string.h>
 
 #include <string>
+#include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
@@ skipping 204 matching lines @@
   for (int i = 0; i < receiver_config.decoders_size(); i++) {
     ASSERT_TRUE(receiver_config.decoders(i).has_name());
     ASSERT_TRUE(receiver_config.decoders(i).has_payload_type());
     const std::string& decoder_name = receiver_config.decoders(i).name();
     int decoder_type = receiver_config.decoders(i).payload_type();
     EXPECT_EQ(config.codecs[i].payload_name, decoder_name);
     EXPECT_EQ(config.codecs[i].payload_type, decoder_type);
   }
 
   // Check consistency of the parser.
-  rtclog::StreamConfig parsed_config;
-  parsed_log.GetVideoReceiveConfig(index, &parsed_config);
+  rtclog::StreamConfig parsed_config = parsed_log.GetVideoReceiveConfig(index);
   VerifyStreamConfigsAreEqual(config, parsed_config);
 }
 
 void RtcEventLogTestHelper::VerifyVideoSendStreamConfig(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     const rtclog::StreamConfig& config) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::VIDEO_SENDER_CONFIG_EVENT, event.type());
@@ skipping 18 matching lines @@
   ASSERT_TRUE(sender_config.encoder().has_name());
   ASSERT_TRUE(sender_config.encoder().has_payload_type());
   EXPECT_EQ(config.codecs[0].payload_name, sender_config.encoder().name());
   EXPECT_EQ(config.codecs[0].payload_type,
             sender_config.encoder().payload_type());
 
   EXPECT_EQ(config.codecs[0].rtx_payload_type,
             sender_config.rtx_payload_type());
 
   // Check consistency of the parser.
-  rtclog::StreamConfig parsed_config;
-  parsed_log.GetVideoSendConfig(index, &parsed_config);
-  VerifyStreamConfigsAreEqual(config, parsed_config);
+  std::vector<rtclog::StreamConfig> parsed_configs =
+      parsed_log.GetVideoSendConfig(index);
+  ASSERT_EQ(1u, parsed_configs.size());
+  VerifyStreamConfigsAreEqual(config, parsed_configs[0]);
 }
 
 void RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     const rtclog::StreamConfig& config) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT, event.type());
   const rtclog::AudioReceiveConfig& receiver_config =
       event.audio_receiver_config();
   // Check SSRCs.
   ASSERT_TRUE(receiver_config.has_remote_ssrc());
   EXPECT_EQ(config.remote_ssrc, receiver_config.remote_ssrc());
   ASSERT_TRUE(receiver_config.has_local_ssrc());
   EXPECT_EQ(config.local_ssrc, receiver_config.local_ssrc());
   // Check header extensions.
   ASSERT_EQ(static_cast<int>(config.rtp_extensions.size()),
             receiver_config.header_extensions_size());
   for (int i = 0; i < receiver_config.header_extensions_size(); i++) {
     ASSERT_TRUE(receiver_config.header_extensions(i).has_name());
     ASSERT_TRUE(receiver_config.header_extensions(i).has_id());
     const std::string& name = receiver_config.header_extensions(i).name();
     int id = receiver_config.header_extensions(i).id();
     EXPECT_EQ(config.rtp_extensions[i].id, id);
     EXPECT_EQ(config.rtp_extensions[i].uri, name);
   }
 
   // Check consistency of the parser.
-  rtclog::StreamConfig parsed_config;
-  parsed_log.GetAudioReceiveConfig(index, &parsed_config);
+  rtclog::StreamConfig parsed_config = parsed_log.GetAudioReceiveConfig(index);
   EXPECT_EQ(config.remote_ssrc, parsed_config.remote_ssrc);
   EXPECT_EQ(config.local_ssrc, parsed_config.local_ssrc);
   // Check header extensions.
   EXPECT_EQ(config.rtp_extensions.size(), parsed_config.rtp_extensions.size());
   for (size_t i = 0; i < parsed_config.rtp_extensions.size(); i++) {
     EXPECT_EQ(config.rtp_extensions[i].uri,
               parsed_config.rtp_extensions[i].uri);
     EXPECT_EQ(config.rtp_extensions[i].id, parsed_config.rtp_extensions[i].id);
   }
 }
@@ skipping 14 matching lines @@
   for (int i = 0; i < sender_config.header_extensions_size(); i++) {
     ASSERT_TRUE(sender_config.header_extensions(i).has_name());
     ASSERT_TRUE(sender_config.header_extensions(i).has_id());
     const std::string& name = sender_config.header_extensions(i).name();
     int id = sender_config.header_extensions(i).id();
     EXPECT_EQ(config.rtp_extensions[i].id, id);
     EXPECT_EQ(config.rtp_extensions[i].uri, name);
   }
 
   // Check consistency of the parser.
-  rtclog::StreamConfig parsed_config;
-  parsed_log.GetAudioSendConfig(index, &parsed_config);
+  rtclog::StreamConfig parsed_config = parsed_log.GetAudioSendConfig(index);
   VerifyStreamConfigsAreEqual(config, parsed_config);
 }
 
 void RtcEventLogTestHelper::VerifyRtpEvent(const ParsedRtcEventLog& parsed_log,
                                            size_t index,
                                            PacketDirection direction,
                                            const uint8_t* header,
                                            size_t header_size,
                                            size_t total_size) {
   const rtclog::Event& event = parsed_log.events_[index];
@@ skipping 205 matching lines @@
   ASSERT_TRUE(bwe_event.has_id());
   EXPECT_EQ(id, bwe_event.id());
   ASSERT_TRUE(bwe_event.has_result());
   EXPECT_EQ(GetProbeResultType(failure_reason), bwe_event.result());
   ASSERT_FALSE(bwe_event.has_bitrate_bps());
 
   // TODO(philipel): Verify the parser when parsing has been implemented.
 }
 
 }  // namespace webrtc