diff --git a/webrtc/modules/modules.gyp b/webrtc/modules/modules.gyp
index 41db70d85c..4422c33ee7 100644
--- a/webrtc/modules/modules.gyp
+++ b/webrtc/modules/modules.gyp
@@ -215,7 +215,6 @@
             'pacing/packet_router_unittest.cc',
             'remote_bitrate_estimator/bwe_simulations.cc',
             'remote_bitrate_estimator/include/mock/mock_remote_bitrate_observer.h',
-            'remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.h',
             'remote_bitrate_estimator/inter_arrival_unittest.cc',
             'remote_bitrate_estimator/overuse_detector_unittest.cc',
             'remote_bitrate_estimator/rate_statistics_unittest.cc',
diff --git a/webrtc/modules/remote_bitrate_estimator/BUILD.gn b/webrtc/modules/remote_bitrate_estimator/BUILD.gn
index 99c297dda6..5f0be091df 100644
--- a/webrtc/modules/remote_bitrate_estimator/BUILD.gn
+++ b/webrtc/modules/remote_bitrate_estimator/BUILD.gn
@@ -36,11 +36,7 @@ source_set("rbe_components") {
     "overuse_estimator.h",
     "remote_bitrate_estimator_abs_send_time.cc",
     "remote_bitrate_estimator_single_stream.cc",
-    "remote_estimator_proxy.cc",
-    "remote_estimator_proxy.h",
     "send_time_history.cc",
-    "transport_feedback_adapter.cc",
-    "transport_feedback_adapter.h",
   ]
 
   configs += [ "../..:common_config" ]
diff --git a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc
index 5f51bc55e9..4c01098f0b 100644
--- a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc
+++ b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc
@@ -107,7 +107,6 @@ void TransportFeedbackAdapter::OnTransportFeedback(
                       << ". Send time history too small?";
     }
   }
-
   RTC_DCHECK(bitrate_estimator_.get() != nullptr);
   bitrate_estimator_->IncomingPacketFeedbackVector(packet_feedback_vector);
 }
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
index 5e18116c34..9ff7406b4f 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
@@ -111,8 +111,7 @@ enum RTCPPacketType : uint32_t {
   kRtcpRemb = 0x10000,
   kRtcpTransmissionTimeOffset = 0x20000,
   kRtcpXrReceiverReferenceTime = 0x40000,
-  kRtcpXrDlrrReportBlock = 0x80000,
-  kRtcpTransportFeedback = 0x100000,
+  kRtcpXrDlrrReportBlock = 0x80000
 };
 
 enum KeyFrameRequestMethod
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
index eb6d35ed3e..a03af2435f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
@@ -60,11 +60,7 @@ class RtcpFormatRembTest : public ::testing::Test {
   RtcpFormatRembTest()
       : over_use_detector_options_(),
         system_clock_(Clock::GetRealTimeClock()),
-        dummy_rtp_rtcp_impl_(nullptr),
         receive_statistics_(ReceiveStatistics::Create(system_clock_)),
-        rtcp_sender_(nullptr),
-        rtcp_receiver_(nullptr),
-        test_transport_(nullptr),
         remote_bitrate_observer_(),
         remote_bitrate_estimator_(new RemoteBitrateEstimatorSingleStream(
             &remote_bitrate_observer_,
@@ -91,9 +87,9 @@ void RtcpFormatRembTest::SetUp() {
   configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get();
   dummy_rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration);
   rtcp_sender_ =
-      new RTCPSender(false, system_clock_, receive_statistics_.get(), nullptr);
-  rtcp_receiver_ = new RTCPReceiver(system_clock_, false, nullptr, nullptr,
-                                    nullptr, nullptr, dummy_rtp_rtcp_impl_);
+      new RTCPSender(false, system_clock_, receive_statistics_.get(), NULL);
+  rtcp_receiver_ = new RTCPReceiver(system_clock_, false, NULL, NULL, NULL,
+                                    dummy_rtp_rtcp_impl_);
   test_transport_ = new TestTransport(rtcp_receiver_);
 
   EXPECT_EQ(0, rtcp_sender_->RegisterSendTransport(test_transport_));
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
index 3c34957c36..f29540100b 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
@@ -91,9 +91,6 @@ class RtcpPacket {
                            size_t max_length,
                            PacketReadyCallback* callback) const;
 
-  // Size of this packet in bytes (including headers, excluding nested packets).
-  virtual size_t BlockLength() const = 0;
-
  protected:
   RtcpPacket() {}
 
@@ -112,6 +109,7 @@ class RtcpPacket {
                     size_t* index,
                     RtcpPacket::PacketReadyCallback* callback) const;
 
+  virtual size_t BlockLength() const = 0;
   size_t HeaderLength() const;
 
   static const size_t kHeaderLength = 4;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
index 168557d224..4392f52e6a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -17,7 +17,6 @@
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/logging.h"
@@ -30,15 +29,12 @@ using namespace RTCPHelp;
 // The number of RTCP time intervals needed to trigger a timeout.
 const int kRrTimeoutIntervals = 3;
 
-const int64_t kMaxWarningLogIntervalMs = 10000;
-
 RTCPReceiver::RTCPReceiver(
     Clock* clock,
     bool receiver_only,
     RtcpPacketTypeCounterObserver* packet_type_counter_observer,
     RtcpBandwidthObserver* rtcp_bandwidth_observer,
     RtcpIntraFrameObserver* rtcp_intra_frame_observer,
-    TransportFeedbackObserver* transport_feedback_observer,
     ModuleRtpRtcpImpl* owner)
     : TMMBRHelp(),
       _clock(clock),
@@ -50,7 +46,6 @@ RTCPReceiver::RTCPReceiver(
           CriticalSectionWrapper::CreateCriticalSection()),
       _cbRtcpBandwidthObserver(rtcp_bandwidth_observer),
       _cbRtcpIntraFrameObserver(rtcp_intra_frame_observer),
-      _cbTransportFeedbackObserver(transport_feedback_observer),
       _criticalSectionRTCPReceiver(
           CriticalSectionWrapper::CreateCriticalSection()),
       main_ssrc_(0),
@@ -66,9 +61,7 @@ RTCPReceiver::RTCPReceiver(
       _lastReceivedRrMs(0),
       _lastIncreasedSequenceNumberMs(0),
       stats_callback_(NULL),
-      packet_type_counter_observer_(packet_type_counter_observer),
-      num_skipped_packets_(0),
-      last_skipped_packets_warning_(clock->TimeInMilliseconds()) {
+      packet_type_counter_observer_(packet_type_counter_observer) {
   memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
 }
 
@@ -356,9 +349,6 @@ RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation,
             // generic application messages
             HandleAPPItem(*rtcpParser, rtcpPacketInformation);
             break;
-          case RTCPPacketTypes::kTransportFeedback:
-            HandleTransportFeedback(rtcpParser, &rtcpPacketInformation);
-            break;
         default:
             rtcpParser->Iterate();
             break;
@@ -371,19 +361,6 @@ RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation,
           main_ssrc_, packet_type_counter_);
     }
 
-    num_skipped_packets_ += rtcpParser->NumSkippedBlocks();
-
-    int64_t now = _clock->TimeInMilliseconds();
-    if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs &&
-        num_skipped_packets_ > 0) {
-      last_skipped_packets_warning_ = now;
-      LOG(LS_WARNING)
-          << num_skipped_packets_
-          << " RTCP blocks were skipped due to being malformed or of "
-             "unrecognized/unsupported type, during the past "
-          << (kMaxWarningLogIntervalMs / 1000) << " second period.";
-    }
-
     return 0;
 }
 
@@ -1275,17 +1252,6 @@ void RTCPReceiver::HandleAPPItem(RTCPUtility::RTCPParserV2& rtcpParser,
   rtcpParser.Iterate();
 }
 
-void RTCPReceiver::HandleTransportFeedback(
-    RTCPUtility::RTCPParserV2* rtcp_parser,
-    RTCPHelp::RTCPPacketInformation* rtcp_packet_information) {
-  rtcp::RtcpPacket* packet = rtcp_parser->ReleaseRtcpPacket();
-  RTC_DCHECK(packet != nullptr);
-  rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
-  rtcp_packet_information->transport_feedback_.reset(
-      static_cast<rtcp::TransportFeedback*>(packet));
-
-  rtcp_parser->Iterate();
-}
 int32_t RTCPReceiver::UpdateTMMBR() {
   int32_t numBoundingSet = 0;
   uint32_t bitrate = 0;
@@ -1355,11 +1321,11 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
     local_ssrc = main_ssrc_;
   }
   if (!receiver_only_ &&
-      (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSrReq)) {
+      rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSrReq) {
     _rtpRtcp.OnRequestSendReport();
   }
   if (!receiver_only_ &&
-      (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack)) {
+      rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack) {
     if (rtcpPacketInformation.nackSequenceNumbers.size() > 0) {
       LOG(LS_VERBOSE) << "Incoming NACK length: "
                    << rtcpPacketInformation.nackSequenceNumbers.size();
@@ -1410,17 +1376,6 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
             now);
       }
     }
