Add TRACE_EVENTX() in WebAudio rendering pipe line

third_party/WebKit/Source/platform/audio/AudioDestination.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 16 matching lines @@
  */
 
 #include "platform/audio/AudioDestination.h"
 
 #include <memory>
 #include "platform/CrossThreadFunctional.h"
 #include "platform/Histogram.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/audio/AudioUtilities.h"
 #include "platform/audio/PushPullFIFO.h"
+#include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAudioLatencyHint.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "public/platform/WebThread.h"
 
 namespace blink {
 
 // FIFO Size.
@@ skipping 46 matching lines @@
 
 AudioDestination::~AudioDestination() {
   Stop();
 }
 
 void AudioDestination::Render(const WebVector<float*>& destination_data,
                               size_t number_of_frames,
                               double delay,
                               double delay_timestamp,
                               size_t prior_frames_skipped) {
+  TRACE_EVENT1("webaudio", "AudioDestination::Render",
+               "callback_buffer_size", number_of_frames);
+
   // This method is called by AudioDeviceThread.
   DCHECK(!IsRenderingThread());
 
   CHECK_EQ(destination_data.size(), number_of_output_channels_);
   CHECK_EQ(number_of_frames, callback_buffer_size_);
 
   // Note that this method is called by AudioDeviceThread. If FIFO is not ready,
   // or the requested render size is greater than FIFO size return here.
   // (crbug.com/692423)
   if (!fifo_ || fifo_->length() < number_of_frames)
@@ skipping 15 matching lines @@
                         frames_to_render, delay, delay_timestamp,
                         prior_frames_skipped));
   }
 }
 
 void AudioDestination::RequestRenderOnWebThread(size_t frames_requested,
                                                 size_t frames_to_render,
                                                 double delay,
                                                 double delay_timestamp,
                                                 size_t prior_frames_skipped) {
+  TRACE_EVENT1("webaudio", "AudioDestination::RequestRenderOnWebThread",
+               "frames_to_render", frames_to_render);
+
   // This method is called by WebThread.
   DCHECK(IsRenderingThread());
 
   frames_elapsed_ -= std::min(frames_elapsed_, prior_frames_skipped);
   AudioIOPosition output_position;
   output_position.position =
       frames_elapsed_ / static_cast<double>(web_audio_device_->SampleRate()) -
       delay;
   output_position.timestamp = delay_timestamp;
   base::TimeTicks received_timestamp = base::TimeTicks::Now();
@@ skipping 21 matching lines @@
   }
 
   frames_elapsed_ += frames_requested;
 }
 
 void AudioDestination::Start() {
   DCHECK(IsMainThread());
 
   // Start the "audio device" after the rendering thread is ready.
   if (web_audio_device_ && !is_playing_) {
+    TRACE_EVENT0("webaudio", "AudioDestination::Start");
     rendering_thread_ =
         Platform::Current()->CreateThread("WebAudio Rendering Thread");
     web_audio_device_->Start();
     is_playing_ = true;
   }
 }
 
 void AudioDestination::Stop() {
   DCHECK(IsMainThread());
 
   // This assumes stopping the "audio device" is synchronous and dumping the
   // rendering thread is safe after that.
   if (web_audio_device_ && is_playing_) {
+    TRACE_EVENT0("webaudio", "AudioDestination::Stop");
     web_audio_device_->Stop();
     rendering_thread_.reset();
     is_playing_ = false;
   }
 }
 
 size_t AudioDestination::CallbackBufferSize() const {
   DCHECK(IsMainThread());
   return callback_buffer_size_;
 }
@@ skipping 42 matching lines @@
   DCHECK(is_buffer_size_valid);
   return is_buffer_size_valid;
 }
 
 bool AudioDestination::IsRenderingThread() {
   return static_cast<ThreadIdentifier>(rendering_thread_->ThreadId()) ==
          CurrentThread();
 }
 
 }  // namespace blink