Event log visualizer TimeSeries is now created on the stack and then moved into the vector of serie…

webrtc/tools/event_log_visualizer/analyzer.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 564 matching lines @@
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
       continue;
     }
 
     TimeSeries time_series(GetStreamName(stream_id), BAR_GRAPH);
     ProcessPoints<LoggedRtpPacket>(
         [](const LoggedRtpPacket& packet) -> rtc::Optional<float> {
           return rtc::Optional<float>(packet.total_length);
         },
         packet_stream, begin_time_, &time_series);
-    plot->series_list_.push_back(std::move(time_series));
+    plot->AppendTimeSeries(std::move(time_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Packet size (bytes)", kBottomMargin,
                           kTopMargin);
   if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
     plot->SetTitle("Incoming RTP packets");
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
     plot->SetTitle("Outgoing RTP packets");
   }
@@ skipping 15 matching lines @@
     }
 
     std::string label = label_prefix + " " + GetStreamName(stream_id);
     TimeSeries time_series(label, LINE_STEP_GRAPH);
     for (size_t i = 0; i < packet_stream.size(); i++) {
       float x = static_cast<float>(packet_stream[i].timestamp - begin_time_) /
                 1000000;
       time_series.points.emplace_back(x, i + 1);
     }
 
-    plot->series_list_.push_back(std::move(time_series));
+    plot->AppendTimeSeries(std::move(time_series));
   }
 }
 
 void EventLogAnalyzer::CreateAccumulatedPacketsGraph(
     PacketDirection desired_direction,
     Plot* plot) {
   CreateAccumulatedPacketsTimeSeries(desired_direction, plot, rtp_packets_,
                                      "RTP");
   CreateAccumulatedPacketsTimeSeries(desired_direction, plot, rtcp_packets_,
                                      "RTCP");
@@ skipping 30 matching lines @@
         time_series[ssrc].points.push_back(TimeSeriesPoint(x, y));
         last_playout[ssrc] = timestamp;
       }
     }
   }
 
   // Set labels and put in graph.
   for (auto& kv : time_series) {
     kv.second.label = SsrcToString(kv.first);
     kv.second.style = BAR_GRAPH;
-    plot->series_list_.push_back(std::move(kv.second));
+    plot->AppendTimeSeries(std::move(kv.second));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Time since last playout (ms)", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Audio playout");
 }
 
 // For audio SSRCs, plot the audio level.
 void EventLogAnalyzer::CreateAudioLevelGraph(Plot* plot) {
@@ skipping 12 matching lines @@
         // Here we convert it to dBov.
         float y = static_cast<float>(-packet.header.extension.audioLevel);
         time_series[stream_id].points.emplace_back(TimeSeriesPoint(x, y));
       }
     }
   }
 
   for (auto& series : time_series) {
     series.second.label = GetStreamName(series.first);
     series.second.style = LINE_GRAPH;
-    plot->series_list_.push_back(std::move(series.second));
+    plot->AppendTimeSeries(std::move(series.second));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetYAxis(-127, 0, "Audio level (dBov)", kBottomMargin,
                  kTopMargin);
   plot->SetTitle("Audio level");
 }
 
 // For each SSRC, plot the time between the consecutive playouts.
 void EventLogAnalyzer::CreateSequenceNumberGraph(Plot* plot) {
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != kIncomingPacket ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
       continue;
     }
 
     TimeSeries time_series(GetStreamName(stream_id), BAR_GRAPH);
     ProcessPairs<LoggedRtpPacket, float>(
         [](const LoggedRtpPacket& old_packet,
            const LoggedRtpPacket& new_packet) {
           int64_t diff =
               WrappingDifference(new_packet.header.sequenceNumber,
                                  old_packet.header.sequenceNumber, 1ul << 16);
           return rtc::Optional<float>(diff);
         },
         packet_stream, begin_time_, &time_series);
-    plot->series_list_.push_back(std::move(time_series));
+    plot->AppendTimeSeries(std::move(time_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Difference since last packet", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Sequence number");
 }
 
 void EventLogAnalyzer::CreateIncomingPacketLossGraph(Plot* plot) {
   for (auto& kv : rtp_packets_) {
@@ skipping 36 matching lines @@
       }
       float x = static_cast<float>(t - begin_time_) / 1000000;
       int64_t expected_packets = highest_seq_number - highest_prior_seq_number;
       if (expected_packets > 0) {
         int64_t received_packets = window_index_end - window_index_begin;
         int64_t lost_packets = expected_packets - received_packets;
         float y = static_cast<float>(lost_packets) / expected_packets * 100;
         time_series.points.emplace_back(x, y);
       }
     }
