Cast: Simplify code path for RTCP sender report

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 <cstring>
 #include <list>
 
 #include "base/bind.h"
@@ skipping 32 matching lines @@
     const VideoSenderConfig& video_config,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
     const CastInitializationCallback& cast_initialization_cb,
     transport::CastTransportSender* const transport_sender)
     : rtp_max_delay_(base::TimeDelta::FromMilliseconds(
           video_config.rtp_config.max_delay_ms)),
       max_frame_rate_(video_config.max_frame_rate),
       cast_environment_(cast_environment),
       transport_sender_(transport_sender),
-      rtp_stats_(kVideoFrequency),
+      rtp_timestamp_helper_(kVideoFrequency),
       rtcp_feedback_(new LocalRtcpVideoSenderFeedback(this)),
       last_acked_frame_id_(-1),
       last_sent_frame_id_(-1),
       frames_in_encoder_(0),
       duplicate_ack_(0),
       last_skip_count_(0),
       current_requested_bitrate_(video_config.start_bitrate),
       current_bitrate_divider_(1),
       congestion_control_(cast_environment->Clock(),
                           video_config.congestion_control_back_off,
@@ skipping 41 matching lines @@
   rtcp_->SetCastReceiverEventHistorySize(kReceiverRtcpEventHistorySize);
 
   // TODO(pwestin): pass cast_initialization_cb to |video_encoder_|
   // and remove this call.
   cast_environment_->PostTask(
       CastEnvironment::MAIN,
       FROM_HERE,
       base::Bind(cast_initialization_cb, STATUS_VIDEO_INITIALIZED));
 
   memset(frame_id_to_rtp_timestamp_, 0, sizeof(frame_id_to_rtp_timestamp_));
-
-  transport_sender_->SubscribeVideoRtpStatsCallback(
-      base::Bind(&VideoSender::StoreStatistics, weak_factory_.GetWeakPtr()));
 }
 
 VideoSender::~VideoSender() {
 }
 
 void VideoSender::InitializeTimers() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (!initialized_) {
     initialized_ = true;
     ScheduleNextResendCheck();
@@ skipping 56 matching lines @@
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT1(
       "cast_perf_test", "VideoFrameEncoded",
       TRACE_EVENT_SCOPE_THREAD,
       "rtp_timestamp", GetVideoRtpTimestamp(capture_time));
 
   // Only use lowest 8 bits as key.
   frame_id_to_rtp_timestamp_[frame_id & 0xff] = encoded_frame->rtp_timestamp;
 
   last_sent_frame_id_ = static_cast<int>(encoded_frame->frame_id);
+  rtp_timestamp_helper_.StoreLatestTime(capture_time,
+                                        encoded_frame->rtp_timestamp);
   transport_sender_->InsertCodedVideoFrame(encoded_frame.get(), capture_time);
   UpdateFramesInFlight();
   InitializeTimers();
 }
 
 void VideoSender::IncomingRtcpPacket(scoped_ptr<Packet> packet) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_->IncomingRtcpPacket(&packet->front(), packet->size());
 }
 
 void VideoSender::ScheduleNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeDelta time_to_next = rtcp_->TimeToSendNextRtcpReport() -
                                  cast_environment_->Clock()->NowTicks();
 
   time_to_next = std::max(
       time_to_next, base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
 
   cast_environment_->PostDelayedTask(
       CastEnvironment::MAIN,
       FROM_HERE,
       base::Bind(&VideoSender::SendRtcpReport, weak_factory_.GetWeakPtr()),
       time_to_next);
 }
 
-void VideoSender::StoreStatistics(
-    const transport::RtcpSenderInfo& sender_info,
-    base::TimeTicks time_sent,
-    uint32 rtp_timestamp) {
-  rtp_stats_.Store(sender_info, time_sent, rtp_timestamp);
-}
-
 void VideoSender::SendRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-
-  rtp_stats_.UpdateInfo(cast_environment_->Clock()->NowTicks());
-  rtcp_->SendRtcpFromRtpSender(rtp_stats_.sender_info());
+  const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
+  uint32 now_as_rtp_timestamp = 0;
+  if (rtp_timestamp_helper_.GetCurrentTimeAsRtpTimestamp(
+          now, &now_as_rtp_timestamp)) {
+    rtcp_->SendRtcpFromRtpSender(now, now_as_rtp_timestamp);
+  }
   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 195 matching lines @@
 void VideoSender::UpdateBitrate(int new_bitrate) {
   new_bitrate /= current_bitrate_divider_;
   // Make sure we don't set the bitrate too insanely low.
   DCHECK_GT(new_bitrate, 1000);
   video_encoder_->SetBitRate(new_bitrate);
   current_requested_bitrate_ = new_bitrate;
 }
 
 }  // namespace cast
 }  // namespace media