Move log_count_ out of RtcEventLogImpl

webrtc/logging/rtc_event_log/rtc_event_log.cc

 /*
  *  Copyright (c) 2015 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 54 matching lines @@
 const int kEventsInHistory = 10000;
 
 bool IsConfigEvent(const rtclog::Event& event) {
   rtclog::Event_EventType event_type = event.type();
   return event_type == rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT ||
          event_type == rtclog::Event::VIDEO_SENDER_CONFIG_EVENT ||
          event_type == rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT ||
          event_type == rtclog::Event::AUDIO_SENDER_CONFIG_EVENT;
 }
 
+// Observe a limit on the number of concurrent logs, so as not to run into
+// OS-imposed limits on open files and/or threads/task-queues.
+// TODO(eladalon): Known issue - there's a race over |rtc_event_log_count|.
+std::atomic<int> rtc_event_log_count(0);
+
 // TODO(eladalon): This class exists because C++11 doesn't allow transferring a
 // unique_ptr to a lambda (a copy constructor is required). We should get
 // rid of this when we move to C++14.
 template <typename T>
 class ResourceOwningTask final : public rtc::QueuedTask {
  public:
   ResourceOwningTask(std::unique_ptr<T> resource,
                      std::function<void(std::unique_ptr<T>)> handler)
       : resource_(std::move(resource)), handler_(handler) {}
 
@@ skipping 65 matching lines @@
   // event from being added; in this case, the output string is left unchanged.
   bool AppendEventToString(rtclog::Event* event,
                            ProtoString* output_string) RTC_WARN_UNUSED_RESULT;
 
   void LogToMemory(std::unique_ptr<rtclog::Event> event);
 
   void StartLogFile();
   void LogToFile(std::unique_ptr<rtclog::Event> event);
   void StopLogFile(int64_t stop_time);
 
-  // Observe a limit on the number of concurrent logs, so as not to run into
-  // OS-imposed limits on open files and/or threads/task-queues.
-  // TODO(eladalon): Known issue - there's a race over |log_count_|.
-  static std::atomic<int> log_count_;
-
   // Make sure that the event log is "managed" - created/destroyed, as well
   // as started/stopped - from the same thread/task-queue.
   rtc::SequencedTaskChecker owner_sequence_checker_;
 
   // History containing all past configuration events.
   std::vector<std::unique_ptr<rtclog::Event>> config_history_
       RTC_ACCESS_ON(task_queue_);
 
   // History containing the most recent (non-configuration) events (~10s).
   std::deque<std::unique_ptr<rtclog::Event>> history_
@@ skipping 53 matching lines @@
       return rtclog::BweProbeResult::INVALID_SEND_RECEIVE_RATIO;
     case kTimeout:
       return rtclog::BweProbeResult::TIMEOUT;
   }
   RTC_NOTREACHED();
   return rtclog::BweProbeResult::SUCCESS;
 }
 
 }  // namespace
 
-std::atomic<int> RtcEventLogImpl::log_count_(0);
-
 RtcEventLogImpl::RtcEventLogImpl()
     : file_(FileWrapper::Create()),
       max_size_bytes_(std::numeric_limits<decltype(max_size_bytes_)>::max()),
       written_bytes_(0),
       task_queue_("rtc_event_log") {}
 
 RtcEventLogImpl::~RtcEventLogImpl() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
 
   // If we're logging to the file, this will stop that. Blocking function.
   StopLogging();
 
-  int count = std::atomic_fetch_sub(&RtcEventLogImpl::log_count_, 1) - 1;
+  int count = std::atomic_fetch_sub(&rtc_event_log_count, 1) - 1;
   RTC_DCHECK_GE(count, 0);
 }
 
 bool RtcEventLogImpl::StartLogging(const std::string& file_name,
                                    int64_t max_size_bytes) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
 
   auto file = rtc::WrapUnique<FileWrapper>(FileWrapper::Create());
   if (!file->OpenFile(file_name.c_str(), false)) {
     LOG(LS_ERROR) << "Can't open file. WebRTC event log not started.";
@@ skipping 541 matching lines @@
 
   file_->CloseFile();
   RTC_DCHECK(!file_->is_open());
 }
 
 #endif  // ENABLE_RTC_EVENT_LOG
 
 // RtcEventLog member functions.
 std::unique_ptr<RtcEventLog> RtcEventLog::Create() {
 #ifdef ENABLE_RTC_EVENT_LOG
-  // TODO(eladalon): Known issue - there's a race over |log_count_| here.
+    // TODO(eladalon): Known issue - there's a race over |rtc_event_log_count|.
   constexpr int kMaxLogCount = 5;
-  int count = 1 + std::atomic_fetch_add(&RtcEventLogImpl::log_count_, 1);
+  int count = 1 + std::atomic_fetch_add(&rtc_event_log_count, 1);
   if (count > kMaxLogCount) {
     LOG(LS_WARNING) << "Denied creation of additional WebRTC event logs. "
                     << count - 1 << " logs open already.";
-    std::atomic_fetch_sub(&RtcEventLogImpl::log_count_, 1);
+    std::atomic_fetch_sub(&rtc_event_log_count, 1);
     return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
   }
   return std::unique_ptr<RtcEventLog>(new RtcEventLogImpl());
 #else
   return CreateNull();
 #endif  // ENABLE_RTC_EVENT_LOG
 }
 
 std::unique_ptr<RtcEventLog> RtcEventLog::CreateNull() {
   return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
 }
 
 }  // namespace webrtc