-    if (_cbTransportFeedbackObserver &&
-        (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpTransportFeedback)) {
-      uint32_t media_source_ssrc =
-          rtcpPacketInformation.transport_feedback_->GetMediaSourceSsrc();
-      if (media_source_ssrc == main_ssrc_ ||
-          registered_ssrcs_.find(media_source_ssrc) !=
-              registered_ssrcs_.end()) {
-        _cbTransportFeedbackObserver->OnTransportFeedback(
-            *rtcpPacketInformation.transport_feedback_.get());
-      }
-    }
   }
 
   if (!receiver_only_) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
index 68cf231be1..9392e51d26 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
@@ -34,7 +34,6 @@ public:
               RtcpPacketTypeCounterObserver* packet_type_counter_observer,
               RtcpBandwidthObserver* rtcp_bandwidth_observer,
               RtcpIntraFrameObserver* rtcp_intra_frame_observer,
-              TransportFeedbackObserver* transport_feedback_observer,
               ModuleRtpRtcpImpl* owner);
     virtual ~RTCPReceiver();
 
@@ -217,10 +216,6 @@ protected:
     void HandleAPPItem(RTCPUtility::RTCPParserV2& rtcpParser,
                        RTCPHelp::RTCPPacketInformation& rtcpPacketInformation);
 
-    void HandleTransportFeedback(
-        RTCPUtility::RTCPParserV2* rtcp_parser,
-        RTCPHelp::RTCPPacketInformation* rtcp_packet_information);
-
  private:
   typedef std::map<uint32_t, RTCPHelp::RTCPReceiveInformation*>
       ReceivedInfoMap;
@@ -246,7 +241,6 @@ protected:
   CriticalSectionWrapper* _criticalSectionFeedbacks;
   RtcpBandwidthObserver* const _cbRtcpBandwidthObserver;
   RtcpIntraFrameObserver* const _cbRtcpIntraFrameObserver;
-  TransportFeedbackObserver* const _cbTransportFeedbackObserver;
 
   CriticalSectionWrapper* _criticalSectionRTCPReceiver;
   uint32_t main_ssrc_;
@@ -288,9 +282,6 @@ protected:
   RtcpPacketTypeCounter packet_type_counter_;
 
   RTCPUtility::NackStats nack_stats_;
-
-  size_t num_skipped_packets_;
-  int64_t last_skipped_packets_warning_;
 };
 }  // namespace webrtc
 #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc
index 718990d10b..b86e5cc2d8 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc
@@ -13,7 +13,6 @@
 #include <assert.h>  // assert
 #include <string.h>  // memset
 
