Report better error message on update sandbox for gn builds

media/cast/sender/frame_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/frame_sender.h"
 
 #include "base/trace_event/trace_event.h"
 #include "media/cast/sender/sender_encoded_frame.h"
 
 namespace media {
@@ skipping 242 matching lines @@
     SendRtcpReport(is_last_aggressive_report);
   }
 
   congestion_control_->SendFrameToTransport(
       frame_id, encoded_frame->data.size() * 8, last_send_time_);
 
   if (send_target_playout_delay_) {
     encoded_frame->new_playout_delay_ms =
         target_playout_delay_.InMilliseconds();
   }
+
+  TRACE_EVENT_ASYNC_BEGIN2("cast.stream",
+      is_audio_ ? "Audio Transport" : "Video Transport",
+      frame_id,
+      "timestamp", encoded_frame->reference_time.ToInternalValue(),
+      "rtp_timestamp", encoded_frame->rtp_timestamp);
   transport_sender_->InsertFrame(ssrc_, *encoded_frame);
 }
 
 void FrameSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   const bool have_valid_rtt = current_round_trip_time_ > base::TimeDelta();
   if (have_valid_rtt) {
     congestion_control_->UpdateRtt(current_round_trip_time_);
 
@@ skipping 19 matching lines @@
     if (latest_acked_frame_id_ == cast_feedback.ack_frame_id &&
         latest_acked_frame_id_ != last_sent_frame_id_) {
       duplicate_ack_counter_++;
     } else {
       duplicate_ack_counter_ = 0;
     }
     // TODO(miu): The values "2" and "3" should be derived from configuration.
     if (duplicate_ack_counter_ >= 2 && duplicate_ack_counter_ % 3 == 2) {
       VLOG(1) << SENDER_SSRC << "Received duplicate ACK for frame "
               << latest_acked_frame_id_;
+      TRACE_EVENT_INSTANT2(
+        "cast.stream", "Duplicate ACK", TRACE_EVENT_SCOPE_THREAD,
+        "ack_frame_id", cast_feedback.ack_frame_id,
+        "last_sent_frame_id", last_sent_frame_id_);
       ResendForKickstart();
     }
   } else {
     // Only count duplicated ACKs if there is no NACK request in between.
     // This is to avoid aggresive resend.
     duplicate_ack_counter_ = 0;
   }
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   congestion_control_->AckFrame(cast_feedback.ack_frame_id, now);
 
   cast_environment_->Logging()->InsertFrameEvent(
       now,
       FRAME_ACK_RECEIVED,
       is_audio_ ? AUDIO_EVENT : VIDEO_EVENT,
       GetRecordedRtpTimestamp(cast_feedback.ack_frame_id),
       cast_feedback.ack_frame_id);
+  if (!duplicate_ack_counter_) {
+    if (have_valid_rtt) {
+      TRACE_EVENT_ASYNC_END1("cast.stream",
+          is_audio_ ? "Audio Transport" : "Video Transport",
+          cast_feedback.ack_frame_id,
+          "RTT", current_round_trip_time_.ToInternalValue());
+    } else {
+      TRACE_EVENT_ASYNC_END0("cast.stream",
+          is_audio_ ? "Audio Transport" : "Video Transport",
+          cast_feedback.ack_frame_id);
+    }
+  }
 
   const bool is_acked_out_of_order =
       static_cast<int32>(cast_feedback.ack_frame_id -
                              latest_acked_frame_id_) < 0;
   VLOG(2) << SENDER_SSRC
           << "Received ACK" << (is_acked_out_of_order ? " out-of-order" : "")
           << " for frame " << cast_feedback.ack_frame_id;
   if (!is_acked_out_of_order) {
     // Cancel resends of acked frames.
     std::vector<uint32> cancel_sending_frames;
     while (latest_acked_frame_id_ != cast_feedback.ack_frame_id) {
       latest_acked_frame_id_++;
       cancel_sending_frames.push_back(latest_acked_frame_id_);
     }
     transport_sender_->CancelSendingFrames(ssrc_, cancel_sending_frames);
     latest_acked_frame_id_ = cast_feedback.ack_frame_id;
+  } else {
+    TRACE_EVENT_INSTANT2(
+        "cast.stream", "ACK out of order", TRACE_EVENT_SCOPE_THREAD,
+        "ack_frame_id", cast_feedback.ack_frame_id,
+        "latest_acked_frame_id", latest_acked_frame_id_);
   }
 }
 
 bool FrameSender::ShouldDropNextFrame(base::TimeDelta frame_duration) const {
   // Check that accepting the next frame won't cause more frames to become
   // in-flight than the system's design limit.
   const int count_frames_in_flight =
       GetUnacknowledgedFrameCount() + GetNumberOfFramesInEncoder();
   if (count_frames_in_flight >= kMaxUnackedFrames) {
     VLOG(1) << SENDER_SSRC << "Dropping: Too many frames would be in-flight.";
@@ skipping 28 matching lines @@
     VLOG(1) << SENDER_SSRC << "Dropping: In-flight duration would be too high.";
     return true;
   }
 
   // Next frame is accepted.
   return false;
 }
 
 }  // namespace cast
 }  // namespace media