Added support for keeping a buffer of the previous X seconds, to add to

webrtc/modules/audio_coding/main/acm2/acm_dump.cc

Index: webrtc/modules/audio_coding/main/acm2/acm_dump.cc
diff --git a/webrtc/modules/audio_coding/main/acm2/acm_dump.cc b/webrtc/modules/audio_coding/main/acm2/acm_dump.cc
index 4454c25947d5d1d1d226aea04d75833d362ddf39..a3216aae115d99c00fb95c61bf7c9ab59d9b9ef6 100644
--- a/webrtc/modules/audio_coding/main/acm2/acm_dump.cc
+++ b/webrtc/modules/audio_coding/main/acm2/acm_dump.cc
@@ -10,7 +10,7 @@
 
 #include "webrtc/modules/audio_coding/main/acm2/acm_dump.h"
 
-#include <sstream>
+#include <deque>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/thread_annotations.h"
@@ -67,10 +67,21 @@ class AcmDumpImpl final : public AcmDump {
   void LogDebugEventLocked(DebugEvent event_type,
                            const std::string& event_message)
       EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  // Writes the event to the file. Note that this will destroy the state of the
+  // input argument.
+  void StoreToFile(ACMDumpEvent* event) EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  // Adds the event to the list of recent events, and removes any events that
+  // are too old and no longer fall in the time window.
+  void AddRecentEvent(const ACMDumpEvent& event)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_);
+
+  // Amount of time in us to record log events, before starting the actual log.

[hlundin-webrtc, 2015/06/25 13:20:56]

Write microseconds instead of us in comments. Although us is an accepted
approximation of "<greek-mu>s", I think you can spare us some confusion by not
writing us. See what I did there? :)

[ivoc, 2015/06/25 13:55:22]

Good point.

+  const int recent_log_duration_us = 10000000;
 
   rtc::scoped_ptr<webrtc::CriticalSectionWrapper> crit_;
   rtc::scoped_ptr<webrtc::FileWrapper> file_ GUARDED_BY(crit_);
   rtc::scoped_ptr<ACMDumpEventStream> stream_ GUARDED_BY(crit_);
+  std::deque<ACMDumpEvent> recent_log_events_ GUARDED_BY(crit_);
   bool active_ GUARDED_BY(crit_);
   int64_t start_time_us_ GUARDED_BY(crit_);
   int64_t duration_us_ GUARDED_BY(crit_);