-#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 
 namespace webrtc {
@@ -37,7 +36,8 @@ RTCPPacketInformation::RTCPPacketInformation()
       rtp_timestamp(0),
       xr_originator_ssrc(0),
       xr_dlrr_item(false),
-      VoIPMetric(nullptr) {}
+      VoIPMetric(NULL) {
+}
 
 RTCPPacketInformation::~RTCPPacketInformation()
 {
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
index 37b7b88370..790fe819ef 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
@@ -20,9 +20,6 @@
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
-namespace rtcp {
-class TransportFeedback;
-}
 namespace RTCPHelp
 {
 
@@ -87,8 +84,6 @@ public:
     bool xr_dlrr_item;
     RTCPVoIPMetric*  VoIPMetric;
 
-    rtc::scoped_ptr<rtcp::TransportFeedback> transport_feedback_;
-
 private:
     RTC_DISALLOW_COPY_AND_ASSIGN(RTCPPacketInformation);
 };
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index e09c29d72c..6ef2a148fa 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
@@ -33,7 +33,9 @@ namespace {  // Anonymous namespace; hide utility functions and classes.
 class TestTransport : public Transport,
                       public NullRtpData {
  public:
-  explicit TestTransport() : rtcp_receiver_(nullptr) {}
+  explicit TestTransport()
+      : rtcp_receiver_(NULL) {
+  }
   void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) {
     rtcp_receiver_ = rtcp_receiver;
   }
@@ -76,8 +78,8 @@ class RtcpReceiverTest : public ::testing::Test {
     configuration.outgoing_transport = test_transport_;
     configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get();
     rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration);
-    rtcp_receiver_ = new RTCPReceiver(&system_clock_, false, nullptr, nullptr,
-                                      nullptr, nullptr, rtp_rtcp_impl_);
+    rtcp_receiver_ = new RTCPReceiver(&system_clock_, false, NULL, NULL, NULL,
+                                      rtp_rtcp_impl_);
     test_transport_->SetRTCPReceiver(rtcp_receiver_);
   }
   ~RtcpReceiverTest() {
@@ -360,8 +362,7 @@ TEST_F(RtcpReceiverTest, GetRtt) {
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   // No report block received.
-  EXPECT_EQ(
-      -1, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
+  EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
 
   rtcp::ReportBlock rb;
   rb.To(kSourceSsrc);
@@ -373,12 +374,10 @@ TEST_F(RtcpReceiverTest, GetRtt) {
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_EQ(1u, rtcp_packet_info_.report_blocks.size());
-  EXPECT_EQ(
-      0, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
+  EXPECT_EQ(0, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
 
   // Report block not received.
-  EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, nullptr, nullptr, nullptr,
-                                    nullptr));
+  EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, NULL, NULL, NULL, NULL));
 }
 
 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) {
@@ -590,7 +589,7 @@ TEST_F(RtcpReceiverTest, InjectXrVoipPacket) {
   xr.WithVoipMetric(&voip_metric);
   rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
-  ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != nullptr);
+  ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != NULL);
   EXPECT_EQ(kLossRate, rtcp_packet_info_.VoIPMetric->lossRate);
   EXPECT_EQ(kRtcpXrVoipMetric, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
@@ -844,7 +843,7 @@ TEST_F(RtcpReceiverTest, ReceiveReportTimeout) {
 
 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
   // This call is expected to fail because no data has arrived.
-  EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
 }
 
 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
@@ -865,7 +864,7 @@ TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
   rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
 
-  EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
   TMMBRSet candidate_set;
   candidate_set.VerifyAndAllocateSet(1);
   EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set));
@@ -891,7 +890,7 @@ TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
   ssrcs.insert(kMediaFlowSsrc);
   rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
-  EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
 }
 
 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
@@ -912,7 +911,7 @@ TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
   rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
 
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
-  EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
 }
 
 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
@@ -939,7 +938,7 @@ TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
     system_clock_.AdvanceTimeMilliseconds(5000);
   }
   // It is now starttime + 15.
-  EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
   TMMBRSet candidate_set;
   candidate_set.VerifyAndAllocateSet(3);
   EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
@@ -948,7 +947,7 @@ TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
   // seconds, timing out the first packet.
   system_clock_.AdvanceTimeMilliseconds(12000);
   // Odd behaviour: Just counting them does not trigger the timeout.
-  EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
   EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
   EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0));
 }
@@ -1009,7 +1008,7 @@ TEST_F(RtcpReceiverTest, Callbacks) {
   EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss,
                                kCumulativeLoss, kJitter));
 
-  rtcp_receiver_->RegisterRtcpStatisticsCallback(nullptr);
+  rtcp_receiver_->RegisterRtcpStatisticsCallback(NULL);
 
   // Add arbitrary numbers, callback should not be called (retain old values).
   rtcp::ReportBlock rb2;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
index fa6468e519..e0195f1758 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
@@ -33,6 +33,9 @@ namespace webrtc {
 class ModuleRtpRtcpImpl;
 class RTCPReceiver;
 
+namespace rtcp {
+class TransportFeedback;
+}
 class NACKStringBuilder {
  public:
   NACKStringBuilder();
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_utility.cc b/webrtc/modules/rtp_rtcp/source/rtcp_utility.cc
index 6c1deb467e..caffb6342c 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_utility.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_utility.cc
@@ -8,9 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "webrtc/base/checks.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 
 #include <assert.h>
 #include <math.h>   // ceil
@@ -57,7 +55,6 @@ RTCPUtility::RTCPParserV2::RTCPParserV2(const uint8_t* rtcpData,
       _ptrRTCPBlockEnd(NULL),
       _state(ParseState::State_TopLevel),
       _numberOfBlocks(0),
-      num_skipped_blocks_(0),
       _packetType(RTCPPacketTypes::kInvalid) {
   Validate();
 }
@@ -83,9 +80,6 @@ RTCPUtility::RTCPParserV2::Packet() const
     return _packet;
 }
 
-rtcp::RtcpPacket* RTCPUtility::RTCPParserV2::ReleaseRtcpPacket() {
-  return rtcp_packet_.release();
-}
 RTCPUtility::RTCPPacketTypes
 RTCPUtility::RTCPParserV2::Begin()
 {
@@ -153,7 +147,7 @@ RTCPUtility::RTCPParserV2::Iterate()
             IterateAppItem();
             break;
         default:
-          RTC_NOTREACHED() << "Invalid state!";
+            assert(false); // Invalid state!
             break;
         }
     }
@@ -176,7 +170,7 @@ RTCPUtility::RTCPParserV2::IterateTopLevel()
         _ptrRTCPBlockEnd = _ptrRTCPData + header.BlockSize();
         if (_ptrRTCPBlockEnd > _ptrRTCPDataEnd)
         {
-          ++num_skipped_blocks_;
+            // Bad block!
             return;
         }
 
@@ -225,15 +219,16 @@ RTCPUtility::RTCPParserV2::IterateTopLevel()
             ParseIJ();
             return;
         }
-        case PT_RTPFB:
-          FALLTHROUGH();
+        case PT_RTPFB: // Fall through!
         case PT_PSFB:
         {
-          if (!ParseFBCommon(header)) {
-            // Nothing supported found, continue to next block!
-            break;
-          }
-          return;
+            const bool ok = ParseFBCommon(header);
+            if (!ok)
+            {
+                // Nothing supported found, continue to next block!
+                break;
+            }
+            return;
         }
         case PT_APP:
         {
@@ -257,7 +252,6 @@ RTCPUtility::RTCPParserV2::IterateTopLevel()
         }
         default:
             // Not supported! Skip!
-            ++num_skipped_blocks_;
             EndCurrentBlock();
             break;
         }