-    plot->series_list_.push_back(std::move(time_series));
+    plot->AppendTimeSeries(std::move(time_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Estimated loss rate (%)", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Estimated incoming loss rate");
 }
 
 void EventLogAnalyzer::CreateDelayChangeGraph(Plot* plot) {
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != kIncomingPacket ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_) ||
         IsAudioSsrc(stream_id) || !IsVideoSsrc(stream_id) ||
         IsRtxSsrc(stream_id)) {
       continue;
     }
 
     TimeSeries capture_time_data(GetStreamName(stream_id) + " capture-time",
                                  BAR_GRAPH);
     ProcessPairs<LoggedRtpPacket, double>(NetworkDelayDiff_CaptureTime,
                                           packet_stream, begin_time_,
                                           &capture_time_data);
-    plot->series_list_.push_back(std::move(capture_time_data));
+    plot->AppendTimeSeries(std::move(capture_time_data));
 
     TimeSeries send_time_data(GetStreamName(stream_id) + " abs-send-time",
                               BAR_GRAPH);
     ProcessPairs<LoggedRtpPacket, double>(NetworkDelayDiff_AbsSendTime,
                                           packet_stream, begin_time_,
                                           &send_time_data);
-    plot->series_list_.push_back(std::move(send_time_data));
+    plot->AppendTimeSeries(std::move(send_time_data));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Latency change (ms)", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Network latency change between consecutive packets");
 }
 
 void EventLogAnalyzer::CreateAccumulatedDelayChangeGraph(Plot* plot) {
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != kIncomingPacket ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_) ||
         IsAudioSsrc(stream_id) || !IsVideoSsrc(stream_id) ||
         IsRtxSsrc(stream_id)) {
       continue;
     }
 
     TimeSeries capture_time_data(GetStreamName(stream_id) + " capture-time",
                                  LINE_GRAPH);
     AccumulatePairs<LoggedRtpPacket, double>(NetworkDelayDiff_CaptureTime,
                                              packet_stream, begin_time_,
                                              &capture_time_data);
-    plot->series_list_.push_back(std::move(capture_time_data));
+    plot->AppendTimeSeries(std::move(capture_time_data));
 
     TimeSeries send_time_data(GetStreamName(stream_id) + " abs-send-time",
                               LINE_GRAPH);
     AccumulatePairs<LoggedRtpPacket, double>(NetworkDelayDiff_AbsSendTime,
                                              packet_stream, begin_time_,
                                              &send_time_data);
-    plot->series_list_.push_back(std::move(send_time_data));
+    plot->AppendTimeSeries(std::move(send_time_data));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Latency change (ms)", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Accumulated network latency change");
 }
 
 // Plot the fraction of packets lost (as perceived by the loss-based BWE).
 void EventLogAnalyzer::CreateFractionLossGraph(Plot* plot) {
-  TimeSeries* time_series =
-      plot->AddTimeSeries("Fraction lost", LINE_DOT_GRAPH);
+  TimeSeries time_series("Fraction lost", LINE_DOT_GRAPH);
   for (auto& bwe_update : bwe_loss_updates_) {
     float x = static_cast<float>(bwe_update.timestamp - begin_time_) / 1000000;
     float y = static_cast<float>(bwe_update.fraction_loss) / 255 * 100;
-    time_series->points.emplace_back(x, y);
+    time_series.points.emplace_back(x, y);
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Percent lost packets", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Reported packet loss");
+  plot->AppendTimeSeries(std::move(time_series));
 }
 
 // Plot the total bandwidth used by all RTP streams.
 void EventLogAnalyzer::CreateTotalBitrateGraph(
     PacketDirection desired_direction,
     Plot* plot) {
   struct TimestampSize {
     TimestampSize(uint64_t t, size_t s) : timestamp(t), size(s) {}
     uint64_t timestamp;
     size_t size;
@@ skipping 14 matching lines @@
         packets.push_back(TimestampSize(timestamp, total_length));
       }
     }
   }
 
   size_t window_index_begin = 0;
   size_t window_index_end = 0;
   size_t bytes_in_window = 0;
 
   // Calculate a moving average of the bitrate and store in a TimeSeries.
