Removed RtcEventLog deps to call:call_interfaces.

webrtc/tools/event_log_visualizer/analyzer.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 355 matching lines @@
       }
       case ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT: {
         rtclog::StreamConfig config;
         parsed_log_.GetAudioSendConfig(i, &config);
         StreamId stream(config.local_ssrc, kOutgoingPacket);
         extension_maps[stream] = RtpHeaderExtensionMap(config.rtp_extensions);
         audio_ssrcs_.insert(stream);
         break;
       }
       case ParsedRtcEventLog::RTP_EVENT: {
-        MediaType media_type;
-        parsed_log_.GetRtpHeader(i, &direction, &media_type, header,
-                                 &header_length, &total_length);
+        parsed_log_.GetRtpHeader(i, &direction, header, &header_length,
+                                 &total_length);
         // Parse header to get SSRC.
         RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
         RTPHeader parsed_header;
         rtp_parser.Parse(&parsed_header);
         StreamId stream(parsed_header.ssrc, direction);
         // Look up the extension_map and parse it again to get the extensions.
         if (extension_maps.count(stream) == 1) {
           RtpHeaderExtensionMap* extension_map = &extension_maps[stream];
           rtp_parser.Parse(&parsed_header, extension_map);
         } else {
           // Use the default extension map.
           // TODO(ivoc): Once configuration of audio streams is stored in the
           //             event log, this can be removed.
           //             Tracking bug: webrtc:6399
           rtp_parser.Parse(&parsed_header, &default_extension_map);
         }
         uint64_t timestamp = parsed_log_.GetTimestamp(i);
         rtp_packets_[stream].push_back(
             LoggedRtpPacket(timestamp, parsed_header, total_length));
         break;
       }
       case ParsedRtcEventLog::RTCP_EVENT: {
         uint8_t packet[IP_PACKET_SIZE];
-        MediaType media_type;
-        parsed_log_.GetRtcpPacket(i, &direction, &media_type, packet,
-                                  &total_length);
+        parsed_log_.GetRtcpPacket(i, &direction, packet, &total_length);
         // Currently incoming RTCP packets are logged twice, both for audio and
         // video. Only act on one of them. Compare against the previous parsed
         // incoming RTCP packet.
         if (direction == webrtc::kIncomingPacket) {
           RTC_CHECK_LE(total_length, IP_PACKET_SIZE);
           if (total_length == last_incoming_rtcp_packet_length &&
               memcmp(last_incoming_rtcp_packet, packet, total_length) == 0) {
             continue;
           } else {
             memcpy(last_incoming_rtcp_packet, packet, total_length);
@@ skipping 483 matching lines @@
   };
   std::vector<TimestampSize> packets;
 
   PacketDirection direction;
   size_t total_length;
 
   // Extract timestamps and sizes for the relevant packets.
   for (size_t i = 0; i < parsed_log_.GetNumberOfEvents(); i++) {
     ParsedRtcEventLog::EventType event_type = parsed_log_.GetEventType(i);
     if (event_type == ParsedRtcEventLog::RTP_EVENT) {
-      parsed_log_.GetRtpHeader(i, &direction, nullptr, nullptr, nullptr,
-                               &total_length);
+      parsed_log_.GetRtpHeader(i, &direction, nullptr, nullptr, &total_length);
       if (direction == desired_direction) {
         uint64_t timestamp = parsed_log_.GetTimestamp(i);
         packets.push_back(TimestampSize(timestamp, total_length));
       }
     }
   }
 
   size_t window_index_begin = 0;
   size_t window_index_end = 0;
   size_t bytes_in_window = 0;
@@ skipping 475 matching lines @@
       },
       audio_network_adaptation_events_, begin_time_, &time_series);
   plot->AppendTimeSeries(std::move(time_series));
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Number of channels (1 (mono)/2 (stereo))",
                           kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder number of channels");
 }
 }  // namespace plotting
 }  // namespace webrtc