@@ -1166,26 +1160,28 @@ bool RTCPUtility::RTCPParserV2::ParseXrUnsupportedBlockType(
 }
 
 bool RTCPUtility::RTCPParserV2::ParseFBCommon(const RtcpCommonHeader& header) {
-  RTC_CHECK((header.packet_type == PT_RTPFB) ||
-            (header.packet_type == PT_PSFB));  // Parser logic check
+  assert((header.packet_type == PT_RTPFB) ||
+         (header.packet_type == PT_PSFB));  // Parser logic check
 
     const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
 
-    // 4 * 3, RFC4585 section 6.1
-    if (length < 12) {
-      LOG(LS_WARNING)
-          << "Invalid RTCP packet: Too little data (" << length
-          << " bytes) left in buffer to parse a 12 byte RTPFB/PSFB message.";
+    if (length < 12) // 4 * 3, RFC4585 section 6.1
+    {
+        EndCurrentBlock();
         return false;
     }
 
     _ptrRTCPData += 4; // Skip RTCP header
 
-    uint32_t senderSSRC = ByteReader<uint32_t>::ReadBigEndian(_ptrRTCPData);
-    _ptrRTCPData += 4;
+    uint32_t senderSSRC = *_ptrRTCPData++ << 24;
+    senderSSRC += *_ptrRTCPData++ << 16;
+    senderSSRC += *_ptrRTCPData++ << 8;
+    senderSSRC += *_ptrRTCPData++;
 
-    uint32_t mediaSSRC = ByteReader<uint32_t>::ReadBigEndian(_ptrRTCPData);
-    _ptrRTCPData += 4;
+    uint32_t mediaSSRC = *_ptrRTCPData++ << 24;
+    mediaSSRC += *_ptrRTCPData++ << 16;
+    mediaSSRC += *_ptrRTCPData++ << 8;
+    mediaSSRC += *_ptrRTCPData++;
 
     if (header.packet_type == PT_RTPFB) {
         // Transport layer feedback
@@ -1202,6 +1198,12 @@ bool RTCPUtility::RTCPParserV2::ParseFBCommon(const RtcpCommonHeader& header) {
 
             return true;
         }
+        case 2:
+        {
+            // used to be ACK is this code point, which is removed
+            // conficts with http://tools.ietf.org/html/draft-levin-avt-rtcp-burst-00
+            break;
+        }
         case 3:
         {
             // TMMBR
@@ -1234,23 +1236,10 @@ bool RTCPUtility::RTCPParserV2::ParseFBCommon(const RtcpCommonHeader& header) {
             // Note: No state transition, SR REQ is empty!
             return true;
         }
-        case 15: {
-          _packetType = RTCPPacketTypes::kTransportFeedback;
-          rtcp_packet_ =
-              rtcp::TransportFeedback::ParseFrom(_ptrRTCPData - 12, length);
-          // Since we parse the whole packet here, keep the TopLevel state and
-          // just end the current block.
-          if (rtcp_packet_.get()) {
-            EndCurrentBlock();
-            return true;
-          }
-          break;
-        }
         default:
             break;
         }
-        // Unsupported RTPFB message. Skip and move to next block.
-        ++num_skipped_blocks_;
+        EndCurrentBlock();
         return false;
     } else if (header.packet_type == PT_PSFB) {
         // Payload specific feedback
@@ -1298,11 +1287,14 @@ bool RTCPUtility::RTCPParserV2::ParseFBCommon(const RtcpCommonHeader& header) {
             break;
         }
 
+        EndCurrentBlock();
         return false;
     }
     else
     {
-      RTC_NOTREACHED();
+        assert(false);
+
+        EndCurrentBlock();
         return false;
     }
 }
@@ -1662,10 +1654,6 @@ RTCPUtility::RTCPParserV2::ParseAPPItem()
     return true;
 }
 