-  TimeSeries* time_series = plot->AddTimeSeries("Bitrate", LINE_GRAPH);
+  TimeSeries bitrate_series("Bitrate", LINE_GRAPH);
   for (uint64_t time = begin_time_; time < end_time_ + step_; time += step_) {
     while (window_index_end < packets.size() &&
            packets[window_index_end].timestamp < time) {
       bytes_in_window += packets[window_index_end].size;
       ++window_index_end;
     }
     while (window_index_begin < packets.size() &&
            packets[window_index_begin].timestamp < time - window_duration_) {
       RTC_DCHECK_LE(packets[window_index_begin].size, bytes_in_window);
       bytes_in_window -= packets[window_index_begin].size;
       ++window_index_begin;
     }
     float window_duration_in_seconds =
         static_cast<float>(window_duration_) / 1000000;
     float x = static_cast<float>(time - begin_time_) / 1000000;
     float y = bytes_in_window * 8 / window_duration_in_seconds / 1000;
-    time_series->points.emplace_back(x, y);
+    bitrate_series.points.emplace_back(x, y);
   }
+  plot->AppendTimeSeries(std::move(bitrate_series));
 
   // Overlay the send-side bandwidth estimate over the outgoing bitrate.
   if (desired_direction == kOutgoingPacket) {
-    TimeSeries* loss_series =
-        plot->AddTimeSeries("Loss-based estimate", LINE_STEP_GRAPH);
+    TimeSeries loss_series("Loss-based estimate", LINE_STEP_GRAPH);
     for (auto& loss_update : bwe_loss_updates_) {
       float x =
           static_cast<float>(loss_update.timestamp - begin_time_) / 1000000;
       float y = static_cast<float>(loss_update.new_bitrate) / 1000;
-      loss_series->points.emplace_back(x, y);
+      loss_series.points.emplace_back(x, y);
     }
 
-    TimeSeries* delay_series =
-        plot->AddTimeSeries("Delay-based estimate", LINE_STEP_GRAPH);
+    TimeSeries delay_series("Delay-based estimate", LINE_STEP_GRAPH);
     for (auto& delay_update : bwe_delay_updates_) {
       float x =
           static_cast<float>(delay_update.timestamp - begin_time_) / 1000000;
       float y = static_cast<float>(delay_update.bitrate_bps) / 1000;
-      delay_series->points.emplace_back(x, y);
+      delay_series.points.emplace_back(x, y);
     }
 
-    TimeSeries* created_series =
-        plot->AddTimeSeries("Probe cluster created.", DOT_GRAPH);
+    TimeSeries created_series("Probe cluster created.", DOT_GRAPH);
     for (auto& cluster : bwe_probe_cluster_created_events_) {
       float x = static_cast<float>(cluster.timestamp - begin_time_) / 1000000;
       float y = static_cast<float>(cluster.bitrate_bps) / 1000;
-      created_series->points.emplace_back(x, y);
+      created_series.points.emplace_back(x, y);
     }
 
-    TimeSeries* result_series =
-        plot->AddTimeSeries("Probing results.", DOT_GRAPH);
+    TimeSeries result_series("Probing results.", DOT_GRAPH);
     for (auto& result : bwe_probe_result_events_) {
       if (result.bitrate_bps) {
         float x = static_cast<float>(result.timestamp - begin_time_) / 1000000;
         float y = static_cast<float>(*result.bitrate_bps) / 1000;
-        result_series->points.emplace_back(x, y);
+        result_series.points.emplace_back(x, y);
       }
     }
+
+    plot->AppendTimeSeries(std::move(loss_series));
+    plot->AppendTimeSeries(std::move(delay_series));
+    plot->AppendTimeSeries(std::move(created_series));
+    plot->AppendTimeSeries(std::move(result_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin);
   if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
     plot->SetTitle("Incoming RTP bitrate");
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
     plot->SetTitle("Outgoing RTP bitrate");
   }
 }
@@ skipping 11 matching lines @@
       continue;
     }
 
     TimeSeries time_series(GetStreamName(stream_id), LINE_GRAPH);
     MovingAverage<LoggedRtpPacket, double>(
         [](const LoggedRtpPacket& packet) {
           return rtc::Optional<double>(packet.total_length * 8.0 / 1000.0);
         },
         packet_stream, begin_time_, end_time_, window_duration_, step_,
         &time_series);
-    plot->series_list_.push_back(std::move(time_series));
+    plot->AppendTimeSeries(std::move(time_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin);
   if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
     plot->SetTitle("Incoming bitrate per stream");
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
     plot->SetTitle("Outgoing bitrate per stream");
   }
 }
