Report better error message on update sandbox for gn builds

media/cast/sender/video_sender.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/video_sender.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
@@ skipping 142 matching lines @@
   // Drop the frame if either its RTP or reference timestamp is not an increase
   // over the last frame's.  This protects: 1) the duration calculations that
   // assume timestamps are monotonically non-decreasing, and 2) assumptions made
   // deeper in the implementation where each frame's RTP timestamp needs to be
   // unique.
   if (!last_enqueued_frame_reference_time_.is_null() &&
       (!IsNewerRtpTimestamp(rtp_timestamp,
                             last_enqueued_frame_rtp_timestamp_) ||
        reference_time <= last_enqueued_frame_reference_time_)) {
     VLOG(1) << "Dropping video frame: RTP or reference time did not increase.";
+    TRACE_EVENT_INSTANT2("cast.stream", "Video Frame Drop",
+                        TRACE_EVENT_SCOPE_THREAD,
+                        "timestamp", reference_time.ToInternalValue(),
+                        "rtp_timestamp", rtp_timestamp);
     return;
   }
 
   // Two video frames are needed to compute the exact media duration added by
   // the next frame.  If there are no frames in the encoder, compute a guess
   // based on the configured |max_frame_rate_|.  Any error introduced by this
   // guess will be eliminated when |duration_in_encoder_| is updated in
   // OnEncodedVideoFrame().
   const base::TimeDelta duration_added_by_next_frame = frames_in_encoder_ > 0 ?
       reference_time - last_enqueued_frame_reference_time_ :
       base::TimeDelta::FromSecondsD(1.0 / max_frame_rate_);
 
   if (ShouldDropNextFrame(duration_added_by_next_frame)) {
     base::TimeDelta new_target_delay = std::min(
         current_round_trip_time_ * kRoundTripsNeeded +
         base::TimeDelta::FromMilliseconds(kConstantTimeMs),
         max_playout_delay_);
     if (new_target_delay > target_playout_delay_) {
       VLOG(1) << "New target delay: " << new_target_delay.InMilliseconds();
       playout_delay_change_cb_.Run(new_target_delay);
     }
 
     // Some encoder implementations have a frame window for analysis. Since we
     // are dropping this frame, unless we instruct the encoder to flush all the
     // frames that have been enqueued for encoding, frames_in_encoder_ and
     // last_enqueued_frame_reference_time_ will never be updated and we will
     // drop every subsequent frame for the rest of the session.
     video_encoder_->EmitFrames();
 
+    TRACE_EVENT_INSTANT2("cast.stream", "Video Frame Drop",
+                        TRACE_EVENT_SCOPE_THREAD,
+                        "timestamp", reference_time.ToInternalValue(),
+                        "rtp_timestamp", rtp_timestamp);
     return;
   }
 
   uint32 bitrate = congestion_control_->GetBitrate(
         reference_time + target_playout_delay_, target_playout_delay_);
+
+  TRACE_COUNTER_ID1("cast.stream", "Video Target Bitrate", this, bitrate);
+
   if (bitrate != last_bitrate_) {
     video_encoder_->SetBitRate(bitrate);
     last_bitrate_ = bitrate;
   }
 
   if (video_frame->visible_rect().IsEmpty()) {
     VLOG(1) << "Rejecting empty video frame.";
     return;
   }
 
   MaybeRenderPerformanceMetricsOverlay(bitrate,
                                        frames_in_encoder_ + 1,
                                        last_reported_deadline_utilization_,
                                        last_reported_lossy_utilization_,
                                        video_frame.get());
 
+  TRACE_EVENT_ASYNC_BEGIN2("cast.stream", "Video Encode", video_frame.get(),
+                           "timestamp", reference_time.ToInternalValue(),
+                           "rtp_timestamp", rtp_timestamp);
   if (video_encoder_->EncodeVideoFrame(
           video_frame,
           reference_time,
           base::Bind(&VideoSender::OnEncodedVideoFrame,
                      weak_factory_.GetWeakPtr(),
                      video_frame,
                      bitrate))) {
     frames_in_encoder_++;
     duration_in_encoder_ += duration_added_by_next_frame;
     last_enqueued_frame_rtp_timestamp_ = rtp_timestamp;
     last_enqueued_frame_reference_time_ = reference_time;
   } else {
     VLOG(1) << "Encoder rejected a frame.  Skipping...";
+    TRACE_EVENT_INSTANT2("cast.stream", "Video Encode Reject",
+                        TRACE_EVENT_SCOPE_THREAD,
+                        "timestamp", reference_time.ToInternalValue(),
+                        "rtp_timestamp", rtp_timestamp);
   }
 }
 
 scoped_ptr<VideoFrameFactory> VideoSender::CreateVideoFrameFactory() {
   return video_encoder_ ? video_encoder_->CreateVideoFrameFactory() : nullptr;
 }
 
 int VideoSender::GetNumberOfFramesInEncoder() const {
   return frames_in_encoder_;
 }
@@ skipping 20 matching lines @@
 
   frames_in_encoder_--;
   DCHECK_GE(frames_in_encoder_, 0);
 
   duration_in_encoder_ =
       last_enqueued_frame_reference_time_ - encoded_frame->reference_time;
 
   last_reported_deadline_utilization_ = encoded_frame->deadline_utilization;
   last_reported_lossy_utilization_ = encoded_frame->lossy_utilization;
 
+  TRACE_EVENT_ASYNC_END2("cast.stream", "Video Encode", video_frame.get(),
+                         "duration", duration_in_encoder_.ToInternalValue(),
+                         "deadline_utilization",
+                         last_reported_lossy_utilization_);
+
   // Report the resource utilization for processing this frame.  Take the
   // greater of the two utilization values and attenuate them such that the
   // target utilization is reported as the maximum sustainable amount.
   const double attenuated_utilization =
       std::max(last_reported_deadline_utilization_,
                last_reported_lossy_utilization_) /
           (kTargetUtilizationPercentage / 100.0);
   if (attenuated_utilization >= 0.0) {
     // Key frames are artificially capped to 1.0 because their actual
     // utilization is atypical compared to the other frames in the stream, and
     // this can misguide the producer of the input video frames.
     video_frame->metadata()->SetDouble(
         media::VideoFrameMetadata::RESOURCE_UTILIZATION,
         encoded_frame->dependency == EncodedFrame::KEY ?
             std::min(1.0, attenuated_utilization) : attenuated_utilization);
   }
 
   SendEncodedFrame(encoder_bitrate, encoded_frame.Pass());
 }
 
 }  // namespace cast
 }  // namespace media