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..cd3e74be8d5d081d0cf5e92d3e43eba252fe4a13
--- /dev/null
+++ b/webrtc/call/rtc_event_log_helper_thread.h
@@ -0,0 +1,123 @@
+/*
+ *  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/base/swap_queue.h"
+#include "webrtc/call/ringbuffer.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
+
+#ifdef ENABLE_RTC_EVENT_LOG
+
+namespace webrtc {
+
+class RtcEventLogHelperThread {
+ public:
+  struct ControlMessage {
+    ControlMessage()
+        : message_type(STOP_FILE),
+          file(nullptr),
+          max_size_bytes(0),
+          start_time(0),
+          stop_time(0) {}
+    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.
+
+    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<std::unique_ptr<rtclog::Event>>* event_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<std::unique_ptr<rtclog::Event>>* event_queue_;
+
+  // History containing the most recent events (~ 10 s).
+  RingBuffer<std::unique_ptr<rtclog::Event>> history_;
+
+  // History containing all past configuration events.
+  std::vector<std::unique_ptr<rtclog::Event>> config_history_;
+
+  rtc::scoped_ptr<FileWrapper> file_;

[the sun, 2016/04/20 11:30:15]

unique_ptr

[terelius, 2016/04/21 08:10:41]

Done.

+  rtc::PlatformThread thread_;
+
+  int64_t max_size_bytes_;
+  int64_t written_bytes_;
+  int64_t start_time_;
+  int64_t stop_time_;
+
+  bool has_recent_event_;
+  std::unique_ptr<rtclog::Event> most_recent_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_