1/*
2 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#include "webrtc/system_wrappers/source/trace_impl.h"
12
13#include <assert.h>
14#include <stdarg.h>
15#include <stdio.h>
16#include <string.h>
17
18#ifdef _WIN32
19#include "webrtc/system_wrappers/source/trace_win.h"
20#else
21#include "webrtc/system_wrappers/source/trace_posix.h"
22#endif  // _WIN32
23
24#include "webrtc/system_wrappers/interface/sleep.h"
25
26#define KEY_LEN_CHARS 31
27
28#ifdef _WIN32
29#pragma warning(disable:4355)
30#endif  // _WIN32
31
32namespace webrtc {
33
34const int Trace::kBoilerplateLength = 71;
35const int Trace::kTimestampPosition = 13;
36const int Trace::kTimestampLength = 12;
37uint32_t Trace::level_filter_ = kTraceDefault;
38
39// Construct On First Use idiom. Avoids "static initialization order fiasco".
40TraceImpl* TraceImpl::StaticInstance(CountOperation count_operation,
41                                     const TraceLevel level) {
42  // Sanities to avoid taking lock unless absolutely necessary (for
43  // performance reasons). count_operation == kAddRefNoCreate implies that a
44  // message will be written to file.
45  if ((level != kTraceAll) && (count_operation == kAddRefNoCreate)) {
46    if (!(level & level_filter())) {
47      return NULL;
48    }
49  }
50  TraceImpl* impl =
51    GetStaticInstance<TraceImpl>(count_operation);
52  return impl;
53}
54
55TraceImpl* TraceImpl::GetTrace(const TraceLevel level) {
56  return StaticInstance(kAddRefNoCreate, level);
57}
58
59TraceImpl* TraceImpl::CreateInstance() {
60#if defined(_WIN32)
61  return new TraceWindows();
62#else
63  return new TracePosix();
64#endif
65}
66
67TraceImpl::TraceImpl()
68    : critsect_interface_(CriticalSectionWrapper::CreateCriticalSection()),
69      callback_(NULL),
70      row_count_text_(0),
71      file_count_text_(0),
72      trace_file_(*FileWrapper::Create()),
73      thread_(*ThreadWrapper::CreateThread(TraceImpl::Run, this,
74                                           kHighestPriority, "Trace")),
75      event_(*EventWrapper::Create()),
76      critsect_array_(CriticalSectionWrapper::CreateCriticalSection()),
77      next_free_idx_(),
78      level_(),
79      length_(),
80      message_queue_(),
81      active_queue_(0) {
82  next_free_idx_[0] = 0;
83  next_free_idx_[1] = 0;
84
85  unsigned int tid = 0;
86  thread_.Start(tid);
87
88  for (int m = 0; m < WEBRTC_TRACE_NUM_ARRAY; ++m) {
89    for (int n = 0; n < WEBRTC_TRACE_MAX_QUEUE; ++n) {
90      message_queue_[m][n] = new
91      char[WEBRTC_TRACE_MAX_MESSAGE_SIZE];
92    }
93  }
94}
95
96bool TraceImpl::StopThread() {
97  // Release the worker thread so that it can flush any lingering messages.
98  event_.Set();
99
100  // Allow 10 ms for pending messages to be flushed out.
101  // TODO(hellner): why not use condition variables to do this? Or let the
102  //                worker thread die and let this thread flush remaining
103  //                messages?
104  SleepMs(10);
105
106  thread_.SetNotAlive();
107  // Make sure the thread finishes as quickly as possible (instead of having
108  // to wait for the timeout).
109  event_.Set();
110  bool stopped = thread_.Stop();
111
112  CriticalSectionScoped lock(critsect_interface_);
113  trace_file_.Flush();
114  trace_file_.CloseFile();
115  return stopped;
116}
117
118TraceImpl::~TraceImpl() {
119  StopThread();
120  delete &event_;
121  delete &trace_file_;
122  delete &thread_;
123  delete critsect_interface_;
124  delete critsect_array_;
125
126  for (int m = 0; m < WEBRTC_TRACE_NUM_ARRAY; ++m) {
127    for (int n = 0; n < WEBRTC_TRACE_MAX_QUEUE; ++n) {
128      delete [] message_queue_[m][n];
129    }
130  }
131}
132
133int32_t TraceImpl::AddThreadId(char* trace_message) const {
134  uint32_t thread_id = ThreadWrapper::GetThreadId();
135  // Messages is 12 characters.
136  return sprintf(trace_message, "%10u; ", thread_id);
137}
138
139int32_t TraceImpl::AddLevel(char* sz_message, const TraceLevel level) const {
140  const int kMessageLength = 12;
141  switch (level) {
142    case kTraceTerseInfo:
143      // Add the appropriate amount of whitespace.
144      memset(sz_message, ' ', kMessageLength);
145      sz_message[kMessageLength] = '\0';
146      break;
147    case kTraceStateInfo:
148      sprintf(sz_message, "STATEINFO ; ");
149      break;
150    case kTraceWarning:
151      sprintf(sz_message, "WARNING   ; ");
152      break;
153    case kTraceError:
154      sprintf(sz_message, "ERROR     ; ");
155      break;
156    case kTraceCritical:
157      sprintf(sz_message, "CRITICAL  ; ");
158      break;
159    case kTraceInfo:
160      sprintf(sz_message, "DEBUGINFO ; ");
161      break;
162    case kTraceModuleCall:
163      sprintf(sz_message, "MODULECALL; ");
164      break;
165    case kTraceMemory:
166      sprintf(sz_message, "MEMORY    ; ");
167      break;
168    case kTraceTimer:
169      sprintf(sz_message, "TIMER     ; ");
170      break;
171    case kTraceStream:
172      sprintf(sz_message, "STREAM    ; ");
173      break;
174    case kTraceApiCall:
175      sprintf(sz_message, "APICALL   ; ");
176      break;
177    case kTraceDebug:
178      sprintf(sz_message, "DEBUG     ; ");
179      break;
180    default:
181      assert(false);
182      return 0;
183  }
184  // All messages are 12 characters.
185  return kMessageLength;
186}
187
188int32_t TraceImpl::AddModuleAndId(char* trace_message,
189                                  const TraceModule module,
190                                  const int32_t id) const {
191  // Use long int to prevent problems with different definitions of
192  // int32_t.
193  // TODO(hellner): is this actually a problem? If so, it should be better to
194  //                clean up int32_t
195  const long int idl = id;
196  const int kMessageLength = 25;
197  if (idl != -1) {
198    const unsigned long int id_engine = id >> 16;
199    const unsigned long int id_channel = id & 0xffff;
200
201    switch (module) {
202      case kTraceUndefined:
203        // Add the appropriate amount of whitespace.
204        memset(trace_message, ' ', kMessageLength);
205        trace_message[kMessageLength] = '\0';
206        break;
207      case kTraceVoice:
208        sprintf(trace_message, "       VOICE:%5ld %5ld;", id_engine,
209                id_channel);
210        break;
211      case kTraceVideo:
212        sprintf(trace_message, "       VIDEO:%5ld %5ld;", id_engine,
213                id_channel);
214        break;
215      case kTraceUtility:
216        sprintf(trace_message, "     UTILITY:%5ld %5ld;", id_engine,
217                id_channel);
218        break;
219      case kTraceRtpRtcp:
220        sprintf(trace_message, "    RTP/RTCP:%5ld %5ld;", id_engine,
221                id_channel);
222        break;
223      case kTraceTransport:
224        sprintf(trace_message, "   TRANSPORT:%5ld %5ld;", id_engine,
225                id_channel);
226        break;
227      case kTraceAudioCoding:
228        sprintf(trace_message, "AUDIO CODING:%5ld %5ld;", id_engine,
229                id_channel);
230        break;
231      case kTraceSrtp:
232        sprintf(trace_message, "        SRTP:%5ld %5ld;", id_engine,
233                id_channel);
234        break;
235      case kTraceAudioMixerServer:
236        sprintf(trace_message, " AUDIO MIX/S:%5ld %5ld;", id_engine,
237                id_channel);
238        break;
239      case kTraceAudioMixerClient:
240        sprintf(trace_message, " AUDIO MIX/C:%5ld %5ld;", id_engine,
241                id_channel);
242        break;
243      case kTraceVideoCoding:
244        sprintf(trace_message, "VIDEO CODING:%5ld %5ld;", id_engine,
245                id_channel);
246        break;
247      case kTraceVideoMixer:
248        // Print sleep time and API call
249        sprintf(trace_message, "   VIDEO MIX:%5ld %5ld;", id_engine,
250                id_channel);
251        break;
252      case kTraceFile:
253        sprintf(trace_message, "        FILE:%5ld %5ld;", id_engine,
254                id_channel);
255        break;
256      case kTraceAudioProcessing:
257        sprintf(trace_message, "  AUDIO PROC:%5ld %5ld;", id_engine,
258                id_channel);
259        break;
260      case kTraceAudioDevice:
261        sprintf(trace_message, "AUDIO DEVICE:%5ld %5ld;", id_engine,
262                id_channel);
263        break;
264      case kTraceVideoRenderer:
265        sprintf(trace_message, "VIDEO RENDER:%5ld %5ld;", id_engine,
266                id_channel);
267        break;
268      case kTraceVideoCapture:
269        sprintf(trace_message, "VIDEO CAPTUR:%5ld %5ld;", id_engine,
270                id_channel);
271        break;
272      case kTraceRemoteBitrateEstimator:
273        sprintf(trace_message, "     BWE RBE:%5ld %5ld;", id_engine,
274                id_channel);
275        break;
276    }
277  } else {
278    switch (module) {
279      case kTraceUndefined:
280        // Add the appropriate amount of whitespace.
281        memset(trace_message, ' ', kMessageLength);
282        trace_message[kMessageLength] = '\0';
283        break;
284      case kTraceVoice:
285        sprintf(trace_message, "       VOICE:%11ld;", idl);
286        break;
287      case kTraceVideo:
288        sprintf(trace_message, "       VIDEO:%11ld;", idl);
289        break;
290      case kTraceUtility:
291        sprintf(trace_message, "     UTILITY:%11ld;", idl);
292        break;
293      case kTraceRtpRtcp:
294        sprintf(trace_message, "    RTP/RTCP:%11ld;", idl);
295        break;
296      case kTraceTransport:
297        sprintf(trace_message, "   TRANSPORT:%11ld;", idl);
298        break;
299      case kTraceAudioCoding:
300        sprintf(trace_message, "AUDIO CODING:%11ld;", idl);
301        break;
302      case kTraceSrtp:
303        sprintf(trace_message, "        SRTP:%11ld;", idl);
304        break;
305      case kTraceAudioMixerServer:
306        sprintf(trace_message, " AUDIO MIX/S:%11ld;", idl);
307        break;
308      case kTraceAudioMixerClient:
309        sprintf(trace_message, " AUDIO MIX/C:%11ld;", idl);
310        break;
311      case kTraceVideoCoding:
312        sprintf(trace_message, "VIDEO CODING:%11ld;", idl);
313        break;
314      case kTraceVideoMixer:
315        sprintf(trace_message, "   VIDEO MIX:%11ld;", idl);
316        break;
317      case kTraceFile:
318        sprintf(trace_message, "        FILE:%11ld;", idl);
319        break;
320      case kTraceAudioProcessing:
321        sprintf(trace_message, "  AUDIO PROC:%11ld;", idl);
322        break;
323      case kTraceAudioDevice:
324        sprintf(trace_message, "AUDIO DEVICE:%11ld;", idl);
325        break;
326      case kTraceVideoRenderer:
327        sprintf(trace_message, "VIDEO RENDER:%11ld;", idl);
328        break;
329      case kTraceVideoCapture:
330        sprintf(trace_message, "VIDEO CAPTUR:%11ld;", idl);
331        break;
332      case kTraceRemoteBitrateEstimator:
333        sprintf(trace_message, "     BWE RBE:%11ld;", idl);
334        break;
335    }
336  }
337  return kMessageLength;
338}
339
340int32_t TraceImpl::SetTraceFileImpl(const char* file_name_utf8,
341                                    const bool add_file_counter) {
342  CriticalSectionScoped lock(critsect_interface_);
343
344  trace_file_.Flush();
345  trace_file_.CloseFile();
346
347  if (file_name_utf8) {
348    if (add_file_counter) {
349      file_count_text_ = 1;
350
351      char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize];
352      CreateFileName(file_name_utf8, file_name_with_counter_utf8,
353                     file_count_text_);
354      if (trace_file_.OpenFile(file_name_with_counter_utf8, false, false,
355                               true) == -1) {
356        return -1;
357      }
358    } else {
359      file_count_text_ = 0;
360      if (trace_file_.OpenFile(file_name_utf8, false, false, true) == -1) {
361        return -1;
362      }
363    }
364  }
365  row_count_text_ = 0;
366  return 0;
367}
368
369int32_t TraceImpl::TraceFileImpl(
370    char file_name_utf8[FileWrapper::kMaxFileNameSize]) {
371  CriticalSectionScoped lock(critsect_interface_);
372  return trace_file_.FileName(file_name_utf8, FileWrapper::kMaxFileNameSize);
373}
374
375int32_t TraceImpl::SetTraceCallbackImpl(TraceCallback* callback) {
376  CriticalSectionScoped lock(critsect_interface_);
377  callback_ = callback;
378  return 0;
379}
380
381int32_t TraceImpl::AddMessage(
382    char* trace_message,
383    const char msg[WEBRTC_TRACE_MAX_MESSAGE_SIZE],
384    const uint16_t written_so_far) const {
385  int length = 0;
386  if (written_so_far >= WEBRTC_TRACE_MAX_MESSAGE_SIZE) {
387    return -1;
388  }
389  // - 2 to leave room for newline and NULL termination.
390#ifdef _WIN32
391  length = _snprintf(trace_message,
392                     WEBRTC_TRACE_MAX_MESSAGE_SIZE - written_so_far - 2,
393                     "%s", msg);
394  if (length < 0) {
395    length = WEBRTC_TRACE_MAX_MESSAGE_SIZE - written_so_far - 2;
396    trace_message[length] = 0;
397  }
398#else
399  length = snprintf(trace_message,
400                    WEBRTC_TRACE_MAX_MESSAGE_SIZE - written_so_far - 2,
401                    "%s", msg);
402  if (length < 0 ||
403      length > WEBRTC_TRACE_MAX_MESSAGE_SIZE - written_so_far - 2) {
404    length = WEBRTC_TRACE_MAX_MESSAGE_SIZE - written_so_far - 2;
405    trace_message[length] = 0;
406  }
407#endif
408  // Length with NULL termination.
409  return length + 1;
410}
411
412void TraceImpl::AddMessageToList(
413    const char trace_message[WEBRTC_TRACE_MAX_MESSAGE_SIZE],
414    const uint16_t length,
415    const TraceLevel level) {
416// NOTE(andresp): Enabled externally.
417#ifdef WEBRTC_DIRECT_TRACE
418  if (callback_) {
419    callback_->Print(level, trace_message, length);
420  }
421  return;
422#endif
423
424  CriticalSectionScoped lock(critsect_array_);
425
426  if (next_free_idx_[active_queue_] >= WEBRTC_TRACE_MAX_QUEUE) {
427    if (!trace_file_.Open() && !callback_) {
428      // Keep at least the last 1/4 of old messages when not logging.
429      // TODO(hellner): isn't this redundant. The user will make it known
430      //                when to start logging. Why keep messages before
431      //                that?
432      for (int n = 0; n < WEBRTC_TRACE_MAX_QUEUE / 4; ++n) {
433        const int last_quarter_offset = (3 * WEBRTC_TRACE_MAX_QUEUE / 4);
434        memcpy(message_queue_[active_queue_][n],
435               message_queue_[active_queue_][n + last_quarter_offset],
436               WEBRTC_TRACE_MAX_MESSAGE_SIZE);
437      }
438      next_free_idx_[active_queue_] = WEBRTC_TRACE_MAX_QUEUE / 4;
439    } else {
440      // More messages are being written than there is room for in the
441      // buffer. Drop any new messages.
442      // TODO(hellner): its probably better to drop old messages instead
443      //                of new ones. One step further: if this happens
444      //                it's due to writing faster than what can be
445      //                processed. Maybe modify the filter at this point.
446      //                E.g. turn of STREAM.
447      return;
448    }
449  }
450
451  uint16_t idx = next_free_idx_[active_queue_];
452  next_free_idx_[active_queue_]++;
453
454  level_[active_queue_][idx] = level;
455  length_[active_queue_][idx] = length;
456  memcpy(message_queue_[active_queue_][idx], trace_message, length);
457
458  if (next_free_idx_[active_queue_] == WEBRTC_TRACE_MAX_QUEUE - 1) {
459    // Logging more messages than can be worked off. Log a warning.
460    const char warning_msg[] = "WARNING MISSING TRACE MESSAGES\n";
461    level_[active_queue_][next_free_idx_[active_queue_]] = kTraceWarning;
462    length_[active_queue_][next_free_idx_[active_queue_]] = strlen(warning_msg);
463    memcpy(message_queue_[active_queue_][next_free_idx_[active_queue_]],
464           warning_msg, strlen(warning_msg));
465    next_free_idx_[active_queue_]++;
466  }
467}
468
469bool TraceImpl::Run(void* obj) {
470  return static_cast<TraceImpl*>(obj)->Process();
471}
472
473bool TraceImpl::Process() {
474  if (event_.Wait(1000) == kEventSignaled) {
475    // This slightly odd construction is to avoid locking |critsect_interface_|
476    // while calling WriteToFile() since it's locked inside the function.
477    critsect_interface_->Enter();
478    bool write_to_file = trace_file_.Open() || callback_;
479    critsect_interface_->Leave();
480    if (write_to_file) {
481      WriteToFile();
482    }
483  } else {
484    CriticalSectionScoped lock(critsect_interface_);
485    trace_file_.Flush();
486  }
487  return true;
488}
489
490void TraceImpl::WriteToFile() {
491  uint8_t local_queue_active = 0;
492  uint16_t local_next_free_idx = 0;
493
494  // There are two buffers. One for reading (for writing to file) and one for
495  // writing (for storing new messages). Let new messages be posted to the
496  // unused buffer so that the current buffer can be flushed safely.
497  {
498    CriticalSectionScoped lock(critsect_array_);
499    local_next_free_idx = next_free_idx_[active_queue_];
500    next_free_idx_[active_queue_] = 0;
501    local_queue_active = active_queue_;
502    if (active_queue_ == 0) {
503      active_queue_ = 1;
504    } else {
505      active_queue_ = 0;
506    }
507  }
508  if (local_next_free_idx == 0) {
509    return;
510  }
511
512  CriticalSectionScoped lock(critsect_interface_);
513
514  for (uint16_t idx = 0; idx < local_next_free_idx; ++idx) {
515    TraceLevel local_level = level_[local_queue_active][idx];
516    if (callback_) {
517      callback_->Print(local_level, message_queue_[local_queue_active][idx],
518                       length_[local_queue_active][idx]);
519    }
520    if (trace_file_.Open()) {
521      if (row_count_text_ > WEBRTC_TRACE_MAX_FILE_SIZE) {
522        // wrap file
523        row_count_text_ = 0;
524        trace_file_.Flush();
525
526        if (file_count_text_ == 0) {
527          trace_file_.Rewind();
528        } else {
529          char old_file_name[FileWrapper::kMaxFileNameSize];
530          char new_file_name[FileWrapper::kMaxFileNameSize];
531
532          // get current name
533          trace_file_.FileName(old_file_name,
534                               FileWrapper::kMaxFileNameSize);
535          trace_file_.CloseFile();
536
537          file_count_text_++;
538
539          UpdateFileName(old_file_name, new_file_name, file_count_text_);
540
541          if (trace_file_.OpenFile(new_file_name, false, false,
542                                   true) == -1) {
543            return;
544          }
545        }
546      }
547      if (row_count_text_ ==  0) {
548        char message[WEBRTC_TRACE_MAX_MESSAGE_SIZE + 1];
549        int32_t length = AddDateTimeInfo(message);
550        if (length != -1) {
551          message[length] = 0;
552          message[length - 1] = '\n';
553          trace_file_.Write(message, length);
554          row_count_text_++;
555        }
556        length = AddBuildInfo(message);
557        if (length != -1) {
558          message[length + 1] = 0;
559          message[length] = '\n';
560          message[length - 1] = '\n';
561          trace_file_.Write(message, length + 1);
562          row_count_text_++;
563          row_count_text_++;
564        }
565      }
566      uint16_t length = length_[local_queue_active][idx];
567      message_queue_[local_queue_active][idx][length] = 0;
568      message_queue_[local_queue_active][idx][length - 1] = '\n';
569      trace_file_.Write(message_queue_[local_queue_active][idx], length);
570      row_count_text_++;
571    }
572  }
573}
574
575void TraceImpl::AddImpl(const TraceLevel level, const TraceModule module,
576                        const int32_t id,
577                        const char msg[WEBRTC_TRACE_MAX_MESSAGE_SIZE]) {
578  if (TraceCheck(level)) {
579    char trace_message[WEBRTC_TRACE_MAX_MESSAGE_SIZE];
580    char* message_ptr = trace_message;
581
582    int32_t len = 0;
583    int32_t ack_len = 0;
584
585    len = AddLevel(message_ptr, level);
586    if (len == -1) {
587      return;
588    }
589    message_ptr += len;
590    ack_len += len;
591
592    len = AddTime(message_ptr, level);
593    if (len == -1) {
594      return;
595    }
596    message_ptr += len;
597    ack_len += len;
598
599    len = AddModuleAndId(message_ptr, module, id);
600    if (len == -1) {
601      return;
602    }
603    message_ptr += len;
604    ack_len += len;
605
606    len = AddThreadId(message_ptr);
607    if (len < 0) {
608      return;
609    }
610    message_ptr += len;
611    ack_len += len;
612
613    len = AddMessage(message_ptr, msg, (uint16_t)ack_len);
614    if (len == -1) {
615      return;
616    }
617    ack_len += len;
618    AddMessageToList(trace_message, (uint16_t)ack_len, level);
619
620    // Make sure that messages are written as soon as possible.
621    event_.Set();
622  }
623}
624
625bool TraceImpl::TraceCheck(const TraceLevel level) const {
626  return (level & level_filter()) ? true : false;
627}
628
629bool TraceImpl::UpdateFileName(
630    const char file_name_utf8[FileWrapper::kMaxFileNameSize],
631    char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize],
632    const uint32_t new_count) const {
633  int32_t length = (int32_t)strlen(file_name_utf8);
634  if (length < 0) {
635    return false;
636  }
637
638  int32_t length_without_file_ending = length - 1;
639  while (length_without_file_ending > 0) {
640    if (file_name_utf8[length_without_file_ending] == '.') {
641      break;
642    } else {
643      length_without_file_ending--;
644    }
645  }
646  if (length_without_file_ending == 0) {
647    length_without_file_ending = length;
648  }
649  int32_t length_to_ = length_without_file_ending - 1;
650  while (length_to_ > 0) {
651    if (file_name_utf8[length_to_] == '_') {
652      break;
653    } else {
654      length_to_--;
655    }
656  }
657
658  memcpy(file_name_with_counter_utf8, file_name_utf8, length_to_);
659  sprintf(file_name_with_counter_utf8 + length_to_, "_%lu%s",
660          static_cast<long unsigned int>(new_count),
661          file_name_utf8 + length_without_file_ending);
662  return true;
663}
664
665bool TraceImpl::CreateFileName(
666    const char file_name_utf8[FileWrapper::kMaxFileNameSize],
667    char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize],
668    const uint32_t new_count) const {
669  int32_t length = (int32_t)strlen(file_name_utf8);
670  if (length < 0) {
671    return false;
672  }
673
674  int32_t length_without_file_ending = length - 1;
675  while (length_without_file_ending > 0) {
676    if (file_name_utf8[length_without_file_ending] == '.') {
677      break;
678    } else {
679      length_without_file_ending--;
680    }
681  }
682  if (length_without_file_ending == 0) {
683    length_without_file_ending = length;
684  }
685  memcpy(file_name_with_counter_utf8, file_name_utf8,
686         length_without_file_ending);
687  sprintf(file_name_with_counter_utf8 + length_without_file_ending, "_%lu%s",
688          static_cast<long unsigned int>(new_count),
689          file_name_utf8 + length_without_file_ending);
690  return true;
691}
692
693void Trace::CreateTrace() {
694  TraceImpl::StaticInstance(kAddRef);
695}
696
697void Trace::ReturnTrace() {
698  TraceImpl::StaticInstance(kRelease);
699}
700
701int32_t Trace::TraceFile(char file_name[FileWrapper::kMaxFileNameSize]) {
702  TraceImpl* trace = TraceImpl::GetTrace();
703  if (trace) {
704    int ret_val = trace->TraceFileImpl(file_name);
705    ReturnTrace();
706    return ret_val;
707  }
708  return -1;
709}
710
711int32_t Trace::SetTraceFile(const char* file_name,
712                            const bool add_file_counter) {
713  TraceImpl* trace = TraceImpl::GetTrace();
714  if (trace) {
715    int ret_val = trace->SetTraceFileImpl(file_name, add_file_counter);
716    ReturnTrace();
717    return ret_val;
718  }
719  return -1;
720}
721
722int32_t Trace::SetTraceCallback(TraceCallback* callback) {
723  TraceImpl* trace = TraceImpl::GetTrace();
724  if (trace) {
725    int ret_val = trace->SetTraceCallbackImpl(callback);
726    ReturnTrace();
727    return ret_val;
728  }
729  return -1;
730}
731
732void Trace::Add(const TraceLevel level, const TraceModule module,
733                const int32_t id, const char* msg, ...) {
734  TraceImpl* trace = TraceImpl::GetTrace(level);
735  if (trace) {
736    if (trace->TraceCheck(level)) {
737      char temp_buff[WEBRTC_TRACE_MAX_MESSAGE_SIZE];
738      char* buff = 0;
739      if (msg) {
740        va_list args;
741        va_start(args, msg);
742#ifdef _WIN32
743        _vsnprintf(temp_buff, WEBRTC_TRACE_MAX_MESSAGE_SIZE - 1, msg, args);
744#else
745        vsnprintf(temp_buff, WEBRTC_TRACE_MAX_MESSAGE_SIZE - 1, msg, args);
746#endif
747        va_end(args);
748        buff = temp_buff;
749      }
750      trace->AddImpl(level, module, id, buff);
751    }
752    ReturnTrace();
753  }
754}
755
756}  // namespace webrtc
757