cast: Wire upp logging to be sent over RTCP between receiver and sender.

media/cast/video_sender/video_sender.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_sender/video_sender.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 208 matching lines @@
 
   cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&VideoSender::SendRtcpReport, weak_factory_.GetWeakPtr()),
                  time_to_next);
 }
 
 void VideoSender::SendRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   transport::RtcpSenderLogMessage sender_log_message;
-  const FrameRawMap& frame_raw_map =
-      cast_environment_->Logging()->GetFrameRawData();
+  VideoRtcpRawMap video_logs =
+      cast_environment_->Logging()->GetVideoRtcpRawData();
 
-  FrameRawMap::const_iterator it = frame_raw_map.begin();
-  while (it != frame_raw_map.end()) {
+  while (!video_logs.empty()) {
+    VideoRtcpRawMap::iterator it = video_logs.begin();
+    uint32 rtp_timestamp = it->first;
+
     transport::RtcpSenderFrameLogMessage frame_message;
-    frame_message.rtp_timestamp = it->first;
+    frame_message.rtp_timestamp = rtp_timestamp;
     frame_message.frame_status = transport::kRtcpSenderFrameStatusUnknown;
-    if (it->second.type.empty()) {
-      ++it;
-      continue;
-    }
-    CastLoggingEvent last_event = it->second.type.back();
-    switch (last_event) {
+
+    switch (it->second.type) {
       case kVideoFrameCaptured:
         frame_message.frame_status =
             transport::kRtcpSenderFrameStatusDroppedByFlowControl;
         break;
       case kVideoFrameSentToEncoder:
         frame_message.frame_status =
             transport::kRtcpSenderFrameStatusDroppedByEncoder;
         break;
       case kVideoFrameEncoded:
         frame_message.frame_status =
             transport::kRtcpSenderFrameStatusSentToNetwork;
         break;
       default:
-        ++it;
-        continue;
+        NOTREACHED();
+        break;
     }
-    ++it;
-    if (it == frame_raw_map.end()) {
-      // Last message on our map; only send if it is kVideoFrameEncoded.
-      if (last_event != kVideoFrameEncoded) {
-        // For other events we will wait for it to finish and report the result
-        // in the next report.
-        break;
-      }
-    }
+    video_logs.erase(rtp_timestamp);
     sender_log_message.push_back(frame_message);
   }
   rtcp_->SendRtcpFromRtpSender(&sender_log_message);
   if (!sender_log_message.empty()) {
     VLOG(1) << "Failed to send all log messages";
   }
-
-  // TODO(pwestin): When we start pulling out the logging by other means we need
-  // to synchronize this.
-  cast_environment_->Logging()->ResetRaw();
   ScheduleNextRtcpReport();
 }
 
 void VideoSender::ScheduleNextResendCheck() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeDelta time_to_next;
   if (last_send_time_.is_null()) {
     time_to_next = rtp_max_delay_;
   } else {
     time_to_next = last_send_time_ - cast_environment_->Clock()->NowTicks() +
@@ skipping 120 matching lines @@
       video_encoder_->SetBitRate(new_bitrate);
     }
   }
   ReceivedAck(cast_feedback.ack_frame_id_);
 }
 
 void VideoSender::ReceivedAck(uint32 acked_frame_id) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   last_acked_frame_id_ = static_cast<int>(acked_frame_id);
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-  cast_environment_->Logging()->InsertGenericEvent(now, kAckReceived,
+  cast_environment_->Logging()->InsertGenericEvent(now, kVideoAckReceived,
                                                    acked_frame_id);
   VLOG(1) << "ReceivedAck:" << static_cast<int>(acked_frame_id);
   last_acked_frame_id_ = acked_frame_id;
   UpdateFramesInFlight();
 }
 
 void VideoSender::UpdateFramesInFlight() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (last_sent_frame_id_ != -1) {
     DCHECK_LE(0, last_sent_frame_id_);
@@ skipping 19 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   MissingFramesAndPacketsMap missing_frames_and_packets;
   PacketIdSet missing;
   missing_frames_and_packets.insert(std::make_pair(resend_frame_id, missing));
   rtp_sender_->ResendPackets(missing_frames_and_packets);
   last_send_time_ = cast_environment_->Clock()->NowTicks();
 }
 
 }  // namespace cast
 }  // namespace media