@@ skipping 105 matching lines @@
         time_us - last_update_us >= 1e6) {
       uint32_t y = observer.last_bitrate_bps() / 1000;
       float x = static_cast<float>(clock.TimeInMicroseconds() - begin_time_) /
                 1000000;
       time_series.points.emplace_back(x, y);
       last_update_us = time_us;
     }
     time_us = std::min({NextRtpTime(), NextRtcpTime(), NextProcessTime()});
   }
   // 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->AppendTimeSeries(std::move(time_series));
+  plot->AppendTimeSeries(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");
 }
 
 void EventLogAnalyzer::CreateNetworkDelayFeedbackGraph(Plot* plot) {
   std::map<uint64_t, const LoggedRtpPacket*> outgoing_rtp;
   std::map<uint64_t, const LoggedRtcpPacket*> incoming_rtcp;
 
@@ skipping 69 matching lines @@
       }
       ++rtp_iterator;
     }
     time_us = std::min(NextRtpTime(), NextRtcpTime());
   }
   // We assume that the base network delay (w/o queues) is the min delay
   // observed during the call.
   for (TimeSeriesPoint& point : time_series.points)
     point.y -= estimated_base_delay_ms;
   // Add the data set to the plot.
-  plot->series_list_.push_back(std::move(time_series));
+  plot->AppendTimeSeries(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.");
 }
 
 std::vector<std::pair<int64_t, int64_t>> EventLogAnalyzer::GetFrameTimestamps()
     const {
   std::vector<std::pair<int64_t, int64_t>> timestamps;
   size_t largest_stream_size = 0;
@@ skipping 27 matching lines @@
     StreamId stream_id = kv.first;
 
     {
       TimeSeries timestamp_data(GetStreamName(stream_id) + " capture-time",
                                 LINE_DOT_GRAPH);
       for (LoggedRtpPacket packet : rtp_packets) {
         float x = static_cast<float>(packet.timestamp - begin_time_) / 1000000;
         float y = packet.header.timestamp;
         timestamp_data.points.emplace_back(x, y);
       }
-      plot->series_list_.push_back(std::move(timestamp_data));
+      plot->AppendTimeSeries(std::move(timestamp_data));
     }
 
     {
       auto kv = rtcp_packets_.find(stream_id);
       if (kv != rtcp_packets_.end()) {
         const auto& packets = kv->second;
         TimeSeries timestamp_data(
             GetStreamName(stream_id) + " rtcp capture-time", LINE_DOT_GRAPH);
         for (const LoggedRtcpPacket& rtcp : packets) {
           if (rtcp.type != kRtcpSr)
             continue;
           rtcp::SenderReport* sr;
           sr = static_cast<rtcp::SenderReport*>(rtcp.packet.get());
           float x = static_cast<float>(rtcp.timestamp - begin_time_) / 1000000;
           float y = sr->rtp_timestamp();
           timestamp_data.points.emplace_back(x, y);
         }
-        plot->series_list_.push_back(std::move(timestamp_data));
+        plot->AppendTimeSeries(std::move(timestamp_data));
       }
     }
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Timestamp (90khz)", kBottomMargin, kTopMargin);
   plot->SetTitle("Timestamps");
 }
 
 void EventLogAnalyzer::CreateAudioEncoderTargetBitrateGraph(Plot* plot) {
-  TimeSeries* time_series =
-      plot->AddTimeSeries("Audio encoder target bitrate", LINE_DOT_GRAPH);
+  TimeSeries time_series("Audio encoder target bitrate", LINE_DOT_GRAPH);
   ProcessPoints<AudioNetworkAdaptationEvent>(
       [](const AudioNetworkAdaptationEvent& ana_event) -> rtc::Optional<float> {
         if (ana_event.config.bitrate_bps)
           return rtc::Optional<float>(
               static_cast<float>(*ana_event.config.bitrate_bps));
         return rtc::Optional<float>();
       },
-      audio_network_adaptation_events_, begin_time_, time_series);
+      audio_network_adaptation_events_, begin_time_, &time_series);
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Bitrate (bps)", kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder target bitrate");
+  plot->AppendTimeSeries(std::move(time_series));

[terelius, 2017/04/19 09:20:18]

nit: I'd like to finish the timeseries specific things before setting the
general graph properties. I.e., please append the timeseries before setting
x-axis, y-axis and title.

Same below.

[philipel, 2017/04/19 12:32:11]

