Report better error message on update sandbox for gn builds

media/cast/sender/audio_encoder.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/sender/audio_encoder.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/stl_util.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
+#include "base/trace_event/trace_event.h"
 #include "media/cast/cast_defines.h"
 
 #if !defined(OS_IOS)
 #include "third_party/opus/src/include/opus.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include <AudioToolbox/AudioToolbox.h>
 #endif
 
@@ skipping 73 matching lines @@
       const int64 num_frames_missed = amount_ahead_by / frame_duration_;
       if (num_frames_missed > kUnderrunSkipThreshold) {
         samples_dropped_from_buffer_ += buffer_fill_end_;
         buffer_fill_end_ = 0;
         buffer_fill_duration = base::TimeDelta();
         frame_rtp_timestamp_ +=
             static_cast<uint32>(num_frames_missed * samples_per_frame_);
         DVLOG(1) << "Skipping RTP timestamp ahead to account for "
                  << num_frames_missed * samples_per_frame_
                  << " samples' worth of underrun.";
+        TRACE_EVENT_INSTANT2("cast.stream", "Audio Skip",
+                             TRACE_EVENT_SCOPE_THREAD,
+                             "frames missed", num_frames_missed,
+                             "sample_dropped", samples_dropped_from_buffer_);
       }
     }
     frame_capture_time_ = recorded_time - buffer_fill_duration;
 
     // Encode all audio in |audio_bus| into zero or more frames.
     int src_pos = 0;
     while (src_pos < audio_bus->frames()) {
       // Note: This is used to compute the deadline utilization and so it uses
       // the real-world clock instead of the CastEnvironment clock, the latter
       // of which might be simulated.
@@ skipping 11 matching lines @@
         break;
 
       scoped_ptr<SenderEncodedFrame> audio_frame(
           new SenderEncodedFrame());
       audio_frame->dependency = EncodedFrame::KEY;
       audio_frame->frame_id = frame_id_;
       audio_frame->referenced_frame_id = frame_id_;
       audio_frame->rtp_timestamp = frame_rtp_timestamp_;
       audio_frame->reference_time = frame_capture_time_;
 
+      TRACE_EVENT_ASYNC_BEGIN2("cast.stream", "Audio Encode", audio_frame.get(),
+                               "frame_id", frame_id_,
+                               "rtp_timestamp", frame_rtp_timestamp_);
       if (EncodeFromFilledBuffer(&audio_frame->data)) {
         // Compute deadline utilization as the real-world time elapsed divided
         // by the signal duration.
         audio_frame->deadline_utilization =
             (base::TimeTicks::Now() - start_time).InSecondsF() /
                 frame_duration_.InSecondsF();
 
+        TRACE_EVENT_ASYNC_END1("cast.stream", "Audio Encode", audio_frame.get(),
+                               "Deadline utilization",
+                               audio_frame->deadline_utilization);
         cast_environment_->PostTask(
             CastEnvironment::MAIN,
             FROM_HERE,
             base::Bind(callback_,
                        base::Passed(&audio_frame),
                        samples_dropped_from_buffer_));
         samples_dropped_from_buffer_ = 0;
       }
 
       // Reset the internal buffer, frame ID, and timestamps for the next frame.
@@ skipping 673 matching lines @@
   cast_environment_->PostTask(CastEnvironment::AUDIO,
                               FROM_HERE,
                               base::Bind(&AudioEncoder::ImplBase::EncodeAudio,
                                          impl_,
                                          base::Passed(&audio_bus),
                                          recorded_time));
 }
 
 }  // namespace cast
 }  // namespace media