Removed RtcEventLog deps to call:call_interfaces.

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.
  */
 
@@ skipping 12 matching lines @@
 // 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"
 #else
 #include "webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
 #endif
 
 namespace webrtc {
 
 namespace {
-MediaType GetRuntimeMediaType(rtclog::MediaType media_type) {
-  switch (media_type) {
-    case rtclog::MediaType::ANY:
-      return MediaType::ANY;
-    case rtclog::MediaType::AUDIO:
-      return MediaType::AUDIO;
-    case rtclog::MediaType::VIDEO:
-      return MediaType::VIDEO;
-    case rtclog::MediaType::DATA:
-      return MediaType::DATA;
-  }
-  RTC_NOTREACHED();
-  return MediaType::ANY;
-}
 
 BandwidthUsage GetRuntimeDetectorState(
     rtclog::DelayBasedBweUpdate::DetectorState detector_state) {
   switch (detector_state) {
     case rtclog::DelayBasedBweUpdate::BWE_NORMAL:
       return BandwidthUsage::kBwNormal;
     case rtclog::DelayBasedBweUpdate::BWE_UNDERUSING:
       return BandwidthUsage::kBwUnderusing;
     case rtclog::DelayBasedBweUpdate::BWE_OVERUSING:
       return BandwidthUsage::kBwOverusing;
@@ skipping 303 matching lines @@
 
   // Check consistency of the parser.
   rtclog::StreamConfig parsed_config;
   parsed_log.GetAudioSendConfig(index, &parsed_config);
   VerifyStreamConfigsAreEqual(config, parsed_config);
 }
 
 void RtcEventLogTestHelper::VerifyRtpEvent(const ParsedRtcEventLog& parsed_log,
                                            size_t index,
                                            PacketDirection direction,
-                                           MediaType media_type,
                                            const uint8_t* header,
                                            size_t header_size,
                                            size_t total_size) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::RTP_EVENT, event.type());
   const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
   ASSERT_TRUE(rtp_packet.has_incoming());
   EXPECT_EQ(direction == kIncomingPacket, rtp_packet.incoming());
-  ASSERT_TRUE(rtp_packet.has_type());
-  EXPECT_EQ(media_type, GetRuntimeMediaType(rtp_packet.type()));
   ASSERT_TRUE(rtp_packet.has_packet_length());
   EXPECT_EQ(total_size, rtp_packet.packet_length());
   ASSERT_TRUE(rtp_packet.has_header());
   ASSERT_EQ(header_size, rtp_packet.header().size());
   for (size_t i = 0; i < header_size; i++) {
     EXPECT_EQ(header[i], static_cast<uint8_t>(rtp_packet.header()[i]));
   }
 
   // Check consistency of the parser.
   PacketDirection parsed_direction;
-  MediaType parsed_media_type;
   uint8_t parsed_header[1500];
   size_t parsed_header_size, parsed_total_size;
-  parsed_log.GetRtpHeader(index, &parsed_direction, &parsed_media_type,
-                          parsed_header, &parsed_header_size,
-                          &parsed_total_size);
+  parsed_log.GetRtpHeader(index, &parsed_direction, parsed_header,
+                          &parsed_header_size, &parsed_total_size);
   EXPECT_EQ(direction, parsed_direction);
-  EXPECT_EQ(media_type, parsed_media_type);
   ASSERT_EQ(header_size, parsed_header_size);
   EXPECT_EQ(0, std::memcmp(header, parsed_header, header_size));
   EXPECT_EQ(total_size, parsed_total_size);
 }
 
 void RtcEventLogTestHelper::VerifyRtcpEvent(const ParsedRtcEventLog& parsed_log,
                                             size_t index,
                                             PacketDirection direction,
-                                            MediaType media_type,
                                             const uint8_t* packet,
                                             size_t total_size) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::RTCP_EVENT, event.type());
   const rtclog::RtcpPacket& rtcp_packet = event.rtcp_packet();
   ASSERT_TRUE(rtcp_packet.has_incoming());
   EXPECT_EQ(direction == kIncomingPacket, rtcp_packet.incoming());
-  ASSERT_TRUE(rtcp_packet.has_type());
-  EXPECT_EQ(media_type, GetRuntimeMediaType(rtcp_packet.type()));
   ASSERT_TRUE(rtcp_packet.has_packet_data());
   ASSERT_EQ(total_size, rtcp_packet.packet_data().size());
   for (size_t i = 0; i < total_size; i++) {
     EXPECT_EQ(packet[i], static_cast<uint8_t>(rtcp_packet.packet_data()[i]));
   }
 
   // Check consistency of the parser.
   PacketDirection parsed_direction;
-  MediaType parsed_media_type;
   uint8_t parsed_packet[1500];
   size_t parsed_total_size;
-  parsed_log.GetRtcpPacket(index, &parsed_direction, &parsed_media_type,
-                           parsed_packet, &parsed_total_size);
+  parsed_log.GetRtcpPacket(index, &parsed_direction, parsed_packet,
+                           &parsed_total_size);
   EXPECT_EQ(direction, parsed_direction);
-  EXPECT_EQ(media_type, parsed_media_type);
   ASSERT_EQ(total_size, parsed_total_size);
   EXPECT_EQ(0, std::memcmp(packet, parsed_packet, total_size));
 }
 
 void RtcEventLogTestHelper::VerifyPlayoutEvent(
     const ParsedRtcEventLog& parsed_log,
     size_t index,
     uint32_t ssrc) {
   const rtclog::Event& event = parsed_log.events_[index];
   ASSERT_TRUE(IsValidBasicEvent(event));
@@ skipping 146 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