Cast: move net->transport

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 67 matching lines @@
                                  extended_high_sequence_number,
                                  jitter);
   }
 
  private:
   RtpReceiver* rtp_receiver_;
 };
 
 VideoReceiver::VideoReceiver(scoped_refptr<CastEnvironment> cast_environment,
                              const VideoReceiverConfig& video_config,
-                             PacedPacketSender* const packet_sender)
+                             transport::PacedPacketSender* const packet_sender)
       : cast_environment_(cast_environment),
         codec_(video_config.codec),
         target_delay_delta_(
             base::TimeDelta::FromMilliseconds(video_config.rtp_max_delay_ms)),
         frame_delay_(base::TimeDelta::FromMilliseconds(
             1000 / video_config.max_frame_rate)),
         incoming_payload_callback_(new LocalRtpVideoData(this)),
         incoming_payload_feedback_(new LocalRtpVideoFeedback(this)),
         rtp_receiver_(cast_environment_->Clock(), NULL, &video_config,
                       incoming_payload_callback_.get()),
@@ skipping 234 matching lines @@
     // to wait for new packet(s).
   }
 }
 
 base::TimeTicks VideoReceiver::GetRenderTime(base::TimeTicks now,
                                              uint32 rtp_timestamp) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   // Senders time in ms when this frame was captured.
   // Note: the senders clock and our local clock might not be synced.
   base::TimeTicks rtp_timestamp_in_ticks;
+
   if (time_offset_.InMilliseconds() == 0) {
     if (!rtcp_->RtpTimestampInSenderTime(kVideoFrequency,
                                          incoming_rtp_timestamp_,
                                          &rtp_timestamp_in_ticks)) {
       // We have not received any RTCP to sync the stream play it out as soon as
       // possible.
       return now;
     }
     time_offset_ = time_incoming_packet_ - rtp_timestamp_in_ticks;
   } else if (time_incoming_packet_updated_) {
     if (rtcp_->RtpTimestampInSenderTime(kVideoFrequency,
                                         incoming_rtp_timestamp_,
                                         &rtp_timestamp_in_ticks)) {
       // Time to update the time_offset.
       base::TimeDelta time_offset =
           time_incoming_packet_ - rtp_timestamp_in_ticks;
       time_offset_ = ((kTimeOffsetFilter - 1) * time_offset_ + time_offset)
           / kTimeOffsetFilter;
     }
   }
   // Reset |time_incoming_packet_updated_| to enable a future measurement.
   time_incoming_packet_updated_ = false;
   if (!rtcp_->RtpTimestampInSenderTime(kVideoFrequency,
                                        rtp_timestamp,
                                        &rtp_timestamp_in_ticks)) {
     // This can fail if we have not received any RTCP packets in a long time.
     return now;
   }
   base::TimeTicks render_time =
-      (rtp_timestamp_in_ticks + time_offset_ + target_delay_delta_);
+      rtp_timestamp_in_ticks + time_offset_ + target_delay_delta_;
   if (last_render_time_ > render_time)
     render_time = last_render_time_;
   last_render_time_ = render_time;
   return render_time;
 }
 
 void VideoReceiver::IncomingPacket(const uint8* packet, size_t length,
                                    const base::Closure callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (Rtcp::IsRtcpPacket(packet, length)) {
@@ skipping 80 matching lines @@
 }
 
 void VideoReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_->SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media