Incorporating logging into Cast

media/cast/video_receiver/video_receiver.cc

 // Copyright 2013 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/video_receiver/video_receiver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 109 matching lines @@
   framer_.reset(new Framer(cast_environment->Clock(),
                            incoming_payload_feedback_.get(),
                            video_config.incoming_ssrc,
                            video_config.decoder_faster_than_max_frame_rate,
                            max_unacked_frames));
   if (!video_config.use_external_decoder) {
     video_decoder_.reset(new VideoDecoder(video_config, cast_environment));
   }
 
   rtcp_.reset(
-      new Rtcp(cast_environment_->Clock(),
+      new Rtcp(cast_environment_,
                NULL,
                packet_sender,
                NULL,
                rtp_video_receiver_statistics_.get(),
                video_config.rtcp_mode,
                base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
                video_config.feedback_ssrc,
                video_config.incoming_ssrc,
                video_config.rtcp_c_name));
 }
@@ skipping 101 matching lines @@
 // the next frame or we are running out of time and have to pull the following
 // frame.
 // If the frame it too old to be rendered we set the don't show flag in the
 // video bitstream where possible.
 bool VideoReceiver::PullEncodedVideoFrame(uint32 rtp_timestamp,
     bool next_frame, scoped_ptr<EncodedVideoFrame>* encoded_frame,
     base::TimeTicks* render_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   *render_time = GetRenderTime(now, rtp_timestamp);
+  base::TimeDelta diff = now - *render_time;
+
+  cast_environment_->Logging()->InsertFrameEvent(kVideoRenderDelay,
+      rtp_timestamp, diff.InMilliseconds());
 
   // Minimum time before a frame is due to be rendered before we pull it for
   // decode.
   base::TimeDelta min_wait_delta = frame_delay_;
   base::TimeDelta time_until_render = *render_time - now;
   if (!next_frame && (time_until_render > min_wait_delta)) {
     // Example:
     // We have decoded frame 1 and we have received the complete frame 3, but
     // not frame 2. If we still have time before frame 3 should be rendered we
     // will wait for 2 to arrive, however if 2 never show up this timer will hit
@@ skipping 122 matching lines @@
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   if (time_incoming_packet_.is_null() || now - time_incoming_packet_ >
       base::TimeDelta::FromMilliseconds(kMinTimeBetweenOffsetUpdatesMs)) {
     if (time_incoming_packet_.is_null()) InitializeTimers();
     incoming_rtp_timestamp_ = rtp_header.webrtc.header.timestamp;
     time_incoming_packet_ = now;
     time_incoming_packet_updated_ = true;
   }
 
+  cast_environment_->Logging()->InsertPacketEvent(kPacketReceived,
+      rtp_header.webrtc.header.timestamp, rtp_header.frame_id,
+      rtp_header.packet_id, rtp_header.max_packet_id, payload_size);
+
   bool complete = framer_->InsertPacket(payload_data, payload_size, rtp_header);
 
   if (!complete) return;  // Video frame not complete; wait for more packets.
   if (queued_encoded_callbacks_.empty()) return;  // No pending callback.
 
   VideoFrameEncodedCallback callback = queued_encoded_callbacks_.front();
   queued_encoded_callbacks_.pop_front();
   cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&VideoReceiver::GetEncodedVideoFrame,
           weak_factory_.GetWeakPtr(), callback));
@@ skipping 45 matching lines @@
 }
 
 void VideoReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_->SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media