-size_t RTCPUtility::RTCPParserV2::NumSkippedBlocks() const {
-  return num_skipped_blocks_;
-}
-
 RTCPUtility::RTCPPacketIterator::RTCPPacketIterator(uint8_t* rtcpData,
                                                     size_t rtcpDataLength)
     : _ptrBegin(rtcpData),
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_utility.h b/webrtc/modules/rtp_rtcp/source/rtcp_utility.h
index f05d512919..73658a01f8 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_utility.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_utility.h
@@ -13,15 +13,11 @@
 
 #include <stddef.h> // size_t, ptrdiff_t
 
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
-namespace rtcp {
-class RtcpPacket;
-}
 namespace RTCPUtility {
 
 class NackStats {
@@ -298,9 +294,6 @@ enum class RTCPPacketTypes {
 
   kApp,
   kAppItem,
-
-  // draft-holmer-rmcat-transport-wide-cc-extensions
-  kTransportFeedback,
 };
 
 struct RTCPRawPacket {
@@ -366,12 +359,10 @@ class RTCPParserV2 {
 
   RTCPPacketTypes PacketType() const;
   const RTCPPacket& Packet() const;
-  rtcp::RtcpPacket* ReleaseRtcpPacket();
   const RTCPRawPacket& RawPacket() const;
   ptrdiff_t LengthLeft() const;
 
   bool IsValid() const;
-  size_t NumSkippedBlocks() const;
 
   RTCPPacketTypes Begin();
   RTCPPacketTypes Iterate();
@@ -463,11 +454,9 @@ class RTCPParserV2 {
 
   ParseState _state;
   uint8_t _numberOfBlocks;
-  size_t num_skipped_blocks_;
 
   RTCPPacketTypes _packetType;
   RTCPPacket _packet;
-  rtc::scoped_ptr<webrtc::rtcp::RtcpPacket> rtcp_packet_;
 };
 
 class RTCPPacketIterator {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index ae4caf7bde..d941201cb1 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -78,7 +78,6 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
                      configuration.rtcp_packet_type_counter_observer,
                      configuration.bandwidth_callback,
                      configuration.intra_frame_callback,
-                     configuration.transport_feedback_callback,
                      this),
       clock_(configuration.clock),
       audio_(configuration.audio),
diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index 7224478e14..00e7279adb 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -15,7 +15,6 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/base/checks.h"
-#include "webrtc/base/event.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/call.h"
 #include "webrtc/frame_callback.h"
@@ -1446,68 +1445,6 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
   tester.RunTest();
 }
 
-TEST_F(EndToEndTest, ReceivesTransportFeedback) {
-  static const int kExtensionId = 5;
-
-  class TransportFeedbackObserver : public test::DirectTransport {
-   public:
-    TransportFeedbackObserver(rtc::Event* done_event) : done_(done_event) {}
-    virtual ~TransportFeedbackObserver() {}
-
-    bool SendRtcp(const uint8_t* data, size_t length) override {
-      RTCPUtility::RTCPParserV2 parser(data, length, true);
-      EXPECT_TRUE(parser.IsValid());
-
-      RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::RTCPPacketTypes::kTransportFeedback) {
-          done_->Set();
-          break;
-        }
-        packet_type = parser.Iterate();
-      }
-
-      return test::DirectTransport::SendRtcp(data, length);
-    }
-
-    rtc::Event* done_;
-  };
-
-  class TransportFeedbackTester : public MultiStreamTest {
-   public:
-    TransportFeedbackTester() : done_(false, false) {}
-    virtual ~TransportFeedbackTester() {}
-
-   protected:
-    void Wait() override {
-      EXPECT_TRUE(done_.Wait(CallTest::kDefaultTimeoutMs));
-    }
-
-    void UpdateSendConfig(
-        size_t stream_index,
-        VideoSendStream::Config* send_config,
-        VideoEncoderConfig* encoder_config,
-        test::FrameGeneratorCapturer** frame_generator) override {
-      send_config->rtp.extensions.push_back(
-          RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
-    }
-
-    void UpdateReceiveConfig(
-        size_t stream_index,
-        VideoReceiveStream::Config* receive_config) override {
-      receive_config->rtp.extensions.push_back(
-          RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
-    }
-
-    virtual test::DirectTransport* CreateReceiveTransport() {
-      return new TransportFeedbackObserver(&done_);
-    }
-
-   private:
-    rtc::Event done_;
-  } tester;
-  tester.RunTest();
-}
 TEST_F(EndToEndTest, ObserversEncodedFrames) {
   class EncodedFrameTestObserver : public EncodedFrameObserver {
    public:
diff --git a/webrtc/video/rampup_tests.cc b/webrtc/video/rampup_tests.cc
index fd60fc4d64..d308f2ddb7 100644
--- a/webrtc/video/rampup_tests.cc
+++ b/webrtc/video/rampup_tests.cc
@@ -11,18 +11,14 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
-#include "webrtc/base/event.h"
-#include "webrtc/modules/pacing/include/packet_router.h"
 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h"
 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h"
-#include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h"
 #include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
-#include "webrtc/system_wrappers/interface/thread_wrapper.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #include "webrtc/video/rampup_tests.h"
 
@@ -74,22 +70,14 @@ StreamObserver::StreamObserver(const SsrcMap& rtx_media_ssrcs,
   rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
   rtp_rtcp_->SetREMBStatus(true);
   rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
-  packet_router_.reset(new PacketRouter());
-  packet_router_->AddRtpModule(rtp_rtcp_.get());
   rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
                                           kAbsSendTimeExtensionId);
   rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
                                           kTransmissionTimeOffsetExtensionId);
-  rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
-                                          kTransportSequenceNumberExtensionId);
   payload_registry_->SetRtxPayloadType(RampUpTest::kSendRtxPayloadType,
                                        RampUpTest::kFakeSendPayloadType);
 }
 
-StreamObserver::~StreamObserver() {
-  packet_router_->RemoveRtpModule(rtp_rtcp_.get());
-}
-
 void StreamObserver::set_expected_bitrate_bps(
     unsigned int expected_bitrate_bps) {
   rtc::CritScope lock(&crit_);
@@ -175,10 +163,6 @@ void StreamObserver::SetRemoteBitrateEstimator(RemoteBitrateEstimator* rbe) {
   remote_bitrate_estimator_.reset(rbe);
 }
 
-PacketRouter* StreamObserver::GetPacketRouter() {
-  return packet_router_.get();
-}
-
 void StreamObserver::ReportResult(const std::string& measurement,
                   size_t value,
                   const std::string& units) {
@@ -387,48 +371,6 @@ EventTypeWrapper LowRateStreamObserver::Wait() {
   return test_done_->Wait(test::CallTest::kLongTimeoutMs);
 }
 
-class SendBitrateAdapter {
- public:
-  static const int64_t kPollIntervalMs = 250;
-
-  SendBitrateAdapter(const Call& call,
-                     const std::vector<uint32_t>& ssrcs,
-                     RemoteBitrateObserver* bitrate_observer)
-      : event_(false, false),
-        call_(call),
-        ssrcs_(ssrcs),
-        bitrate_observer_(bitrate_observer) {
-    RTC_DCHECK(bitrate_observer != nullptr);
-    poller_thread_ = ThreadWrapper::CreateThread(&SendBitrateAdapterThread,
-                                                 this, "SendBitratePoller");
-    RTC_DCHECK(poller_thread_->Start());
-  }
-
-  virtual ~SendBitrateAdapter() {
-    event_.Set();
-    poller_thread_->Stop();
-  }
-
- private:
-  static bool SendBitrateAdapterThread(void* obj) {
-    return static_cast<SendBitrateAdapter*>(obj)->PollStats();
-  }
-
-  bool PollStats() {
-    Call::Stats stats = call_.GetStats();
-
-    bitrate_observer_->OnReceiveBitrateChanged(ssrcs_,
-                                               stats.send_bandwidth_bps);
-    return !event_.Wait(kPollIntervalMs);
-  }
-
-  rtc::Event event_;
-  rtc::scoped_ptr<ThreadWrapper> poller_thread_;
-  const Call& call_;
-  const std::vector<uint32_t> ssrcs_;
-  RemoteBitrateObserver* const bitrate_observer_;
-};
-
 void RampUpTest::RunRampUpTest(size_t num_streams,
                                unsigned int start_bitrate_bps,
                                const std::string& extension_type,
@@ -449,8 +391,6 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
   CreateSendConfig(num_streams, &stream_observer);
   send_config_.rtp.extensions.clear();
 
-  rtc::scoped_ptr<SendBitrateAdapter> send_bitrate_adapter_;
-
   if (extension_type == RtpExtension::kAbsSendTime) {
     stream_observer.SetRemoteBitrateEstimator(
         new RemoteBitrateEstimatorAbsSendTime(
@@ -458,11 +398,6 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
             kRemoteBitrateEstimatorMinBitrateBps));
     send_config_.rtp.extensions.push_back(RtpExtension(
         extension_type.c_str(), kAbsSendTimeExtensionId));
-  } else if (extension_type == RtpExtension::kTransportSequenceNumber) {
-    stream_observer.SetRemoteBitrateEstimator(new RemoteEstimatorProxy(
-        Clock::GetRealTimeClock(), stream_observer.GetPacketRouter()));
-    send_config_.rtp.extensions.push_back(RtpExtension(
-        extension_type.c_str(), kTransportSequenceNumberExtensionId));
   } else {
     stream_observer.SetRemoteBitrateEstimator(
         new RemoteBitrateEstimatorSingleStream(
@@ -514,18 +449,10 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
   CreateStreams();
   CreateFrameGeneratorCapturer();
 
-  if (extension_type == RtpExtension::kTransportSequenceNumber) {
-    send_bitrate_adapter_.reset(
-        new SendBitrateAdapter(*sender_call_.get(), ssrcs, &stream_observer));
-  }
   Start();
 
   EXPECT_EQ(kEventSignaled, stream_observer.Wait());
 
-  // Destroy the SendBitrateAdapter (if any) to stop the poller thread in it,
-  // otherwise we might get a data race with the destruction of the call.
-  send_bitrate_adapter_.reset();
-
   Stop();
   DestroyStreams();
 }
@@ -636,25 +563,4 @@ TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) {
   RunRampUpTest(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime,
                 false, false);
 }
-
-TEST_F(RampUpTest, TransportSequenceNumberSingleStream) {
-  RunRampUpTest(1, 0, RtpExtension::kTransportSequenceNumber, false, false);
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
-  RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, false, false);
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) {
-  RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, true, false);
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) {
-  RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, true, true);
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
-  RunRampUpTest(1, 0.9 * kSingleStreamTargetBps,
-                RtpExtension::kTransportSequenceNumber, false, false);
-}
 }  // namespace webrtc
diff --git a/webrtc/video/rampup_tests.h b/webrtc/video/rampup_tests.h
index 8c18a52eb9..56c5e75a6e 100644
--- a/webrtc/video/rampup_tests.h
+++ b/webrtc/video/rampup_tests.h
@@ -26,11 +26,9 @@ namespace webrtc {
 
 static const int kTransmissionTimeOffsetExtensionId = 6;
 static const int kAbsSendTimeExtensionId = 7;
-static const int kTransportSequenceNumberExtensionId = 8;
 static const unsigned int kSingleStreamTargetBps = 1000000;
 
 class Clock;
-class PacketRouter;
 class ReceiveStatistics;
 class RtpHeaderParser;
 class RTPPayloadRegistry;
@@ -43,7 +41,6 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
   StreamObserver(const SsrcMap& rtx_media_ssrcs,
                  newapi::Transport* feedback_transport,
                  Clock* clock);
-  virtual ~StreamObserver();
 
   void set_expected_bitrate_bps(unsigned int expected_bitrate_bps);
 
@@ -60,8 +57,6 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
 
   void SetRemoteBitrateEstimator(RemoteBitrateEstimator* rbe);
 
-  PacketRouter* GetPacketRouter();
-
  private:
   void ReportResult(const std::string& measurement,
                     size_t value,
@@ -72,7 +67,6 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
   const rtc::scoped_ptr<EventWrapper> test_done_;
   const rtc::scoped_ptr<RtpHeaderParser> rtp_parser_;
   rtc::scoped_ptr<RtpRtcp> rtp_rtcp_;
-  rtc::scoped_ptr<PacketRouter> packet_router_;
   internal::TransportAdapter feedback_transport_;
   const rtc::scoped_ptr<ReceiveStatistics> receive_stats_;
   const rtc::scoped_ptr<RTPPayloadRegistry> payload_registry_;
diff --git a/webrtc/video/screenshare_loopback.cc b/webrtc/video/screenshare_loopback.cc
index 9897783eb9..34f68947f6 100644
--- a/webrtc/video/screenshare_loopback.cc
+++ b/webrtc/video/screenshare_loopback.cc
@@ -139,8 +139,6 @@ int DurationSecs() {
   return static_cast<int>(FLAGS_duration);
 }
 
-DEFINE_bool(send_side_bwe, true, "Use send-side bandwidth estimation");
-
 DEFINE_string(
     force_fieldtrials,
     "",
@@ -164,12 +162,19 @@ void Loopback() {
   call_bitrate_config.max_bitrate_bps = flags::MaxBitrateKbps() * 1000;
 
   VideoQualityTest::Params params{
-      {flags::Width(), flags::Height(), flags::Fps(),
-       flags::MinBitrateKbps() * 1000, flags::TargetBitrateKbps() * 1000,
-       flags::MaxBitrateKbps() * 1000, flags::Codec(),
-       flags::NumTemporalLayers(), flags::MinTransmitBitrateKbps() * 1000,
-       call_bitrate_config, flags::TLDiscardThreshold(),
-       flags::FLAGS_send_side_bwe},
+      {
+        flags::Width(),
+        flags::Height(),
+        flags::Fps(),
+        flags::MinBitrateKbps() * 1000,
+        flags::TargetBitrateKbps() * 1000,
+        flags::MaxBitrateKbps() * 1000,
+        flags::Codec(),
+        flags::NumTemporalLayers(),
+        flags::MinTransmitBitrateKbps() * 1000,
+        call_bitrate_config,
+        flags::TLDiscardThreshold()
+      },
       {},  // Video specific.
       {true, flags::SlideChangeInterval(), flags::ScrollDuration()},
       {"screenshare", 0.0, 0.0, flags::DurationSecs(), flags::OutputFilename()},
diff --git a/webrtc/video/video_loopback.cc b/webrtc/video/video_loopback.cc
index 0dceea82e6..c5e9254c08 100644
--- a/webrtc/video/video_loopback.cc
+++ b/webrtc/video/video_loopback.cc
@@ -140,8 +140,6 @@ int DurationSecs() {
   return static_cast<int>(FLAGS_duration);
 }
 
-DEFINE_bool(send_side_bwe, true, "Use send-side bandwidth estimation");
-
 }  // namespace flags
 
 void Loopback() {
@@ -160,13 +158,19 @@ void Loopback() {
   std::string clip = flags::Clip();
   std::string graph_title = clip.empty() ? "" : "video " + clip;
   VideoQualityTest::Params params{
-      {flags::Width(), flags::Height(), flags::Fps(),
-       flags::MinBitrateKbps() * 1000, flags::TargetBitrateKbps() * 1000,
-       flags::MaxBitrateKbps() * 1000, flags::Codec(),
-       flags::NumTemporalLayers(),
-       0,  // No min transmit bitrate.
-       call_bitrate_config, flags::TLDiscardThreshold(),
-       flags::FLAGS_send_side_bwe},
+      {
+        flags::Width(),
+        flags::Height(),
+        flags::Fps(),
+        flags::MinBitrateKbps() * 1000,
+        flags::TargetBitrateKbps() * 1000,
+        flags::MaxBitrateKbps() * 1000,
+        flags::Codec(),
+        flags::NumTemporalLayers(),
+        0,  // No min transmit bitrate.
+        call_bitrate_config,
+        flags::TLDiscardThreshold()
+      },
       {clip},
       {},  // Screenshare specific.
       {graph_title, 0.0, 0.0, flags::DurationSecs(), flags::OutputFilename()},
diff --git a/webrtc/video/video_quality_test.cc b/webrtc/video/video_quality_test.cc
index 110cb063b5..47c5021685 100644
--- a/webrtc/video/video_quality_test.cc
+++ b/webrtc/video/video_quality_test.cc
@@ -32,8 +32,6 @@
 
 namespace webrtc {
 
-static const int kTransportSeqExtensionId =
-    VideoQualityTest::kAbsSendTimeExtensionId + 1;
 static const int kSendStatsPollingIntervalMs = 1000;
 static const int kPayloadTypeVP8 = 123;
 static const int kPayloadTypeVP9 = 124;
@@ -600,15 +598,6 @@ void VideoQualityTest::SetupFullStack(const Params& params,
   send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
   send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
 
-  send_config_.rtp.extensions.clear();
-  if (params.common.send_side_bwe) {
-    send_config_.rtp.extensions.push_back(RtpExtension(
-        RtpExtension::kTransportSequenceNumber, kTransportSeqExtensionId));
-  } else {
-    send_config_.rtp.extensions.push_back(
-        RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
-  }
-
   // Automatically fill out streams[0] with params.
   VideoStream* stream = &encoder_config_.streams[0];
   stream->width = params.common.width;
diff --git a/webrtc/video/video_quality_test.h b/webrtc/video/video_quality_test.h
index 52ac9e40d9..d6020fa6e9 100644
--- a/webrtc/video/video_quality_test.h
+++ b/webrtc/video/video_quality_test.h
@@ -38,7 +38,6 @@ class VideoQualityTest : public test::CallTest {
       int min_transmit_bps;
       Call::Config::BitrateConfig call_bitrate_config;
       size_t tl_discard_threshold;
-      bool send_side_bwe;
     } common;
     struct {  // Video-specific settings.
       std::string clip_name;
diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc
index 1be63e07d1..2c8d8f85f3 100644
--- a/webrtc/video/video_receive_stream.cc
+++ b/webrtc/video/video_receive_stream.cc
@@ -140,7 +140,7 @@ VideoReceiveStream::VideoReceiveStream(int num_cpu_cores,
       channel_group_(channel_group),
       channel_id_(channel_id) {
   RTC_CHECK(channel_group_->CreateReceiveChannel(
-      channel_id_, &transport_adapter_, num_cpu_cores, config));
+      channel_id_, &transport_adapter_, num_cpu_cores));
 
   vie_channel_ = channel_group_->GetChannel(channel_id_);
 
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 670344854d..721cc9dcac 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -120,7 +120,7 @@ VideoSendStream::VideoSendStream(
   RTC_DCHECK(!config_.rtp.ssrcs.empty());
   RTC_CHECK(channel_group->CreateSendChannel(
       channel_id_, &transport_adapter_, &stats_proxy_,
-      config.pre_encode_callback, num_cpu_cores, config_));
+      config.pre_encode_callback, num_cpu_cores, config_.rtp.ssrcs));
   vie_channel_ = channel_group_->GetChannel(channel_id_);
   vie_encoder_ = channel_group_->GetEncoder(channel_id_);
 
diff --git a/webrtc/video_engine/vie_channel_group.cc b/webrtc/video_engine/vie_channel_group.cc
index 6553ce2e04..42ffafb7d0 100644
--- a/webrtc/video_engine/vie_channel_group.cc
+++ b/webrtc/video_engine/vie_channel_group.cc
@@ -18,7 +18,6 @@
 #include "webrtc/modules/remote_bitrate_estimator/include/send_time_history.h"
 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h"
 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h"
-#include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h"
 #include "webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/utility/interface/process_thread.h"
@@ -146,6 +145,7 @@ ChannelGroup::ChannelGroup(ProcessThread* process_thread)
     : remb_(new VieRemb()),
       bitrate_allocator_(new BitrateAllocator()),
       call_stats_(new CallStats()),
+      encoder_state_feedback_(new EncoderStateFeedback()),
       packet_router_(new PacketRouter()),
       pacer_(new PacedSender(Clock::GetRealTimeClock(),
                              packet_router_.get(),
@@ -153,12 +153,6 @@ ChannelGroup::ChannelGroup(ProcessThread* process_thread)
                              PacedSender::kDefaultPaceMultiplier *
                                  BitrateController::kDefaultStartBitrateKbps,
                              0)),
-      remote_bitrate_estimator_(
-          new WrappingBitrateEstimator(remb_.get(), Clock::GetRealTimeClock())),
-      remote_estimator_proxy_(
-          new RemoteEstimatorProxy(Clock::GetRealTimeClock(),
-                                   packet_router_.get())),
-      encoder_state_feedback_(new EncoderStateFeedback()),
       process_thread_(process_thread),
       pacer_thread_(ProcessThread::Create("PacerThread")),
       // Constructed last as this object calls the provided callback on
@@ -166,12 +160,14 @@ ChannelGroup::ChannelGroup(ProcessThread* process_thread)
       bitrate_controller_(
           BitrateController::CreateBitrateController(Clock::GetRealTimeClock(),
                                                      this)) {
+  remote_bitrate_estimator_.reset(new WrappingBitrateEstimator(
+      remb_.get(), Clock::GetRealTimeClock()));
+
   call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get());
 
   pacer_thread_->RegisterModule(pacer_.get());
   pacer_thread_->Start();
 
-  process_thread->RegisterModule(remote_estimator_proxy_.get());
   process_thread->RegisterModule(remote_bitrate_estimator_.get());
   process_thread->RegisterModule(call_stats_.get());
   process_thread->RegisterModule(bitrate_controller_.get());
@@ -183,10 +179,7 @@ ChannelGroup::~ChannelGroup() {
   process_thread_->DeRegisterModule(bitrate_controller_.get());
   process_thread_->DeRegisterModule(call_stats_.get());
   process_thread_->DeRegisterModule(remote_bitrate_estimator_.get());
-  process_thread_->DeRegisterModule(remote_estimator_proxy_.get());
   call_stats_->DeregisterStatsObserver(remote_bitrate_estimator_.get());
-  if (transport_feedback_adapter_.get())
-    call_stats_->DeregisterStatsObserver(transport_feedback_adapter_.get());
   RTC_DCHECK(channel_map_.empty());
   RTC_DCHECK(!remb_->InUse());
   RTC_DCHECK(vie_encoder_map_.empty());
@@ -197,30 +190,7 @@ bool ChannelGroup::CreateSendChannel(int channel_id,
                                      SendStatisticsProxy* stats_proxy,
                                      I420FrameCallback* pre_encode_callback,
                                      int number_of_cores,
-                                     const VideoSendStream::Config& config) {
-  TransportFeedbackObserver* transport_feedback_observer = nullptr;
-  bool transport_seq_enabled = false;
-  for (const RtpExtension& extension : config.rtp.extensions) {
-    if (extension.name == RtpExtension::kTransportSequenceNumber) {
-      transport_seq_enabled = true;
-      break;
-    }
-  }
-  if (transport_seq_enabled) {
-    if (transport_feedback_adapter_.get() == nullptr) {
-      transport_feedback_adapter_.reset(new TransportFeedbackAdapter(
-          bitrate_controller_->CreateRtcpBandwidthObserver(),
-          Clock::GetRealTimeClock(), process_thread_));
-      transport_feedback_adapter_->SetBitrateEstimator(
-          new RemoteBitrateEstimatorAbsSendTime(
-              transport_feedback_adapter_.get(), Clock::GetRealTimeClock(),
-              RemoteBitrateEstimator::kDefaultMinBitrateBps));
-      call_stats_->RegisterStatsObserver(transport_feedback_adapter_.get());
-    }
-    transport_feedback_observer = transport_feedback_adapter_.get();
-  }
-
-  const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs;
+                                     const std::vector<uint32_t>& ssrcs) {
   RTC_DCHECK(!ssrcs.empty());
   rtc::scoped_ptr<ViEEncoder> vie_encoder(new ViEEncoder(
       channel_id, number_of_cores, process_thread_, stats_proxy,
@@ -230,9 +200,7 @@ bool ChannelGroup::CreateSendChannel(int channel_id,
   }
   ViEEncoder* encoder = vie_encoder.get();
   if (!CreateChannel(channel_id, transport, number_of_cores,
-                     vie_encoder.release(), ssrcs.size(), true,
-                     remote_bitrate_estimator_.get(),
-                     transport_feedback_observer)) {
+                     vie_encoder.release(), ssrcs.size(), true)) {
     return false;
   }
   ViEChannel* channel = channel_map_[channel_id];
@@ -246,27 +214,11 @@ bool ChannelGroup::CreateSendChannel(int channel_id,
   return true;
 }
 
-bool ChannelGroup::CreateReceiveChannel(
-    int channel_id,
-    Transport* transport,
-    int number_of_cores,
-    const VideoReceiveStream::Config& config) {
-  bool send_side_bwe = false;
-  for (const RtpExtension& extension : config.rtp.extensions) {
-    if (extension.name == RtpExtension::kTransportSequenceNumber) {
-      send_side_bwe = true;
-      break;
-    }
-  }
-
-  RemoteBitrateEstimator* bitrate_estimator;
-  if (send_side_bwe) {
-    bitrate_estimator = remote_estimator_proxy_.get();
-  } else {
-    bitrate_estimator = remote_bitrate_estimator_.get();
-  }
-  return CreateChannel(channel_id, transport, number_of_cores, nullptr, 1,
-                       false, bitrate_estimator, nullptr);
+bool ChannelGroup::CreateReceiveChannel(int channel_id,
+                                        Transport* transport,
+                                        int number_of_cores) {
+  return CreateChannel(channel_id, transport, number_of_cores,
+                       nullptr, 1, false);
 }
 
 bool ChannelGroup::CreateChannel(int channel_id,
@@ -274,15 +226,13 @@ bool ChannelGroup::CreateChannel(int channel_id,
                                  int number_of_cores,
                                  ViEEncoder* vie_encoder,
                                  size_t max_rtp_streams,
-                                 bool sender,
-                                 RemoteBitrateEstimator* bitrate_estimator,
-                                 TransportFeedbackObserver* feedback_observer) {
+                                 bool sender) {
   rtc::scoped_ptr<ViEChannel> channel(new ViEChannel(
       number_of_cores, transport, process_thread_,
       encoder_state_feedback_->GetRtcpIntraFrameObserver(),
-      bitrate_controller_->CreateRtcpBandwidthObserver(), feedback_observer,
-      bitrate_estimator, call_stats_->rtcp_rtt_stats(), pacer_.get(),
-      packet_router_.get(), max_rtp_streams, sender));
+      bitrate_controller_->CreateRtcpBandwidthObserver(), nullptr,
+      remote_bitrate_estimator_.get(), call_stats_->rtcp_rtt_stats(),
+      pacer_.get(), packet_router_.get(), max_rtp_streams, sender));
   if (channel->Init() != 0) {
     return false;
   }
diff --git a/webrtc/video_engine/vie_channel_group.h b/webrtc/video_engine/vie_channel_group.h
index e133d1a0b6..91f949085a 100644
--- a/webrtc/video_engine/vie_channel_group.h
+++ b/webrtc/video_engine/vie_channel_group.h
@@ -19,8 +19,6 @@
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
-#include "webrtc/video_receive_stream.h"
-#include "webrtc/video_send_stream.h"
 
 namespace webrtc {
 
@@ -54,11 +52,10 @@ class ChannelGroup : public BitrateObserver {
                          SendStatisticsProxy* stats_proxy,
                          I420FrameCallback* pre_encode_callback,
                          int number_of_cores,
-                         const VideoSendStream::Config& config);
+                         const std::vector<uint32_t>& ssrcs);
   bool CreateReceiveChannel(int channel_id,
                             Transport* transport,
-                            int number_of_cores,
-                            const VideoReceiveStream::Config& config);
+                            int number_of_cores);
   void DeleteChannel(int channel_id);
   ViEChannel* GetChannel(int channel_id) const;
   ViEEncoder* GetEncoder(int channel_id) const;
@@ -86,19 +83,16 @@ class ChannelGroup : public BitrateObserver {
                      int number_of_cores,
                      ViEEncoder* vie_encoder,
                      size_t max_rtp_streams,
-                     bool sender,
-                     RemoteBitrateEstimator* bitrate_estimator,
-                     TransportFeedbackObserver* feedback_observer);
+                     bool sender);
   ViEChannel* PopChannel(int channel_id);
 
   rtc::scoped_ptr<VieRemb> remb_;
   rtc::scoped_ptr<BitrateAllocator> bitrate_allocator_;
   rtc::scoped_ptr<CallStats> call_stats_;
+  rtc::scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_;
+  rtc::scoped_ptr<EncoderStateFeedback> encoder_state_feedback_;
   rtc::scoped_ptr<PacketRouter> packet_router_;
   rtc::scoped_ptr<PacedSender> pacer_;
-  rtc::scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_;
-  rtc::scoped_ptr<RemoteEstimatorProxy> remote_estimator_proxy_;
-  rtc::scoped_ptr<EncoderStateFeedback> encoder_state_feedback_;
   ChannelMap channel_map_;
   // Maps Channel id -> ViEEncoder.
   mutable rtc::CriticalSection encoder_map_crit_;
@@ -109,7 +103,6 @@ class ChannelGroup : public BitrateObserver {
   rtc::scoped_ptr<ProcessThread> pacer_thread_;
 
   rtc::scoped_ptr<BitrateController> bitrate_controller_;
-  rtc::scoped_ptr<TransportFeedbackAdapter> transport_feedback_adapter_;
 };
 
 }  // namespace webrtc