Cast: Reshuffle files under media/cast

media/cast/receiver/frame_receiver.cc

 // Copyright 2014 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/receiver/frame_receiver.h"
 
 #include <algorithm>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_environment.h"
 
 namespace {
 const int kMinSchedulingDelayMs = 1;
 }  // namespace
 
 namespace media {
 namespace cast {
 
 FrameReceiver::FrameReceiver(
     const scoped_refptr<CastEnvironment>& cast_environment,
     const FrameReceiverConfig& config,
     EventMediaType event_media_type,
-    transport::PacedPacketSender* const packet_sender)
+    PacedPacketSender* const packet_sender)
     : cast_environment_(cast_environment),
       packet_parser_(config.incoming_ssrc, config.rtp_payload_type),
       stats_(cast_environment->Clock()),
       event_media_type_(event_media_type),
       event_subscriber_(kReceiverRtcpEventHistorySize, event_media_type),
       rtp_timebase_(config.frequency),
       target_playout_delay_(
           base::TimeDelta::FromMilliseconds(config.rtp_max_delay_ms)),
       expected_frame_duration_(
           base::TimeDelta::FromSeconds(1) / config.max_frame_rate),
@@ skipping 149 matching lines @@
   rtcp_.SendRtcpFromRtpReceiver(&cast_message, &rtcp_events);
 }
 
 void FrameReceiver::EmitAvailableEncodedFrames() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   while (!frame_request_queue_.empty()) {
     // Attempt to peek at the next completed frame from the |framer_|.
     // TODO(miu): We should only be peeking at the metadata, and not copying the
     // payload yet!  Or, at least, peek using a StringPiece instead of a copy.
-    scoped_ptr<transport::EncodedFrame> encoded_frame(
-        new transport::EncodedFrame());
+    scoped_ptr<EncodedFrame> encoded_frame(
+        new EncodedFrame());
     bool is_consecutively_next_frame = false;
     bool have_multiple_complete_frames = false;
     if (!framer_.GetEncodedFrame(encoded_frame.get(),
                                  &is_consecutively_next_frame,
                                  &have_multiple_complete_frames)) {
       VLOG(1) << "Wait for more packets to produce a completed frame.";
       return;  // ProcessParsedPacket() will invoke this method in the future.
     }
 
     const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
@@ skipping 109 matching lines @@
 }
 
 void FrameReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_.SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media