Done.

 }
 
 void EventLogAnalyzer::CreateAudioEncoderFrameLengthGraph(Plot* plot) {
-  TimeSeries* time_series =
-      plot->AddTimeSeries("Audio encoder frame length", LINE_DOT_GRAPH);
+  TimeSeries time_series("Audio encoder frame length", LINE_DOT_GRAPH);
   ProcessPoints<AudioNetworkAdaptationEvent>(
       [](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.frame_length_ms)
           return rtc::Optional<float>(
               static_cast<float>(*ana_event.config.frame_length_ms));
         return rtc::Optional<float>();
       },
-      audio_network_adaptation_events_, begin_time_, time_series);
+      audio_network_adaptation_events_, begin_time_, &time_series);
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Frame length (ms)", kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder frame length");
+  plot->AppendTimeSeries(std::move(time_series));
 }
 
 void EventLogAnalyzer::CreateAudioEncoderUplinkPacketLossFractionGraph(
     Plot* plot) {
-  TimeSeries* time_series = plot->AddTimeSeries(
-      "Audio encoder uplink packet loss fraction", LINE_DOT_GRAPH);
+  TimeSeries time_series("Audio encoder uplink packet loss fraction",
+                         LINE_DOT_GRAPH);
   ProcessPoints<AudioNetworkAdaptationEvent>(
       [](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.uplink_packet_loss_fraction)
           return rtc::Optional<float>(static_cast<float>(
               *ana_event.config.uplink_packet_loss_fraction));
         return rtc::Optional<float>();
       },
-      audio_network_adaptation_events_, begin_time_, time_series);
+      audio_network_adaptation_events_, begin_time_, &time_series);
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Percent lost packets", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Reported audio encoder lost packets");
+  plot->AppendTimeSeries(std::move(time_series));
 }
 
 void EventLogAnalyzer::CreateAudioEncoderEnableFecGraph(Plot* plot) {
-  TimeSeries* time_series =
-      plot->AddTimeSeries("Audio encoder FEC", LINE_DOT_GRAPH);
+  TimeSeries time_series("Audio encoder FEC", LINE_DOT_GRAPH);
   ProcessPoints<AudioNetworkAdaptationEvent>(
       [](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.enable_fec)
           return rtc::Optional<float>(
               static_cast<float>(*ana_event.config.enable_fec));
         return rtc::Optional<float>();
       },
-      audio_network_adaptation_events_, begin_time_, time_series);
+      audio_network_adaptation_events_, begin_time_, &time_series);
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "FEC (false/true)", kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder FEC");
+  plot->AppendTimeSeries(std::move(time_series));
 }
 
 void EventLogAnalyzer::CreateAudioEncoderEnableDtxGraph(Plot* plot) {
-  TimeSeries* time_series =
-      plot->AddTimeSeries("Audio encoder DTX", LINE_DOT_GRAPH);
+  TimeSeries time_series("Audio encoder DTX", LINE_DOT_GRAPH);
   ProcessPoints<AudioNetworkAdaptationEvent>(
       [](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.enable_dtx)
           return rtc::Optional<float>(
               static_cast<float>(*ana_event.config.enable_dtx));
         return rtc::Optional<float>();
       },
-      audio_network_adaptation_events_, begin_time_, time_series);
+      audio_network_adaptation_events_, begin_time_, &time_series);
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "DTX (false/true)", kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder DTX");
+  plot->AppendTimeSeries(std::move(time_series));
 }
 
 void EventLogAnalyzer::CreateAudioEncoderNumChannelsGraph(Plot* plot) {
-  TimeSeries* time_series =
-      plot->AddTimeSeries("Audio encoder number of channels", LINE_DOT_GRAPH);
+  TimeSeries time_series("Audio encoder number of channels", LINE_DOT_GRAPH);
   ProcessPoints<AudioNetworkAdaptationEvent>(
       [](const AudioNetworkAdaptationEvent& ana_event) {
         if (ana_event.config.num_channels)
           return rtc::Optional<float>(
               static_cast<float>(*ana_event.config.num_channels));
         return rtc::Optional<float>();
       },
-      audio_network_adaptation_events_, begin_time_, time_series);
+      audio_network_adaptation_events_, begin_time_, &time_series);
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Number of channels (1 (mono)/2 (stereo))",
                           kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder number of channels");
+  plot->AppendTimeSeries(std::move(time_series));
 }
 }  // namespace plotting
 }  // namespace webrtc