@@ -112,38 +123,37 @@ void AcmDumpImpl::StartLogging(const std::string& file_name, int duration_ms) {
   if (file_->OpenFile(file_name.c_str(), false) != 0) {
     return;
   }
-  // Add a single object to the stream that is reused at every log event.
-  stream_->add_stream();
+  // Add start event to the recent event list, and remove any old events from

[hlundin-webrtc, 2015/06/25 13:20:56]

The comment is slightly confusing. I first thought that the call to
LogDebugEventLocked did all of the above, but the clearing of the list happens
further down, right?

[ivoc, 2015/06/25 13:55:23]

What I meant to say is that this call to LogDebugEventLocked will cause the
LOG_START event to be added to recent_log_events_ list, and also at the same
time will cause the oldest events in recent_log_events_ to be removed from that
list if necessary (this all happens in LogDebugEventLocked, because it calls
AddRecentEvent). 

This is handy because it removes unneeded events right before writing the
contents of the list to the log.

I will rephrase to clarify.

+  // the list.
+  LogDebugEventLocked(DebugEvent::kLogStart, "");
   active_ = true;
   start_time_us_ = clock_->TimeInMicroseconds();
   duration_us_ = static_cast<int64_t>(duration_ms) * 1000;
-  // Log the start event.
-  std::stringstream log_msg;
-  log_msg << "Initial timestamp: " << start_time_us_;
-  LogDebugEventLocked(DebugEvent::kLogStart, log_msg.str());
+  // Write all the recent events to the log file.
+  for (auto&& event : recent_log_events_) {
+    StoreToFile(&event);
+  }
+  recent_log_events_.clear();
 }
 
 void AcmDumpImpl::LogRtpPacket(bool incoming,
                                const uint8_t* packet,
                                size_t length) {
   CriticalSectionScoped lock(crit_.get());
-  if (!CurrentlyLogging()) {
+  ACMDumpEvent rtp_event;
+  rtp_event.clear_debug_event();
+  const int64_t timestamp = clock_->TimeInMicroseconds();
+  rtp_event.set_timestamp_us(timestamp);
+  rtp_event.set_type(webrtc::ACMDumpEvent::RTP_EVENT);
+  rtp_event.mutable_packet()->set_direction(
+      incoming ? ACMDumpRTPPacket::INCOMING : ACMDumpRTPPacket::OUTGOING);
+  rtp_event.mutable_packet()->set_rtp_data(packet, length);
+  if (CurrentlyLogging()) {
+    StoreToFile(&rtp_event);
+  } else {
     StopIfNecessary();
-    return;
+    AddRecentEvent(rtp_event);
   }
-  // Reuse the same object at every log event.
-  auto rtp_event = stream_->mutable_stream(0);
-  rtp_event->clear_debug_event();
-  const int64_t timestamp = clock_->TimeInMicroseconds() - start_time_us_;
-  rtp_event->set_timestamp_us(timestamp);
-  rtp_event->set_type(webrtc::ACMDumpEvent::RTP_EVENT);
-  rtp_event->mutable_packet()->set_direction(
-      incoming ? ACMDumpRTPPacket::INCOMING : ACMDumpRTPPacket::OUTGOING);
-  rtp_event->mutable_packet()->set_rtp_data(packet, length);
-  std::string dump_buffer;
-  stream_->SerializeToString(&dump_buffer);
-  file_->Write(dump_buffer.data(), dump_buffer.size());
-  file_->Flush();
 }
 
 void AcmDumpImpl::LogDebugEvent(DebugEvent event_type,
@@ -175,25 +185,42 @@ void AcmDumpImpl::Clear() {
 
 void AcmDumpImpl::LogDebugEventLocked(DebugEvent event_type,
                                       const std::string& event_message) {
-  if (!CurrentlyLogging()) {
+  ACMDumpEvent event;
+  int64_t timestamp = clock_->TimeInMicroseconds();
+  event.set_timestamp_us(timestamp);
+  event.set_type(webrtc::ACMDumpEvent::DEBUG_EVENT);
+  event.clear_packet();
+  auto debug_event = event.mutable_debug_event();
+  debug_event->set_type(convertDebugEvent(event_type));
+  debug_event->set_message(event_message);
+  if (CurrentlyLogging()) {
+    StoreToFile(&event);
+  } else {
     StopIfNecessary();
-    return;
+    AddRecentEvent(event);
   }
+}
 
+void AcmDumpImpl::StoreToFile(ACMDumpEvent* event) {
   // Reuse the same object at every log event.
-  auto event = stream_->mutable_stream(0);
-  int64_t timestamp = clock_->TimeInMicroseconds() - start_time_us_;
-  event->set_timestamp_us(timestamp);
-  event->set_type(webrtc::ACMDumpEvent::DEBUG_EVENT);
-  event->clear_packet();
-  auto debug_event = event->mutable_debug_event();
-  debug_event->set_type(convertDebugEvent(event_type));
-  debug_event->set_message(event_message);
+  if (stream_->stream_size() < 1) {
+    stream_->add_stream();
+  }
+  stream_->mutable_stream(0)->Swap(event);
+
   std::string dump_buffer;
   stream_->SerializeToString(&dump_buffer);
   file_->Write(dump_buffer.data(), dump_buffer.size());
 }
 
+void AcmDumpImpl::AddRecentEvent(const ACMDumpEvent& event) {
+  recent_log_events_.push_back(event);
+  while (recent_log_events_.front().timestamp_us() <
+         event.timestamp_us() - recent_log_duration_us) {
+    recent_log_events_.pop_front();
+  }
+}
+
 #endif  // RTC_AUDIOCODING_DEBUG_DUMP
 
 // AcmDump member functions.