Cast: Simplify code path for RTCP sender report

media/cast/audio_sender/audio_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/audio_sender/audio_sender.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/audio_sender/audio_encoder.h"
@@ skipping 23 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LocalRtcpAudioSenderFeedback);
 };
 
 // TODO(mikhal): Reduce heap allocation when not needed.
 AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
                          const AudioSenderConfig& audio_config,
                          transport::CastTransportSender* const transport_sender)
     : cast_environment_(cast_environment),
       transport_sender_(transport_sender),
-      rtp_stats_(audio_config.frequency),
+      rtp_timestamp_helper_(audio_config.frequency),
       rtcp_feedback_(new LocalRtcpAudioSenderFeedback(this)),
       rtcp_(cast_environment,
             rtcp_feedback_.get(),
             transport_sender_,
             NULL,  // paced sender.
             NULL,
             audio_config.rtcp_mode,
             base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval),
             audio_config.rtp_config.ssrc,
             audio_config.incoming_feedback_ssrc,
@@ skipping 13 matching lines @@
   }
 
   media::cast::transport::CastTransportAudioConfig transport_config;
   transport_config.codec = audio_config.codec;
   transport_config.rtp.config = audio_config.rtp_config;
   transport_config.frequency = audio_config.frequency;
   transport_config.channels = audio_config.channels;
   transport_config.rtp.max_outstanding_frames =
       audio_config.rtp_config.max_delay_ms / 100 + 1;
   transport_sender_->InitializeAudio(transport_config);
-
-  transport_sender_->SubscribeAudioRtpStatsCallback(
-      base::Bind(&AudioSender::StoreStatistics, weak_factory_.GetWeakPtr()));
 }
 
 AudioSender::~AudioSender() {}
 
 void AudioSender::InitializeTimers() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (!timers_initialized_) {
     timers_initialized_ = true;
     ScheduleNextRtcpReport();
   }
 }
 
 void AudioSender::InsertAudio(scoped_ptr<AudioBus> audio_bus,
                               const base::TimeTicks& recorded_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(audio_encoder_.get()) << "Invalid internal state";
   audio_encoder_->InsertAudio(audio_bus.Pass(), recorded_time);
 }
 
 void AudioSender::SendEncodedAudioFrame(
     scoped_ptr<transport::EncodedAudioFrame> audio_frame,
     const base::TimeTicks& recorded_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
+  rtp_timestamp_helper_.StoreLatestTime(recorded_time,
+                                        audio_frame->rtp_timestamp);
   InitializeTimers();
   transport_sender_->InsertCodedAudioFrame(audio_frame.get(), recorded_time);
 }
 
 void AudioSender::ResendPackets(
     const MissingFramesAndPacketsMap& missing_frames_and_packets) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   transport_sender_->ResendPackets(true, missing_frames_and_packets);
 }
 
@@ skipping 10 matching lines @@
   time_to_next = std::max(
       time_to_next, base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
 
   cast_environment_->PostDelayedTask(
       CastEnvironment::MAIN,
       FROM_HERE,
       base::Bind(&AudioSender::SendRtcpReport, weak_factory_.GetWeakPtr()),
       time_to_next);
 }
 
-void AudioSender::StoreStatistics(
-    const transport::RtcpSenderInfo& sender_info,
-    base::TimeTicks time_sent,
-    uint32 rtp_timestamp) {
-  rtp_stats_.Store(sender_info, time_sent, rtp_timestamp);
-}
-
 void AudioSender::SendRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  // We don't send audio logging messages since all captured audio frames will
-  // be sent.
-  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();
 }
 
 }  // namespace cast
 }  // namespace media