Reland: Fix race / crash in OnNetworkRouteChanged().

webrtc/tools/event_log_visualizer/analyzer.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/tools/event_log_visualizer/analyzer.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <sstream>
 #include <string>
 #include <utility>
 
 #include "webrtc/api/call/audio_receive_stream.h"
 #include "webrtc/api/call/audio_send_stream.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/rate_statistics.h"
 #include "webrtc/call.h"
 #include "webrtc/common_types.h"
+#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/video_receive_stream.h"
 #include "webrtc/video_send_stream.h"
 
 namespace webrtc {
@@ skipping 1009 matching lines @@
   }
   // Add the data set to the plot.
   plot->series_list_.push_back(std::move(time_series));
   plot->series_list_.push_back(std::move(acked_time_series));
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Bitrate (kbps)", kBottomMargin, kTopMargin);
   plot->SetTitle("Simulated BWE behavior");
 }
 
+// TODO(holmer): Remove once TransportFeedbackAdapter no longer needs a
+// BitrateController.
+class NullBitrateController : public BitrateController {
+ public:
+  ~NullBitrateController() override {}
+  RtcpBandwidthObserver* CreateRtcpBandwidthObserver() override {
+    return nullptr;
+  }
+  void SetStartBitrate(int start_bitrate_bps) override {}
+  void SetMinMaxBitrate(int min_bitrate_bps, int max_bitrate_bps) override {}
+  void SetBitrates(int start_bitrate_bps,
+                   int min_bitrate_bps,
+                   int max_bitrate_bps) override {}
+  void ResetBitrates(int bitrate_bps,
+                     int min_bitrate_bps,
+                     int max_bitrate_bps) override {}
+  void OnDelayBasedBweResult(const DelayBasedBwe::Result& result) override {}
+  bool AvailableBandwidth(uint32_t* bandwidth) const override { return false; }
+  void SetReservedBitrate(uint32_t reserved_bitrate_bps) override {}
+  bool GetNetworkParameters(uint32_t* bitrate,
+                            uint8_t* fraction_loss,
+                            int64_t* rtt) override {
+    return false;
+  }
+  int64_t TimeUntilNextProcess() override { return 0; }
+  void Process() override {}
+};
+
 void EventLogAnalyzer::CreateNetworkDelayFeedbackGraph(Plot* plot) {
   std::map<uint64_t, const LoggedRtpPacket*> outgoing_rtp;
   std::map<uint64_t, const LoggedRtcpPacket*> incoming_rtcp;
 
   for (const auto& kv : rtp_packets_) {
     if (kv.first.GetDirection() == PacketDirection::kOutgoingPacket) {
       for (const LoggedRtpPacket& rtp_packet : kv.second)
         outgoing_rtp.insert(std::make_pair(rtp_packet.timestamp, &rtp_packet));
     }
   }
 
   for (const auto& kv : rtcp_packets_) {
     if (kv.first.GetDirection() == PacketDirection::kIncomingPacket) {
       for (const LoggedRtcpPacket& rtcp_packet : kv.second)
         incoming_rtcp.insert(
             std::make_pair(rtcp_packet.timestamp, &rtcp_packet));
     }
   }
 
   SimulatedClock clock(0);
-  TransportFeedbackAdapter feedback_adapter(&clock);
+  NullBitrateController null_controller;
+  TransportFeedbackAdapter feedback_adapter(&clock, &null_controller);
 
   TimeSeries time_series;
   time_series.label = "Network Delay Change";
   time_series.style = LINE_DOT_GRAPH;
   int64_t estimated_base_delay_ms = std::numeric_limits<int64_t>::max();
 
   auto rtp_iterator = outgoing_rtp.begin();
   auto rtcp_iterator = incoming_rtcp.begin();
 
   auto NextRtpTime = [&]() {
@@ skipping 50 matching lines @@
     point.y -= estimated_base_delay_ms;
   // Add the data set to the plot.
   plot->series_list_.push_back(std::move(time_series));
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Delay (ms)", kBottomMargin, kTopMargin);
   plot->SetTitle("Network Delay Change.");
 }
 }  // namespace plotting
 }  // namespace webrtc