Cast: Reshuffle files under media/cast

media/cast/receiver/cast_receiver_impl.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/cast_receiver_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/receiver/audio_decoder.h"
 #include "media/cast/receiver/video_decoder.h"
 
 namespace media {
 namespace cast {
 
 scoped_ptr<CastReceiver> CastReceiver::Create(
     scoped_refptr<CastEnvironment> cast_environment,
     const FrameReceiverConfig& audio_config,
     const FrameReceiverConfig& video_config,
-    transport::PacketSender* const packet_sender) {
+    PacketSender* const packet_sender) {
   return scoped_ptr<CastReceiver>(new CastReceiverImpl(
       cast_environment, audio_config, video_config, packet_sender));
 }
 
 CastReceiverImpl::CastReceiverImpl(
     scoped_refptr<CastEnvironment> cast_environment,
     const FrameReceiverConfig& audio_config,
     const FrameReceiverConfig& video_config,
-    transport::PacketSender* const packet_sender)
+    PacketSender* const packet_sender)
     : cast_environment_(cast_environment),
       pacer_(cast_environment->Clock(),
              cast_environment->Logging(),
              packet_sender,
              cast_environment->GetTaskRunner(CastEnvironment::MAIN)),
       audio_receiver_(cast_environment, audio_config, AUDIO_EVENT, &pacer_),
       video_receiver_(cast_environment, video_config, VIDEO_EVENT, &pacer_),
       ssrc_of_audio_sender_(audio_config.incoming_ssrc),
       ssrc_of_video_sender_(video_config.incoming_ssrc),
       num_audio_channels_(audio_config.channels),
@@ skipping 26 matching lines @@
     return;
   }
   cast_environment_->PostTask(
       CastEnvironment::MAIN,
       FROM_HERE,
       base::Bind(base::IgnoreResult(&FrameReceiver::ProcessPacket),
                  target,
                  base::Passed(&packet)));
 }
 
-transport::PacketReceiverCallback CastReceiverImpl::packet_receiver() {
+PacketReceiverCallback CastReceiverImpl::packet_receiver() {
   return base::Bind(&CastReceiverImpl::DispatchReceivedPacket,
                     // TODO(miu): This code structure is dangerous, since the
                     // callback could be stored and then invoked after
                     // destruction of |this|.
                     base::Unretained(this));
 }
 
 void CastReceiverImpl::RequestDecodedAudioFrame(
     const AudioFrameDecodedCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
@@ skipping 25 matching lines @@
 }
 
 void CastReceiverImpl::RequestEncodedVideoFrame(
     const ReceiveEncodedFrameCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   video_receiver_.RequestEncodedFrame(callback);
 }
 
 void CastReceiverImpl::DecodeEncodedAudioFrame(
     const AudioFrameDecodedCallback& callback,
-    scoped_ptr<transport::EncodedFrame> encoded_frame) {
+    scoped_ptr<EncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (!encoded_frame) {
     callback.Run(make_scoped_ptr<AudioBus>(NULL), base::TimeTicks(), false);
     return;
   }
 
   if (!audio_decoder_) {
     audio_decoder_.reset(new AudioDecoder(cast_environment_,
                                           num_audio_channels_,
                                           audio_sampling_rate_,
                                           audio_codec_));
   }
   const uint32 frame_id = encoded_frame->frame_id;
   const uint32 rtp_timestamp = encoded_frame->rtp_timestamp;
   const base::TimeTicks playout_time = encoded_frame->reference_time;
   audio_decoder_->DecodeFrame(
       encoded_frame.Pass(),
       base::Bind(&CastReceiverImpl::EmitDecodedAudioFrame,
                  cast_environment_,
                  callback,
                  frame_id,
                  rtp_timestamp,
                  playout_time));
 }
 
 void CastReceiverImpl::DecodeEncodedVideoFrame(
     const VideoFrameDecodedCallback& callback,
-    scoped_ptr<transport::EncodedFrame> encoded_frame) {
+    scoped_ptr<EncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (!encoded_frame) {
     callback.Run(
         make_scoped_refptr<VideoFrame>(NULL), base::TimeTicks(), false);
     return;
   }
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT2(
       "cast_perf_test", "PullEncodedVideoFrame",
@@ skipping 59 matching lines @@
     TRACE_EVENT_INSTANT1(
         "cast_perf_test", "FrameDecoded",
         TRACE_EVENT_SCOPE_THREAD,
         "rtp_timestamp", rtp_timestamp);
   }
   callback.Run(video_frame, playout_time, is_continuous);
 }
 
 }  // namespace cast
 }  // namespace media