diff --git a/media/BUILD.gn b/media/BUILD.gn
index 4e54d5a..23aa0f0 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -61,8 +61,6 @@
     "base/mediaengine.h",
     "base/rtpdataengine.cc",
     "base/rtpdataengine.h",
-    "base/rtpdump.cc",
-    "base/rtpdump.h",
     "base/rtputils.cc",
     "base/rtputils.h",
     "base/streamparams.cc",
@@ -324,7 +322,6 @@
     sources = [
       "base/codec_unittest.cc",
       "base/rtpdataengine_unittest.cc",
-      "base/rtpdump_unittest.cc",
       "base/rtputils_unittest.cc",
       "base/streamparams_unittest.cc",
       "base/turnutils_unittest.cc",
diff --git a/media/base/rtpdump.cc b/media/base/rtpdump.cc
deleted file mode 100644
index 2460859..0000000
--- a/media/base/rtpdump.cc
+++ /dev/null
@@ -1,407 +0,0 @@
-/*
- *  Copyright (c) 2010 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/media/base/rtpdump.h"
-
-#include <ctype.h>
-
-#include <string>
-
-#include "webrtc/base/byteorder.h"
-#include "webrtc/base/logging.h"
-#include "webrtc/base/timeutils.h"
-#include "webrtc/media/base/rtputils.h"
-
-namespace {
-static const int kRtpSsrcOffset = 8;
-const int  kWarnSlowWritesDelayMs = 50;
-}  // namespace
-
-namespace cricket {
-
-const char RtpDumpFileHeader::kFirstLine[] = "#!rtpplay1.0 0.0.0.0/0\n";
-
-RtpDumpFileHeader::RtpDumpFileHeader(int64_t start_ms, uint32_t s, uint16_t p)
-    : start_sec(static_cast<uint32_t>(start_ms / 1000)),
-      start_usec(static_cast<uint32_t>(start_ms % 1000 * 1000)),
-      source(s),
-      port(p),
-      padding(0) {}
-
-void RtpDumpFileHeader::WriteToByteBuffer(rtc::ByteBufferWriter* buf) {
-  buf->WriteUInt32(start_sec);
-  buf->WriteUInt32(start_usec);
-  buf->WriteUInt32(source);
-  buf->WriteUInt16(port);
-  buf->WriteUInt16(padding);
-}
-
-static const int kDefaultTimeIncrease = 30;
-
-bool RtpDumpPacket::IsValidRtpPacket() const {
-  return original_data_len >= data.size() &&
-      data.size() >= kMinRtpPacketLen;
-}
-
-bool RtpDumpPacket::IsValidRtcpPacket() const {
-  return original_data_len == 0 &&
-      data.size() >= kMinRtcpPacketLen;
-}
-
-bool RtpDumpPacket::GetRtpPayloadType(int* pt) const {
-  return IsValidRtpPacket() &&
-      cricket::GetRtpPayloadType(&data[0], data.size(), pt);
-}
-
-bool RtpDumpPacket::GetRtpSeqNum(int* seq_num) const {
-  return IsValidRtpPacket() &&
-      cricket::GetRtpSeqNum(&data[0], data.size(), seq_num);
-}
-
-bool RtpDumpPacket::GetRtpTimestamp(uint32_t* ts) const {
-  return IsValidRtpPacket() &&
-      cricket::GetRtpTimestamp(&data[0], data.size(), ts);
-}
-
-bool RtpDumpPacket::GetRtpSsrc(uint32_t* ssrc) const {
-  return IsValidRtpPacket() &&
-      cricket::GetRtpSsrc(&data[0], data.size(), ssrc);
-}
-
-bool RtpDumpPacket::GetRtpHeaderLen(size_t* len) const {
-  return IsValidRtpPacket() &&
-      cricket::GetRtpHeaderLen(&data[0], data.size(), len);
-}
-
-bool RtpDumpPacket::GetRtcpType(int* type) const {
-  return IsValidRtcpPacket() &&
-      cricket::GetRtcpType(&data[0], data.size(), type);
-}
-
-///////////////////////////////////////////////////////////////////////////
-// Implementation of RtpDumpReader.
-///////////////////////////////////////////////////////////////////////////
-
-void RtpDumpReader::SetSsrc(uint32_t ssrc) {
-  ssrc_override_ = ssrc;
-}
-
-rtc::StreamResult RtpDumpReader::ReadPacket(RtpDumpPacket* packet) {
-  if (!packet) return rtc::SR_ERROR;
-
-  rtc::StreamResult res = rtc::SR_SUCCESS;
-  // Read the file header if it has not been read yet.
-  if (!file_header_read_) {
-    res = ReadFileHeader();
-    if (res != rtc::SR_SUCCESS) {
-      return res;
-    }
-    file_header_read_ = true;
-  }
-
-  // Read the RTP dump packet header.
-  char header[RtpDumpPacket::kHeaderLength];
-  res = stream_->ReadAll(header, sizeof(header), NULL, NULL);
-  if (res != rtc::SR_SUCCESS) {
-    return res;
-  }
-  rtc::ByteBufferReader buf(header, sizeof(header));
-  uint16_t dump_packet_len;
-  uint16_t data_len;
-  // Read the full length of the rtpdump packet, including the rtpdump header.
-  buf.ReadUInt16(&dump_packet_len);
-  packet->data.resize(dump_packet_len - sizeof(header));
-  // Read the size of the original packet, which may be larger than the size in
-  // the rtpdump file, in the event that only part of the packet (perhaps just
-  // the header) was recorded. Note that this field is set to zero for RTCP
-  // packets, which have their own internal length field.
-  buf.ReadUInt16(&data_len);
-  packet->original_data_len = data_len;
-  // Read the elapsed time for this packet (different than RTP timestamp).
-  buf.ReadUInt32(&packet->elapsed_time);
-
-  // Read the actual RTP or RTCP packet.
-  res = stream_->ReadAll(&packet->data[0], packet->data.size(), NULL, NULL);
-
-  // If the packet is RTP and we have specified a ssrc, replace the RTP ssrc
-  // with the specified ssrc.
-  if (res == rtc::SR_SUCCESS &&
-      packet->IsValidRtpPacket() &&
-      ssrc_override_ != 0) {
-    rtc::SetBE32(&packet->data[kRtpSsrcOffset], ssrc_override_);
-  }
-
-  return res;
-}
-
-rtc::StreamResult RtpDumpReader::ReadFileHeader() {
-  // Read the first line.
-  std::string first_line;
-  rtc::StreamResult res = stream_->ReadLine(&first_line);
-  if (res != rtc::SR_SUCCESS) {
-    return res;
-  }
-  if (!CheckFirstLine(first_line)) {
-    return rtc::SR_ERROR;
-  }
-
-  // Read the 16 byte file header.
-  char header[RtpDumpFileHeader::kHeaderLength];
-  res = stream_->ReadAll(header, sizeof(header), NULL, NULL);
-  if (res == rtc::SR_SUCCESS) {
-    rtc::ByteBufferReader buf(header, sizeof(header));
-    uint32_t start_sec;
-    uint32_t start_usec;
-    buf.ReadUInt32(&start_sec);
-    buf.ReadUInt32(&start_usec);
-    start_time_ms_ = static_cast<int64_t>(start_sec * 1000 + start_usec / 1000);
-    // Increase the length by 1 since first_line does not contain the ending \n.
-    first_line_and_file_header_len_ = first_line.size() + 1 + sizeof(header);
-  }
-  return res;
-}
-
-bool RtpDumpReader::CheckFirstLine(const std::string& first_line) {
-  // The first line is like "#!rtpplay1.0 address/port"
-  bool matched = (0 == first_line.find("#!rtpplay1.0 "));
-
-  // The address could be IP or hostname. We do not check it here. Instead, we
-  // check the port at the end.
-  size_t pos = first_line.find('/');
-  matched &= (pos != std::string::npos && pos < first_line.size() - 1);
-  for (++pos; pos < first_line.size() && matched; ++pos) {
-    matched &= (0 != isdigit(first_line[pos]));
-  }
-
-  return matched;
-}
-
-///////////////////////////////////////////////////////////////////////////
-// Implementation of RtpDumpLoopReader.
-///////////////////////////////////////////////////////////////////////////
-RtpDumpLoopReader::RtpDumpLoopReader(rtc::StreamInterface* stream)
-    : RtpDumpReader(stream),
-      loop_count_(0),
-      elapsed_time_increases_(0),
-      rtp_seq_num_increase_(0),
-      rtp_timestamp_increase_(0),
-      packet_count_(0),
-      frame_count_(0),
-      first_elapsed_time_(0),
-      first_rtp_seq_num_(0),
-      first_rtp_timestamp_(0),
-      prev_elapsed_time_(0),
-      prev_rtp_seq_num_(0),
-      prev_rtp_timestamp_(0) {
-}
-
-rtc::StreamResult RtpDumpLoopReader::ReadPacket(RtpDumpPacket* packet) {
-  if (!packet) return rtc::SR_ERROR;
-
-  rtc::StreamResult res = RtpDumpReader::ReadPacket(packet);
-  if (rtc::SR_SUCCESS == res) {
-    if (0 == loop_count_) {
-      // During the first loop, we update the statistics of the input stream.
-      UpdateStreamStatistics(*packet);
-    }
-  } else if (rtc::SR_EOS == res) {
-    if (0 == loop_count_) {
-      // At the end of the first loop, calculate elapsed_time_increases_,
-      // rtp_seq_num_increase_, and rtp_timestamp_increase_, which will be
-      // used during the second and later loops.
-      CalculateIncreases();
-    }
-
-    // Rewind the input stream to the first dump packet and read again.
-    ++loop_count_;
-    if (RewindToFirstDumpPacket()) {
-      res = RtpDumpReader::ReadPacket(packet);
-    }
-  }
-
-  if (rtc::SR_SUCCESS == res && loop_count_ > 0) {
-    // During the second and later loops, we update the elapsed time of the dump
-    // packet. If the dumped packet is a RTP packet, we also update its RTP
-    // sequence number and timestamp.
-    UpdateDumpPacket(packet);
-  }
-
-  return res;
-}
-
-void RtpDumpLoopReader::UpdateStreamStatistics(const RtpDumpPacket& packet) {
-  // Get the RTP sequence number and timestamp of the dump packet.
-  int rtp_seq_num = 0;
-  packet.GetRtpSeqNum(&rtp_seq_num);
-  uint32_t rtp_timestamp = 0;
-  packet.GetRtpTimestamp(&rtp_timestamp);
-
-  // Set the timestamps and sequence number for the first dump packet.
-  if (0 == packet_count_++) {
-    first_elapsed_time_ = packet.elapsed_time;
-    first_rtp_seq_num_ = rtp_seq_num;
-    first_rtp_timestamp_ = rtp_timestamp;
-    // The first packet belongs to a new payload frame.
-    ++frame_count_;
-  } else if (rtp_timestamp != prev_rtp_timestamp_) {
-    // The current and previous packets belong to different payload frames.
-    ++frame_count_;
-  }
-
-  prev_elapsed_time_ = packet.elapsed_time;
-  prev_rtp_timestamp_ = rtp_timestamp;
-  prev_rtp_seq_num_ = rtp_seq_num;
-}
-
-void RtpDumpLoopReader::CalculateIncreases() {
-  // At this time, prev_elapsed_time_, prev_rtp_seq_num_, and
-  // prev_rtp_timestamp_ are values of the last dump packet in the input stream.
-  rtp_seq_num_increase_ = prev_rtp_seq_num_ - first_rtp_seq_num_ + 1;
-  // If we have only one packet or frame, we use the default timestamp
-  // increase. Otherwise, we use the difference between the first and the last
-  // packets or frames.
-  elapsed_time_increases_ = packet_count_ <= 1 ? kDefaultTimeIncrease :
-      (prev_elapsed_time_ - first_elapsed_time_) * packet_count_ /
-      (packet_count_ - 1);
-  rtp_timestamp_increase_ = frame_count_ <= 1 ? kDefaultTimeIncrease :
-      (prev_rtp_timestamp_ - first_rtp_timestamp_) * frame_count_ /
-      (frame_count_ - 1);
-}
-
-void RtpDumpLoopReader::UpdateDumpPacket(RtpDumpPacket* packet) {
-  // Increase the elapsed time of the dump packet.
-  packet->elapsed_time += loop_count_ * elapsed_time_increases_;
-
-  if (packet->IsValidRtpPacket()) {
-    // Get the old RTP sequence number and timestamp.
-    int sequence = 0;
-    packet->GetRtpSeqNum(&sequence);
-    uint32_t timestamp = 0;
-    packet->GetRtpTimestamp(&timestamp);
-    // Increase the RTP sequence number and timestamp.
-    sequence += loop_count_ * rtp_seq_num_increase_;
-    timestamp += loop_count_ * rtp_timestamp_increase_;
-    // Write the updated sequence number and timestamp back to the RTP packet.
-    rtc::ByteBufferWriter buffer;
-    buffer.WriteUInt16(sequence);
-    buffer.WriteUInt32(timestamp);
-    memcpy(&packet->data[2], buffer.Data(), buffer.Length());
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////
-// Implementation of RtpDumpWriter.
-///////////////////////////////////////////////////////////////////////////
-
-RtpDumpWriter::RtpDumpWriter(rtc::StreamInterface* stream)
-    : stream_(stream),
-      packet_filter_(PF_ALL),
-      file_header_written_(false),
-      start_time_ms_(rtc::TimeMillis()),
-      warn_slow_writes_delay_(kWarnSlowWritesDelayMs) {}
-
-void RtpDumpWriter::set_packet_filter(int filter) {
-  packet_filter_ = filter;
-  LOG(LS_INFO) << "RtpDumpWriter set_packet_filter to " << packet_filter_;
-}
-
-uint32_t RtpDumpWriter::GetElapsedTime() const {
-  return static_cast<uint32_t>(rtc::TimeSince(start_time_ms_));
-}
-
-rtc::StreamResult RtpDumpWriter::WriteFileHeader() {
-  rtc::StreamResult res = WriteToStream(
-      RtpDumpFileHeader::kFirstLine,
-      strlen(RtpDumpFileHeader::kFirstLine));
-  if (res != rtc::SR_SUCCESS) {
-    return res;
-  }
-
-  rtc::ByteBufferWriter buf;
-  RtpDumpFileHeader file_header(rtc::TimeMillis(), 0, 0);
-  file_header.WriteToByteBuffer(&buf);
-  return WriteToStream(buf.Data(), buf.Length());
-}
-
-rtc::StreamResult RtpDumpWriter::WritePacket(const void* data,
-                                             size_t data_len,
-                                             uint32_t elapsed,
-                                             bool rtcp) {
-  if (!stream_ || !data || 0 == data_len) return rtc::SR_ERROR;
-
-  rtc::StreamResult res = rtc::SR_SUCCESS;
-  // Write the file header if it has not been written yet.
-  if (!file_header_written_) {
-    res = WriteFileHeader();
-    if (res != rtc::SR_SUCCESS) {
-      return res;
-    }
-    file_header_written_ = true;
-  }
-
-  // Figure out what to write.
-  size_t write_len = FilterPacket(data, data_len, rtcp);
-  if (write_len == 0) {
-    return rtc::SR_SUCCESS;
-  }
-
-  // Write the dump packet header.
-  rtc::ByteBufferWriter buf;
-  buf.WriteUInt16(
-      static_cast<uint16_t>(RtpDumpPacket::kHeaderLength + write_len));
-  buf.WriteUInt16(static_cast<uint16_t>(rtcp ? 0 : data_len));
-  buf.WriteUInt32(elapsed);
-  res = WriteToStream(buf.Data(), buf.Length());
-  if (res != rtc::SR_SUCCESS) {
-    return res;
-  }
-
-  // Write the header or full packet as indicated by write_len.
-  return WriteToStream(data, write_len);
-}
-
-size_t RtpDumpWriter::FilterPacket(const void* data, size_t data_len,
-                                   bool rtcp) {
-  size_t filtered_len = 0;
-  if (!rtcp) {
-    if ((packet_filter_ & PF_RTPPACKET) == PF_RTPPACKET) {
-      // RTP header + payload
-      filtered_len = data_len;
-    } else if ((packet_filter_ & PF_RTPHEADER) == PF_RTPHEADER) {
-      // RTP header only
-      size_t header_len;
-      if (GetRtpHeaderLen(data, data_len, &header_len)) {
-        filtered_len = header_len;
-      }
-    }
-  } else {
-    if ((packet_filter_ & PF_RTCPPACKET) == PF_RTCPPACKET) {
-      // RTCP header + payload
-      filtered_len = data_len;
-    }
-  }
-
-  return filtered_len;
-}
-
-rtc::StreamResult RtpDumpWriter::WriteToStream(
-    const void* data, size_t data_len) {
-  int64_t before = rtc::TimeMillis();
-  rtc::StreamResult result =
-      stream_->WriteAll(data, data_len, NULL, NULL);
-  int64_t delay = rtc::TimeSince(before);
-  if (delay >= warn_slow_writes_delay_) {
-    LOG(LS_WARNING) << "Slow RtpDump: took " << delay << "ms to write "
-                    << data_len << " bytes.";
-  }
-  return result;
-}
-
-}  // namespace cricket
diff --git a/media/base/rtpdump.h b/media/base/rtpdump.h
deleted file mode 100644
index 8ea7800..0000000
--- a/media/base/rtpdump.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- *  Copyright (c) 2010 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.
- */
-
-#ifndef WEBRTC_MEDIA_BASE_RTPDUMP_H_
-#define WEBRTC_MEDIA_BASE_RTPDUMP_H_
-
-#include <string.h>
-
-#include <string>
-#include <vector>
-
-#include "webrtc/base/basictypes.h"
-#include "webrtc/base/bytebuffer.h"
-#include "webrtc/base/constructormagic.h"
-#include "webrtc/base/stream.h"
-
-namespace cricket {
-
-// We use the RTP dump file format compatible to the format used by rtptools
-// (http://www.cs.columbia.edu/irt/software/rtptools/) and Wireshark
-// (http://wiki.wireshark.org/rtpdump). In particular, the file starts with the
-// first line "#!rtpplay1.0 address/port\n", followed by a 16 byte file header.
-// For each packet, the file contains a 8 byte dump packet header, followed by
-// the actual RTP or RTCP packet.
-
-enum RtpDumpPacketFilter {
-  PF_NONE = 0x0,
-  PF_RTPHEADER = 0x1,
-  PF_RTPPACKET = 0x3,  // includes header
-  // PF_RTCPHEADER = 0x4,  // TODO(juberti)
-  PF_RTCPPACKET = 0xC,  // includes header
-  PF_ALL = 0xF
-};
-
-struct RtpDumpFileHeader {
-  RtpDumpFileHeader(int64_t start_ms, uint32_t s, uint16_t p);
-  void WriteToByteBuffer(rtc::ByteBufferWriter* buf);
-
-  static const char kFirstLine[];
-  static const size_t kHeaderLength = 16;
-  uint32_t start_sec;   // start of recording, the seconds part.
-  uint32_t start_usec;  // start of recording, the microseconds part.
-  uint32_t source;      // network source (multicast address).
-  uint16_t port;        // UDP port.
-  uint16_t padding;     // 2 bytes padding.
-};
-
-struct RtpDumpPacket {
-  RtpDumpPacket() {}
-
-  RtpDumpPacket(const void* d, size_t s, uint32_t elapsed, bool rtcp)
-      : elapsed_time(elapsed), original_data_len((rtcp) ? 0 : s) {
-    data.resize(s);
-    memcpy(&data[0], d, s);
-  }
-
-  // In the rtpdump file format, RTCP packets have their data len set to zero,
-  // since RTCP has an internal length field.
-  bool is_rtcp() const { return original_data_len == 0; }
-  bool IsValidRtpPacket() const;
-  bool IsValidRtcpPacket() const;
-  // Get the payload type, sequence number, timestampe, and SSRC of the RTP
-  // packet. Return true and set the output parameter if successful.
-  bool GetRtpPayloadType(int* pt) const;
-  bool GetRtpSeqNum(int* seq_num) const;
-  bool GetRtpTimestamp(uint32_t* ts) const;
-  bool GetRtpSsrc(uint32_t* ssrc) const;
-  bool GetRtpHeaderLen(size_t* len) const;
-  // Get the type of the RTCP packet. Return true and set the output parameter
-  // if successful.
-  bool GetRtcpType(int* type) const;
-
-  static const size_t kHeaderLength = 8;
-  uint32_t elapsed_time;      // Milliseconds since the start of recording.
-  std::vector<uint8_t> data;  // The actual RTP or RTCP packet.
-  size_t original_data_len;  // The original length of the packet; may be
-                             // greater than data.size() if only part of the
-                             // packet was recorded.
-};
-
-class RtpDumpReader {
- public:
-  explicit RtpDumpReader(rtc::StreamInterface* stream)
-      : stream_(stream),
-        file_header_read_(false),
-        first_line_and_file_header_len_(0),
-        start_time_ms_(0),
-        ssrc_override_(0) {
-  }
-  virtual ~RtpDumpReader() {}
-
-  // Use the specified ssrc, rather than the ssrc from dump, for RTP packets.
-  void SetSsrc(uint32_t ssrc);
-  virtual rtc::StreamResult ReadPacket(RtpDumpPacket* packet);
-
- protected:
-  rtc::StreamResult ReadFileHeader();
-  bool RewindToFirstDumpPacket() {
-    return stream_->SetPosition(first_line_and_file_header_len_);
-  }
-
- private:
-  // Check if its matches "#!rtpplay1.0 address/port\n".
-  bool CheckFirstLine(const std::string& first_line);
-
-  rtc::StreamInterface* stream_;
-  bool file_header_read_;
-  size_t first_line_and_file_header_len_;
-  int64_t start_time_ms_;
-  uint32_t ssrc_override_;
-
-  RTC_DISALLOW_COPY_AND_ASSIGN(RtpDumpReader);
-};
-
-// RtpDumpLoopReader reads RTP dump packets from the input stream and rewinds
-// the stream when it ends. RtpDumpLoopReader maintains the elapsed time, the
-// RTP sequence number and the RTP timestamp properly. RtpDumpLoopReader can
-// handle both RTP dump and RTCP dump. We assume that the dump does not mix
-// RTP packets and RTCP packets.
-class RtpDumpLoopReader : public RtpDumpReader {
- public:
-  explicit RtpDumpLoopReader(rtc::StreamInterface* stream);
-  virtual rtc::StreamResult ReadPacket(RtpDumpPacket* packet);
-
- private:
-  // During the first loop, update the statistics, including packet count, frame
-  // count, timestamps, and sequence number, of the input stream.
-  void UpdateStreamStatistics(const RtpDumpPacket& packet);
-
-  // At the end of first loop, calculate elapsed_time_increases_,
-  // rtp_seq_num_increase_, and rtp_timestamp_increase_.
-  void CalculateIncreases();
-
-  // During the second and later loops, update the elapsed time of the dump
-  // packet. If the dumped packet is a RTP packet, update its RTP sequence
-  // number and timestamp as well.
-  void UpdateDumpPacket(RtpDumpPacket* packet);
-
-  int loop_count_;
-  // How much to increase the elapsed time, RTP sequence number, RTP timestampe
-  // for each loop. They are calcualted with the variables below during the
-  // first loop.
-  uint32_t elapsed_time_increases_;
-  int rtp_seq_num_increase_;
-  uint32_t rtp_timestamp_increase_;
-  // How many RTP packets and how many payload frames in the input stream. RTP
-  // packets belong to the same frame have the same RTP timestamp, different
-  // dump timestamp, and different RTP sequence number.
-  uint32_t packet_count_;
-  uint32_t frame_count_;
-  // The elapsed time, RTP sequence number, and RTP timestamp of the first and
-  // the previous dump packets in the input stream.
-  uint32_t first_elapsed_time_;
-  int first_rtp_seq_num_;
-  int64_t first_rtp_timestamp_;
-  uint32_t prev_elapsed_time_;
-  int prev_rtp_seq_num_;
-  int64_t prev_rtp_timestamp_;
-
-  RTC_DISALLOW_COPY_AND_ASSIGN(RtpDumpLoopReader);
-};
-
-class RtpDumpWriter {
- public:
-  explicit RtpDumpWriter(rtc::StreamInterface* stream);
-
-  // Filter to control what packets we actually record.
-  void set_packet_filter(int filter);
-  // Write a RTP or RTCP packet. The parameters data points to the packet and
-  // data_len is its length.
-  rtc::StreamResult WriteRtpPacket(const void* data, size_t data_len) {
-    return WritePacket(data, data_len, GetElapsedTime(), false);
-  }
-  rtc::StreamResult WriteRtcpPacket(const void* data, size_t data_len) {
-    return WritePacket(data, data_len, GetElapsedTime(), true);
-  }
-  rtc::StreamResult WritePacket(const RtpDumpPacket& packet) {
-    return WritePacket(&packet.data[0], packet.data.size(), packet.elapsed_time,
-                       packet.is_rtcp());
-  }
-  uint32_t GetElapsedTime() const;
-
-  bool GetDumpSize(size_t* size) {
-    // Note that we use GetPosition(), rather than GetSize(), to avoid flush the
-    // stream per write.
-    return stream_ && size && stream_->GetPosition(size);
-  }
-
- protected:
-  rtc::StreamResult WriteFileHeader();
-
- private:
-  rtc::StreamResult WritePacket(const void* data,
-                                size_t data_len,
-                                uint32_t elapsed,
-                                bool rtcp);
-  size_t FilterPacket(const void* data, size_t data_len, bool rtcp);
-  rtc::StreamResult WriteToStream(const void* data, size_t data_len);
-
-  rtc::StreamInterface* stream_;
-  int packet_filter_;
-  bool file_header_written_;
-  int64_t start_time_ms_;  // Time when the record starts.
-  // If writing to the stream takes longer than this many ms, log a warning.
-  int64_t warn_slow_writes_delay_;
-  RTC_DISALLOW_COPY_AND_ASSIGN(RtpDumpWriter);
-};
-
-}  // namespace cricket
-
-#endif  // WEBRTC_MEDIA_BASE_RTPDUMP_H_
diff --git a/media/base/rtpdump_unittest.cc b/media/base/rtpdump_unittest.cc
deleted file mode 100644
index 748ceab..0000000
--- a/media/base/rtpdump_unittest.cc
+++ /dev/null
@@ -1,282 +0,0 @@
-/*
- *  Copyright (c) 2004 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 <memory>
-#include <string>
-
-#include "webrtc/base/bytebuffer.h"
-#include "webrtc/base/gunit.h"
-#include "webrtc/base/thread.h"
-#include "webrtc/media/base/rtpdump.h"
-#include "webrtc/media/base/rtputils.h"
-#include "webrtc/media/base/testutils.h"
-
-namespace cricket {
-
-static const uint32_t kTestSsrc = 1;
-
-// Test that we read the correct header fields from the RTP/RTCP packet.
-TEST(RtpDumpTest, ReadRtpDumpPacket) {
-  rtc::ByteBufferWriter rtp_buf;
-  RtpTestUtility::kTestRawRtpPackets[0].WriteToByteBuffer(kTestSsrc, &rtp_buf);
-  RtpDumpPacket rtp_packet(rtp_buf.Data(), rtp_buf.Length(), 0, false);
-
-  int payload_type;
-  int seq_num;
-  uint32_t ts;
-  uint32_t ssrc;
-  int rtcp_type;
-  EXPECT_FALSE(rtp_packet.is_rtcp());
-  EXPECT_TRUE(rtp_packet.IsValidRtpPacket());
-  EXPECT_FALSE(rtp_packet.IsValidRtcpPacket());
-  EXPECT_TRUE(rtp_packet.GetRtpPayloadType(&payload_type));
-  EXPECT_EQ(0, payload_type);
-  EXPECT_TRUE(rtp_packet.GetRtpSeqNum(&seq_num));
-  EXPECT_EQ(0, seq_num);
-  EXPECT_TRUE(rtp_packet.GetRtpTimestamp(&ts));
-  EXPECT_EQ(0U, ts);
-  EXPECT_TRUE(rtp_packet.GetRtpSsrc(&ssrc));
-  EXPECT_EQ(kTestSsrc, ssrc);
-  EXPECT_FALSE(rtp_packet.GetRtcpType(&rtcp_type));
-
-  rtc::ByteBufferWriter rtcp_buf;
-  RtpTestUtility::kTestRawRtcpPackets[0].WriteToByteBuffer(&rtcp_buf);
-  RtpDumpPacket rtcp_packet(rtcp_buf.Data(), rtcp_buf.Length(), 0, true);
-
-  EXPECT_TRUE(rtcp_packet.is_rtcp());
-  EXPECT_FALSE(rtcp_packet.IsValidRtpPacket());
-  EXPECT_TRUE(rtcp_packet.IsValidRtcpPacket());
-  EXPECT_TRUE(rtcp_packet.GetRtcpType(&rtcp_type));
-  EXPECT_EQ(0, rtcp_type);
-}
-
-// Test that we read only the RTP dump file.
-TEST(RtpDumpTest, ReadRtpDumpFile) {
-  RtpDumpPacket packet;
-  rtc::MemoryStream stream;
-  RtpDumpWriter writer(&stream);
-  std::unique_ptr<RtpDumpReader> reader;
-
-  // Write a RTP packet to the stream, which is a valid RTP dump. Next, we will
-  // change the first line to make the RTP dump valid or invalid.
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, false, kTestSsrc, &writer));
-  stream.Rewind();
-  reader.reset(new RtpDumpReader(&stream));
-  EXPECT_EQ(rtc::SR_SUCCESS, reader->ReadPacket(&packet));
-
-  // The first line is correct.
-  stream.Rewind();
-  const char new_line[] = "#!rtpplay1.0 1.1.1.1/1\n";
-  EXPECT_EQ(rtc::SR_SUCCESS,
-            stream.WriteAll(new_line, strlen(new_line), NULL, NULL));
-  stream.Rewind();
-  reader.reset(new RtpDumpReader(&stream));
-  EXPECT_EQ(rtc::SR_SUCCESS, reader->ReadPacket(&packet));
-
-  // The first line is not correct: not started with #!rtpplay1.0.
-  stream.Rewind();
-  const char new_line2[] = "#!rtpplaz1.0 0.0.0.0/0\n";
-  EXPECT_EQ(rtc::SR_SUCCESS,
-            stream.WriteAll(new_line2, strlen(new_line2), NULL, NULL));
-  stream.Rewind();
-  reader.reset(new RtpDumpReader(&stream));
-  EXPECT_EQ(rtc::SR_ERROR, reader->ReadPacket(&packet));
-
-  // The first line is not correct: no port.
-  stream.Rewind();
-  const char new_line3[] = "#!rtpplay1.0 0.0.0.0//\n";
-  EXPECT_EQ(rtc::SR_SUCCESS,
-            stream.WriteAll(new_line3, strlen(new_line3), NULL, NULL));
-  stream.Rewind();
-  reader.reset(new RtpDumpReader(&stream));
-  EXPECT_EQ(rtc::SR_ERROR, reader->ReadPacket(&packet));
-}
-
-// Test that we read the same RTP packets that rtp dump writes.
-TEST(RtpDumpTest, WriteReadSameRtp) {
-  rtc::MemoryStream stream;
-  RtpDumpWriter writer(&stream);
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
-      RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
-  EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
-      RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
-
-  // Check stream has only RtpTestUtility::GetTestPacketCount() packets.
-  RtpDumpPacket packet;
-  RtpDumpReader reader(&stream);
-  for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
-    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
-    uint32_t ssrc;
-    EXPECT_TRUE(GetRtpSsrc(&packet.data[0], packet.data.size(), &ssrc));
-    EXPECT_EQ(kTestSsrc, ssrc);
-  }
-  // No more packets to read.
-  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
-
-  // Rewind the stream and read again with a specified ssrc.
-  stream.Rewind();
-  RtpDumpReader reader_w_ssrc(&stream);
-  const uint32_t send_ssrc = kTestSsrc + 1;
-  reader_w_ssrc.SetSsrc(send_ssrc);
-  for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
-    EXPECT_EQ(rtc::SR_SUCCESS, reader_w_ssrc.ReadPacket(&packet));
-    EXPECT_FALSE(packet.is_rtcp());
-    EXPECT_EQ(packet.original_data_len, packet.data.size());
-    uint32_t ssrc;
-    EXPECT_TRUE(GetRtpSsrc(&packet.data[0], packet.data.size(), &ssrc));
-    EXPECT_EQ(send_ssrc, ssrc);
-  }
-  // No more packets to read.
-  EXPECT_EQ(rtc::SR_EOS, reader_w_ssrc.ReadPacket(&packet));
-}
-
-// Test that we read the same RTCP packets that rtp dump writes.
-TEST(RtpDumpTest, WriteReadSameRtcp) {
-  rtc::MemoryStream stream;
-  RtpDumpWriter writer(&stream);
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
-      RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
-  EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
-      RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
-
-  // Check stream has only RtpTestUtility::GetTestPacketCount() packets.
-  RtpDumpPacket packet;
-  RtpDumpReader reader(&stream);
-  reader.SetSsrc(kTestSsrc + 1);  // Does not affect RTCP packet.
-  for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
-    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
-    EXPECT_TRUE(packet.is_rtcp());
-    EXPECT_EQ(0U, packet.original_data_len);
-  }
-  // No more packets to read.
-  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
-}
-
-// Test dumping only RTP packet headers.
-TEST(RtpDumpTest, WriteReadRtpHeadersOnly) {
-  rtc::MemoryStream stream;
-  RtpDumpWriter writer(&stream);
-  writer.set_packet_filter(PF_RTPHEADER);
-
-  // Write some RTP and RTCP packets. RTP packets should only have headers;
-  // RTCP packets should be eaten.
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
-      RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
-      RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
-  stream.Rewind();
-
-  // Check that only RTP packet headers are present.
-  RtpDumpPacket packet;
-  RtpDumpReader reader(&stream);
-  for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
-    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
-    EXPECT_FALSE(packet.is_rtcp());
-    size_t len = 0;
-    packet.GetRtpHeaderLen(&len);
-    EXPECT_EQ(len, packet.data.size());
-    EXPECT_GT(packet.original_data_len, packet.data.size());
-  }
-  // No more packets to read.
-  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
-}
-
-// Test dumping only RTCP packets.
-TEST(RtpDumpTest, WriteReadRtcpOnly) {
-  rtc::MemoryStream stream;
-  RtpDumpWriter writer(&stream);
-  writer.set_packet_filter(PF_RTCPPACKET);
-
-  // Write some RTP and RTCP packets. RTP packets should be eaten.
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
-      RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
-      RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
-  stream.Rewind();
-
-  // Check that only RTCP packets are present.
-  RtpDumpPacket packet;
-  RtpDumpReader reader(&stream);
-  for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
-    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
-    EXPECT_TRUE(packet.is_rtcp());
-    EXPECT_EQ(0U, packet.original_data_len);
-  }
-  // No more packets to read.
-  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
-}
-
-// Test that RtpDumpLoopReader reads RTP packets continously and the elapsed
-// time, the sequence number, and timestamp are maintained properly.
-TEST(RtpDumpTest, LoopReadRtp) {
-  rtc::MemoryStream stream;
-  RtpDumpWriter writer(&stream);
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
-      RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
-  EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
-      3 * RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
-}
-
-// Test that RtpDumpLoopReader reads RTCP packets continously and the elapsed
-// time is maintained properly.
-TEST(RtpDumpTest, LoopReadRtcp) {
-  rtc::MemoryStream stream;
-  RtpDumpWriter writer(&stream);
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
-      RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
-  EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
-      3 * RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
-}
-
-// Test that RtpDumpLoopReader reads continously from stream with a single RTP
-// packets.
-TEST(RtpDumpTest, LoopReadSingleRtp) {
-  rtc::MemoryStream stream;
-  RtpDumpWriter writer(&stream);
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, false, kTestSsrc, &writer));
-
-  // The regular reader can read only one packet.
-  RtpDumpPacket packet;
-  stream.Rewind();
-  RtpDumpReader reader(&stream);
-  EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
-  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
-
-  // The loop reader reads three packets from the input stream.
-  stream.Rewind();
-  RtpDumpLoopReader loop_reader(&stream);
-  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
-  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
-  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
-}
-
-// Test that RtpDumpLoopReader reads continously from stream with a single RTCP
-// packets.
-TEST(RtpDumpTest, LoopReadSingleRtcp) {
-  rtc::MemoryStream stream;
-  RtpDumpWriter writer(&stream);
-  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, true, kTestSsrc, &writer));
-
-  // The regular reader can read only one packet.
-  RtpDumpPacket packet;
-  stream.Rewind();
-  RtpDumpReader reader(&stream);
-  EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
-  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
-
-  // The loop reader reads three packets from the input stream.
-  stream.Rewind();
-  RtpDumpLoopReader loop_reader(&stream);
-  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
-  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
-  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
-}
-
-}  // namespace cricket
diff --git a/media/base/testutils.cc b/media/base/testutils.cc
index 0af8d16..aa92aea 100644
--- a/media/base/testutils.cc
+++ b/media/base/testutils.cc
@@ -22,7 +22,6 @@
 #include "webrtc/base/stream.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/testutils.h"
-#include "webrtc/media/base/rtpdump.h"
 #include "webrtc/media/base/videocapturer.h"
 
 namespace cricket {
@@ -97,117 +96,6 @@
       0 == memcmp(payload, packet.payload, sizeof(payload));
 }
 
-/////////////////////////////////////////////////////////////////////////
-// Implementation of class RtpTestUtility
-/////////////////////////////////////////////////////////////////////////
-const RawRtpPacket RtpTestUtility::kTestRawRtpPackets[] = {
-    {0x80, 0, 0, 0,  RtpTestUtility::kDefaultSsrc, "RTP frame 0"},
-    {0x80, 0, 1, 30, RtpTestUtility::kDefaultSsrc, "RTP frame 1"},
-    {0x80, 0, 2, 30, RtpTestUtility::kDefaultSsrc, "RTP frame 1"},
-    {0x80, 0, 3, 60, RtpTestUtility::kDefaultSsrc, "RTP frame 2"}
-};
-const RawRtcpPacket RtpTestUtility::kTestRawRtcpPackets[] = {
-    // The Version is 2, the Length is 2, and the payload has 8 bytes.
-    {0x80, 0, 2, "RTCP0000"},
-    {0x80, 0, 2, "RTCP0001"},
-    {0x80, 0, 2, "RTCP0002"},
-    {0x80, 0, 2, "RTCP0003"},
-};
-
-size_t RtpTestUtility::GetTestPacketCount() {
-  return std::min(arraysize(kTestRawRtpPackets),
-                  arraysize(kTestRawRtcpPackets));
-}
-
-bool RtpTestUtility::WriteTestPackets(size_t count,
-                                      bool rtcp,
-                                      uint32_t rtp_ssrc,
-                                      RtpDumpWriter* writer) {
-  if (!writer || count > GetTestPacketCount()) return false;
-
-  bool result = true;
-  uint32_t elapsed_time_ms = 0;
-  for (size_t i = 0; i < count && result; ++i) {
-    rtc::ByteBufferWriter buf;
-    if (rtcp) {
-      kTestRawRtcpPackets[i].WriteToByteBuffer(&buf);
-    } else {
-      kTestRawRtpPackets[i].WriteToByteBuffer(rtp_ssrc, &buf);
-    }
-
-    RtpDumpPacket dump_packet(buf.Data(), buf.Length(), elapsed_time_ms, rtcp);
-    elapsed_time_ms += kElapsedTimeInterval;
-    result &= (rtc::SR_SUCCESS == writer->WritePacket(dump_packet));
-  }
-  return result;
-}
-
-bool RtpTestUtility::VerifyTestPacketsFromStream(size_t count,
-                                                 rtc::StreamInterface* stream,
-                                                 uint32_t ssrc) {
-  if (!stream) return false;
-
-  uint32_t prev_elapsed_time = 0;
-  bool result = true;
-  stream->Rewind();
-  RtpDumpLoopReader reader(stream);
-  for (size_t i = 0; i < count && result; ++i) {
-    // Which loop and which index in the loop are we reading now.
-    size_t loop = i / GetTestPacketCount();
-    size_t index = i % GetTestPacketCount();
-
-    RtpDumpPacket packet;
-    result &= (rtc::SR_SUCCESS == reader.ReadPacket(&packet));
-    // Check the elapsed time of the dump packet.
-    result &= (packet.elapsed_time >= prev_elapsed_time);
-    prev_elapsed_time = packet.elapsed_time;
-
-    // Check the RTP or RTCP packet.
-    rtc::ByteBufferReader buf(reinterpret_cast<const char*>(&packet.data[0]),
-                              packet.data.size());
-    if (packet.is_rtcp()) {
-      // RTCP packet.
-      RawRtcpPacket rtcp_packet;
-      result &= rtcp_packet.ReadFromByteBuffer(&buf);
-      result &= rtcp_packet.EqualsTo(kTestRawRtcpPackets[index]);
-    } else {
-      // RTP packet.
-      RawRtpPacket rtp_packet;
-      result &= rtp_packet.ReadFromByteBuffer(&buf);
-      result &= rtp_packet.SameExceptSeqNumTimestampSsrc(
-          kTestRawRtpPackets[index],
-          static_cast<uint16_t>(kTestRawRtpPackets[index].sequence_number +
-                                loop * GetTestPacketCount()),
-          static_cast<uint32_t>(kTestRawRtpPackets[index].timestamp +
-                                loop * kRtpTimestampIncrease),
-          ssrc);
-    }
-  }
-
-  stream->Rewind();
-  return result;
-}
-
-bool RtpTestUtility::VerifyPacket(const RtpDumpPacket* dump,
-                                  const RawRtpPacket* raw,
-                                  bool header_only) {
-  if (!dump || !raw) return false;
-
-  rtc::ByteBufferWriter buf;
-  raw->WriteToByteBuffer(RtpTestUtility::kDefaultSsrc, &buf);
-
-  if (header_only) {
-    size_t header_len = 0;
-    dump->GetRtpHeaderLen(&header_len);
-    return header_len == dump->data.size() &&
-        buf.Length() > dump->data.size() &&
-        0 == memcmp(buf.Data(), &dump->data[0], dump->data.size());
-  } else {
-    return buf.Length() == dump->data.size() &&
-        0 == memcmp(buf.Data(), &dump->data[0], dump->data.size());
-  }
-}
-
 // Implementation of VideoCaptureListener.
 VideoCapturerListener::VideoCapturerListener(VideoCapturer* capturer)
     : capturer_(capturer),
diff --git a/media/base/testutils.h b/media/base/testutils.h
index 966a25b..b0aacd5 100644
--- a/media/base/testutils.h
+++ b/media/base/testutils.h
@@ -79,43 +79,6 @@
   char payload[16];
 };
 
-class RtpTestUtility {
- public:
-  static size_t GetTestPacketCount();
-
-  // Write the first count number of kTestRawRtcpPackets or kTestRawRtpPackets,
-  // depending on the flag rtcp. If it is RTP, use the specified SSRC. Return
-  // true if successful.
-  static bool WriteTestPackets(size_t count,
-                               bool rtcp,
-                               uint32_t rtp_ssrc,
-                               RtpDumpWriter* writer);
-
-  // Loop read the first count number of packets from the specified stream.
-  // Verify the elapsed time of the dump packets increase monotonically. If the
-  // stream is a RTP stream, verify the RTP sequence number, timestamp, and
-  // payload. If the stream is a RTCP stream, verify the RTCP header and
-  // payload.
-  static bool VerifyTestPacketsFromStream(size_t count,
-                                          rtc::StreamInterface* stream,
-                                          uint32_t ssrc);
-
-  // Verify the dump packet is the same as the raw RTP packet.
-  static bool VerifyPacket(const RtpDumpPacket* dump,
-                           const RawRtpPacket* raw,
-                           bool header_only);
-
-  static const uint32_t kDefaultSsrc = 1;
-  static const uint32_t kRtpTimestampIncrease = 90;
-  static const uint32_t kDefaultTimeIncrease = 30;
-  static const uint32_t kElapsedTimeInterval = 10;
-  static const RawRtpPacket kTestRawRtpPackets[];
-  static const RawRtcpPacket kTestRawRtcpPackets[];
-
- private:
-  RtpTestUtility() {}
-};
-
 // Test helper for testing VideoCapturer implementations.
 class VideoCapturerListener
     : public sigslot::has_slots<>,