Revert of Cast:Adding cast_transport_config and cleaning up

media/cast/cast_sender_impl.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/cast_sender_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/video_frame.h"
@@ skipping 22 matching lines @@
   }
 
   virtual void InsertAudio(const AudioBus* audio_bus,
                            const base::TimeTicks& recorded_time,
                            const base::Closure& done_callback) OVERRIDE {
     cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
         base::Bind(&AudioSender::InsertAudio, audio_sender_,
             audio_bus, recorded_time, done_callback));
   }
 
-  virtual void InsertCodedAudioFrame(
-      const transport::EncodedAudioFrame* audio_frame,
-      const base::TimeTicks& recorded_time,
-      const base::Closure callback) OVERRIDE {
+  virtual void InsertCodedAudioFrame(const EncodedAudioFrame* audio_frame,
+                                     const base::TimeTicks& recorded_time,
+                                     const base::Closure callback) OVERRIDE {
     cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
         base::Bind(&AudioSender::InsertCodedAudioFrame, audio_sender_,
             audio_frame, recorded_time, callback));
   }
 
  protected:
   virtual ~LocalFrameInput() {}
 
  private:
   friend class base::RefCountedThreadSafe<LocalFrameInput>;
@@ skipping 22 matching lines @@
 //    e.g., audio encoding, over time.  The SSRC identifier is a
 //    randomly chosen value meant to be globally unique within a
 //    particular RTP session (see Section 8).  A participant need not
 //    use the same SSRC identifier for all the RTP sessions in a
 //    multimedia session; the binding of the SSRC identifiers is
 //    provided through RTCP (see Section 6.5.1).  If a participant
 //    generates multiple streams in one RTP session, for example from
 //    separate video cameras, each MUST be identified as a different
 //    SSRC.
 
-class LocalCastSenderPacketReceiver : public transport::PacketReceiver {
+class LocalCastSenderPacketReceiver : public PacketReceiver {
  public:
   LocalCastSenderPacketReceiver(scoped_refptr<CastEnvironment> cast_environment,
                                 base::WeakPtr<AudioSender> audio_sender,
                                 base::WeakPtr<VideoSender> video_sender,
                                 uint32 ssrc_of_audio_sender,
                                 uint32 ssrc_of_video_sender)
       : cast_environment_(cast_environment),
         audio_sender_(audio_sender),
         video_sender_(video_sender),
         ssrc_of_audio_sender_(ssrc_of_audio_sender),
@@ skipping 51 matching lines @@
   return new CastSenderImpl(cast_environment, audio_config, video_config,
                             gpu_factories, packet_sender);
 }
 
 CastSenderImpl::CastSenderImpl(
     scoped_refptr<CastEnvironment> cast_environment,
     const AudioSenderConfig& audio_config,
     const VideoSenderConfig& video_config,
     const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories,
     PacketSender* const packet_sender)
-    : pacer_(cast_environment->Clock(), packet_sender,
-          cast_environment->GetMessageTaskRunnerForThread(
-          CastEnvironment::TRANSPORT)),
+    : pacer_(cast_environment, packet_sender),
       audio_sender_(cast_environment, audio_config, &pacer_),
       video_sender_(cast_environment, video_config, gpu_factories, &pacer_),
       frame_input_(new LocalFrameInput(cast_environment,
                                        audio_sender_.AsWeakPtr(),
                                        video_sender_.AsWeakPtr())),
       packet_receiver_(new LocalCastSenderPacketReceiver(cast_environment,
           audio_sender_.AsWeakPtr(), video_sender_.AsWeakPtr(),
           audio_config.incoming_feedback_ssrc,
           video_config.incoming_feedback_ssrc)) {}
 
 CastSenderImpl::~CastSenderImpl() {}
 
 scoped_refptr<FrameInput> CastSenderImpl::frame_input() {
   return frame_input_;
 }
 
-scoped_refptr<transport::PacketReceiver> CastSenderImpl::packet_receiver() {
+scoped_refptr<PacketReceiver> CastSenderImpl::packet_receiver() {
   return packet_receiver_;
 }
 
 }  // namespace cast
 }  // namespace media