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"
 #include "base/message_loop/message_loop.h"
@@ skipping 39 matching lines @@
   bool GetPacketTimeInformation(base::TimeTicks* time_incoming_packet,
                                 uint32* incoming_rtp_timestamp) {
     *time_incoming_packet = time_incoming_packet_;
     *incoming_rtp_timestamp = incoming_rtp_timestamp_;
     bool time_updated = time_updated_;
     time_updated_ = false;
     return time_updated;
   }
 
  private:
-  base::TickClock* clock_;  // Not owned by this class.
+  base::TickClock* const clock_;  // Not owned by this class.
   VideoReceiver* video_receiver_;
   bool time_updated_;
   base::TimeTicks time_incoming_packet_;
   uint32 incoming_rtp_timestamp_;
 };
 
 // Local implementation of RtpPayloadFeedback (defined in rtp_defines.h)
 // Used to convey cast-specific feedback from receiver to sender.
 // Callback triggered by the Framer (cast message builder).
 class LocalRtpVideoFeedback : public RtpPayloadFeedback {
@@ skipping 57 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),
                false,
                video_config.feedback_ssrc,
                video_config.rtcp_c_name));
 
@@ skipping 68 matching lines @@
 // Should we pull the encoded video frame from the framer? decided by if this is
 // 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) {
   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 107 matching lines @@
     rtcp_->IncomingRtcpPacket(packet, length);
   } else {
     rtp_receiver_.ReceivedPacket(packet, length);
   }
   cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE, callback);
 }
 
 void VideoReceiver::IncomingRtpPacket(const uint8* payload_data,
                                       size_t payload_size,
                                       const RtpCastHeader& rtp_header) {
+  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 39 matching lines @@
                 weak_factory_.GetWeakPtr()), time_to_next);
 }
 
 void VideoReceiver::SendNextRtcpReport() {
   rtcp_->SendRtcpReport(incoming_ssrc_);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media