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 {
+
+#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.
+    int64_t start_time;                 // Only used with START_FILE.
+    int64_t stop_time;                  // Used with all 3 message types.

[ivoc, 2016/03/11 13:29:53]

This feature is not currently used on the API, right? How about removing it
until we need it?

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

It is not pat of the API, but it is used by StopLogging to ensure that we only
log events that came before the call to StopLogging. (I.e. not events that were
queued between the call to StopLogging and the next time slice for the logging
thread.)

+
+    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_;
+
+  // 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_;
+  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_;

[ivoc, 2016/03/11 13:29:53]

These events as well as the valid_<X> flags below only seem to be used in the
ProcessInOrder function, how about moving them to being static variables inside
of that function?

[the sun, 2016/03/11 13:37:47]

No. That is tantamount to making them global, in the sense that there can only
ever be ONE RtcEventLogHelperThread object. Static variables should be avoided.

[ivoc, 2016/03/11 13:40:26]

Oops, my bad, you're absolutely right.

+  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_