Refactored CL for moving the output to a separate thread.

webrtc/call/rtc_event_log_helper_thread.h

Index: webrtc/call/rtc_event_log_helper_thread.h
diff --git a/webrtc/call/rtc_event_log_helper_thread.h b/webrtc/call/rtc_event_log_helper_thread.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5b691d87fdb821e7b0217d78ebc84f9c67a7932
--- /dev/null
+++ b/webrtc/call/rtc_event_log_helper_thread.h
@@ -0,0 +1,135 @@
+/*
+ *  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.
+ */
+
+#ifndef WEBRTC_CALL_RTC_EVENT_LOG_HELPER_THREAD_H_
+#define WEBRTC_CALL_RTC_EVENT_LOG_HELPER_THREAD_H_
+
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "webrtc/base/constructormagic.h"
+#include "webrtc/base/event.h"
+#include "webrtc/base/platform_thread.h"
+#include "webrtc/call/ringbuffer.h"
+#include "webrtc/common_audio/swap_queue.h"
+#include "webrtc/system_wrappers/include/clock.h"
+#include "webrtc/system_wrappers/include/file_wrapper.h"
+
+#ifdef ENABLE_RTC_EVENT_LOG
+// Files generated at build-time by the protobuf compiler.
+#ifdef WEBRTC_ANDROID_PLATFORM_BUILD
+#include "external/webrtc/webrtc/call/rtc_event_log.pb.h"
+#else
+#include "webrtc/call/rtc_event_log.pb.h"
+#endif
+#endif
+
+namespace webrtc {

[the sun, 2016/03/11 13:21:57]

Enclose the whole contents with "#if ENABLE_RTC_EVENT_LOG". Right now it looks
like it won't compile.

[terelius, 2016/03/18 14:03:25]

Done.

+
+#ifdef ENABLE_RTC_EVENT_LOG
+
+class RtcEventLogHelperThread {
+ public:
+  struct ControlMessage {
+    enum { START_FILE, STOP_FILE, TERMINATE_THREAD } message_type;
+
+    rtc::scoped_ptr<FileWrapper> file;  // Only used with START_FILE.
+    int64_t max_size_bytes;             // Only used with START_FILE.

[the sun, 2016/03/11 13:21:57]

Add default initialization

[terelius, 2016/03/18 14:03:25]

Not sure why, but done.

+    int64_t start_time;                 // Only used with START_FILE.
+    int64_t stop_time;                  // Used with all 3 message types.
+
+    friend void swap(ControlMessage& lhs, ControlMessage& rhs) {
+      using std::swap;
+      swap(lhs.message_type, rhs.message_type);
+      lhs.file.swap(rhs.file);
+      swap(lhs.max_size_bytes, rhs.max_size_bytes);
+      swap(lhs.start_time, rhs.start_time);
+      swap(lhs.stop_time, rhs.stop_time);
+    }
+  };
+
+  RtcEventLogHelperThread(SwapQueue<ControlMessage>* message_queue,
+                          SwapQueue<rtclog::Event>* config_queue,
+                          SwapQueue<rtclog::Event>* rtp_queue,
+                          SwapQueue<rtclog::Event>* rtcp_queue,
+                          SwapQueue<rtclog::Event>* acm_playout_queue,
+                          SwapQueue<rtclog::Event>* bwe_loss_queue,
+                          rtc::Event* wake_up,
+                          rtc::Event* file_finished,
+                          const Clock* const clock);
+  ~RtcEventLogHelperThread();
+
+ private:
+  static bool ThreadOutputFunction(void* obj);
+
+  void TerminateThread();
+  bool AppendEventToString(rtclog::Event* event);
+  void AppendEventToHistory(const rtclog::Event& event);
+  bool ProcessInOrder(bool memory, int64_t current_time);
+  void LogToMemory();
+  void StartLogFile();
+  void LogToFile();
+  void StopLogFile();
+  void WriteLog();
+
+  // Message queues for passing events to the logging thread.
+  SwapQueue<ControlMessage>* message_queue_;
+  SwapQueue<rtclog::Event>* config_queue_;
+  SwapQueue<rtclog::Event>* rtp_queue_;
+  SwapQueue<rtclog::Event>* rtcp_queue_;
+  SwapQueue<rtclog::Event>* acm_playout_queue_;
+  SwapQueue<rtclog::Event>* bwe_loss_queue_;
+
+  // History containing the most recent events (~ 10 s).
+  RingBuffer<rtclog::Event> history_;

[the sun, 2016/03/11 13:21:57]

How about using a std::queue instead of the RingBuffer, and implement time
window based purge within the confines of this class?

[terelius, 2016/03/18 14:03:25]

A space based limit is more efficient and more natural. (See discussion about
history length in event_log_helper_thread.cc comment.)

 

+
+  // History containing all past configuration events.
+  std::vector<rtclog::Event> config_history_;
+
+  rtc::scoped_ptr<FileWrapper> file_;
+  rtc::PlatformThread thread_;
+
+  int64_t max_size_bytes_;

[the sun, 2016/03/11 13:21:57]

Use non-static member initialization. It is not as easy to forget as relying on
everything to be in the ctor init list.

[terelius, 2016/03/18 14:03:25]

I think the general consensus in the video team is to do all initialization in
the constructor.

+  int64_t written_bytes_;
+  int64_t start_time_;
+  int64_t stop_time_;
+
+  // We want to extract the elements from the buffers in timestamp order
+  // and, because we can't peek into the SwapQueue, we need to keep the first
+  // elements outside.
+  rtclog::Event config_event_;
+  rtclog::Event rtp_event_;
+  rtclog::Event rtcp_event_;
+  rtclog::Event playout_event_;
+  rtclog::Event loss_event_;
+  bool valid_config_event_;
+  bool valid_rtp_event_;
+  bool valid_rtcp_event_;
+  bool valid_playout_event_;
+  bool valid_loss_event_;
+
+  // Temporary space for serializing profobuf data.
+  std::string output_string_;
+
+  rtc::Event* wake_up_;
+  rtc::Event* stopped_;
+
+  const Clock* const clock_;
+
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RtcEventLogHelperThread);
+};
+
+}  // namespace webrtc
+
+#endif  // ENABLE_RTC_EVENT_LOG
+
+#endif  // WEBRTC_CALL_RTC_EVENT_LOG_HELPER_THREAD_H_