Add performance tracing for PlatformThread and parts of the video code.

webrtc/modules/video_coding/frame_buffer.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
 #include "webrtc/modules/video_coding/frame_buffer.h"
 
 #include <assert.h>
 #include <string.h>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/trace_event.h"
 #include "webrtc/modules/video_coding/packet.h"
 
 namespace webrtc {
 
 VCMFrameBuffer::VCMFrameBuffer()
     : _state(kStateEmpty), _nackCount(0), _latestPacketTimeMs(-1) {}
 
 VCMFrameBuffer::~VCMFrameBuffer() {}
 
 VCMFrameBuffer::VCMFrameBuffer(const VCMFrameBuffer& rhs)
@@ skipping 36 matching lines @@
 
 bool VCMFrameBuffer::NonReference() const {
   return _sessionInfo.NonReference();
 }
 
 std::vector<NaluInfo> VCMFrameBuffer::GetNaluInfos() const {
   return _sessionInfo.GetNaluInfos();
 }
 
 void VCMFrameBuffer::SetGofInfo(const GofInfoVP9& gof_info, size_t idx) {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::SetGofInfo");
   _sessionInfo.SetGofInfo(gof_info, idx);
   // TODO(asapersson): Consider adding hdr->VP9.ref_picture_id for testing.
   _codecSpecificInfo.codecSpecific.VP9.temporal_idx =
       gof_info.temporal_idx[idx];
   _codecSpecificInfo.codecSpecific.VP9.temporal_up_switch =
       gof_info.temporal_up_switch[idx];
 }
 
 bool VCMFrameBuffer::IsSessionComplete() const {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::IsSessionComplete");
   return _sessionInfo.complete();
 }
 
 // Insert packet
 VCMFrameBufferEnum VCMFrameBuffer::InsertPacket(
     const VCMPacket& packet,
     int64_t timeInMs,
     VCMDecodeErrorMode decode_error_mode,
     const FrameData& frame_data) {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::InsertPacket");
   assert(!(NULL == packet.dataPtr && packet.sizeBytes > 0));
   if (packet.dataPtr != NULL) {
     _payloadType = packet.payloadType;
   }
 
   if (kStateEmpty == _state) {
     // First packet (empty and/or media) inserted into this frame.
     // store some info and set some initial values.
     _timeStamp = packet.timestamp;
     // We only take the ntp timestamp of the first packet of a frame.
@@ skipping 67 matching lines @@
     SetState(kStateComplete);
     return kCompleteSession;
   } else if (_sessionInfo.decodable()) {
     SetState(kStateDecodable);
     return kDecodableSession;
   }
   return kIncomplete;
 }
 
 int64_t VCMFrameBuffer::LatestPacketTimeMs() const {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::LatestPacketTimeMs");
   return _latestPacketTimeMs;
 }
 
 void VCMFrameBuffer::IncrementNackCount() {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::IncrementNackCount");
   _nackCount++;
 }
 
 int16_t VCMFrameBuffer::GetNackCount() const {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::GetNackCount");
   return _nackCount;
 }
 
 bool VCMFrameBuffer::HaveFirstPacket() const {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::HaveFirstPacket");
   return _sessionInfo.HaveFirstPacket();
 }
 
 bool VCMFrameBuffer::HaveLastPacket() const {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::HaveLastPacket");
   return _sessionInfo.HaveLastPacket();
 }
 
 int VCMFrameBuffer::NumPackets() const {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::NumPackets");
   return _sessionInfo.NumPackets();
 }
 
 void VCMFrameBuffer::Reset() {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::Reset");
   _length = 0;
   _timeStamp = 0;
   _sessionInfo.Reset();
   _payloadType = 0;
   _nackCount = 0;
   _latestPacketTimeMs = -1;
   _state = kStateEmpty;
   VCMEncodedFrame::Reset();
 }
 
 // Set state of frame
 void VCMFrameBuffer::SetState(VCMFrameBufferStateEnum state) {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::SetState");
   if (_state == state) {
     return;
   }
   switch (state) {
     case kStateIncomplete:
       // we can go to this state from state kStateEmpty
       assert(_state == kStateEmpty);
 
       // Do nothing, we received a packet
       break;
@@ skipping 16 matching lines @@
   _state = state;
 }
 
 // Get current state of frame
 VCMFrameBufferStateEnum VCMFrameBuffer::GetState() const {
   return _state;
 }
 
 // Get current state of frame
 VCMFrameBufferStateEnum VCMFrameBuffer::GetState(uint32_t& timeStamp) const {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::GetState");
   timeStamp = TimeStamp();
   return GetState();
 }
 
 bool VCMFrameBuffer::IsRetransmitted() const {
   return _sessionInfo.session_nack();
 }
 
 void VCMFrameBuffer::PrepareForDecode(bool continuous) {
+  TRACE_EVENT0("webrtc", "VCMFrameBuffer::PrepareForDecode");
   size_t bytes_removed = _sessionInfo.MakeDecodable();
   _length -= bytes_removed;
   // Transfer frame information to EncodedFrame and create any codec
   // specific information.
   _frameType = _sessionInfo.FrameType();
   _completeFrame = _sessionInfo.complete();
   _missingFrame = !continuous;
 }
 
 }  // namespace webrtc