Revert 243647 "Cast:Adding cast_transport_config and cleaning up"

> Cast:Adding cast_transport_config and cleaning up
> 
> BUG=327482
> 
> Review URL: https://codereview.chromium.org/109413004

TBR=mikhal@chromium.org

Review URL: https://codereview.chromium.org/129113003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@243648 0039d316-1c4b-4281-b951-d872f2087c98

80 files changed, 438 insertions, 593 deletions

diff --git a/chrome/renderer/media/cast_rtp_stream.cc b/chrome/renderer/media/cast_rtp_stream.cc
index 66ac92a..3f5f8d3 100644
--- a/chrome/renderer/media/cast_rtp_stream.cc
+++ b/chrome/renderer/media/cast_rtp_stream.cc
@@ -15,7 +15,6 @@
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_sender.h"
-#include "media/cast/transport/cast_transport_config.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 
 using media::cast::AudioSenderConfig;
@@ -80,9 +79,9 @@ bool ToAudioSenderConfig(const CastRtpParams& params,
   config->bitrate = payload_params.max_bitrate;
   config->aes_key = payload_params.aes_key;
   config->aes_iv_mask = payload_params.aes_iv_mask;
-  config->codec = media::cast::transport::kPcm16;
+  config->codec = media::cast::kPcm16;
   if (payload_params.codec_name == kCodecNameOpus)
-    config->codec = media::cast::transport::kOpus;
+    config->codec = media::cast::kOpus;
   else
     return false;
   return true;
@@ -104,7 +103,7 @@ bool ToVideoSenderConfig(const CastRtpParams& params,
   config->aes_key = payload_params.aes_key;
   config->aes_iv_mask = payload_params.aes_iv_mask;
   if (payload_params.codec_name == kCodecNameVp8)
-    config->codec = media::cast::transport::kVp8;
+    config->codec = media::cast::kVp8;
   else
     return false;
   return true;
diff --git a/chrome/renderer/media/cast_session_delegate.cc b/chrome/renderer/media/cast_session_delegate.cc
index 7ad7a68..63d5f4a 100644
--- a/chrome/renderer/media/cast_session_delegate.cc
+++ b/chrome/renderer/media/cast_session_delegate.cc
@@ -80,7 +80,6 @@ void CastSessionDelegate::StartSendingInternal() {
       NULL,
       video_encode_thread_.message_loop_proxy(),
       NULL,
-      base::MessageLoopProxy::current(),
       media::cast::GetDefaultCastLoggingConfig());
 
   // TODO(hclam): Implement VideoEncoderController to configure hardware
@@ -122,6 +121,5 @@ void CastSessionDelegate::ReceivePacket(const std::vector<char>& packet) {
   cast_sender_->packet_receiver()->ReceivedPacket(
       packet_copy,
       packet.size(),
-      base::Bind(&media::cast::transport::PacketReceiver::DeletePacket,
-                 packet_copy));
+      base::Bind(&media::cast::PacketReceiver::DeletePacket, packet_copy));
 }
diff --git a/media/cast/audio_receiver/audio_decoder.cc b/media/cast/audio_receiver/audio_decoder.cc
index b59f0f0..e9a8837 100644
--- a/media/cast/audio_receiver/audio_decoder.cc
+++ b/media/cast/audio_receiver/audio_decoder.cc
@@ -25,7 +25,7 @@ AudioDecoder::AudioDecoder(scoped_refptr<CastEnvironment> cast_environment,
 
   webrtc::CodecInst receive_codec;
   switch (audio_config.codec) {
-    case transport::kPcm16:
+    case kPcm16:
       receive_codec.pltype = audio_config.rtp_payload_type;
       strncpy(receive_codec.plname, "L16", 4);
       receive_codec.plfreq = audio_config.frequency;
@@ -33,7 +33,7 @@ AudioDecoder::AudioDecoder(scoped_refptr<CastEnvironment> cast_environment,
       receive_codec.channels = audio_config.channels;
       receive_codec.rate = -1;
       break;
-    case transport::kOpus:
+    case kOpus:
       receive_codec.pltype = audio_config.rtp_payload_type;
       strncpy(receive_codec.plname, "opus", 5);
       receive_codec.plfreq = audio_config.frequency;
@@ -41,7 +41,7 @@ AudioDecoder::AudioDecoder(scoped_refptr<CastEnvironment> cast_environment,
       receive_codec.channels = audio_config.channels;
       receive_codec.rate = -1;
       break;
-    case transport::kExternalAudio:
+    case kExternalAudio:
       NOTREACHED() << "Codec must be specified for audio decoder";
       break;
   }
@@ -109,7 +109,7 @@ void AudioDecoder::IncomingParsedRtpPacket(const uint8* payload_data,
                                            size_t payload_size,
                                            const RtpCastHeader& rtp_header) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  DCHECK_LE(payload_size, kMaxIpPacketSize);
+  DCHECK_LE(payload_size, kIpPacketSize);
   audio_decoder_->IncomingPacket(payload_data, static_cast<int32>(payload_size),
                                  rtp_header.webrtc);
   lock_.Acquire();
diff --git a/media/cast/audio_receiver/audio_decoder_unittest.cc b/media/cast/audio_receiver/audio_decoder_unittest.cc
index fd28e98..04df472 100644
--- a/media/cast/audio_receiver/audio_decoder_unittest.cc
+++ b/media/cast/audio_receiver/audio_decoder_unittest.cc
@@ -30,7 +30,7 @@ class AudioDecoderTest : public ::testing::Test {
     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(1234));
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
-        task_runner_, task_runner_, task_runner_, task_runner_, task_runner_,
+        task_runner_, task_runner_, task_runner_, task_runner_,
         GetDefaultCastLoggingConfig());
   }
   virtual ~AudioDecoderTest() {}
@@ -52,7 +52,7 @@ TEST_F(AudioDecoderTest, Pcm16MonoNoResampleOnePacket) {
   audio_config.rtp_payload_type = 127;
   audio_config.frequency = 16000;
   audio_config.channels = 1;
-  audio_config.codec = transport::kPcm16;
+  audio_config.codec = kPcm16;
   audio_config.use_external_decoder = false;
   Configure(audio_config);
 
@@ -101,7 +101,7 @@ TEST_F(AudioDecoderTest, Pcm16StereoNoResampleTwoPackets) {
   audio_config.rtp_payload_type = 127;
   audio_config.frequency = 16000;
   audio_config.channels = 2;
-  audio_config.codec = transport::kPcm16;
+  audio_config.codec = kPcm16;
   audio_config.use_external_decoder = false;
   Configure(audio_config);
 
@@ -171,7 +171,7 @@ TEST_F(AudioDecoderTest, Pcm16Resample) {
   audio_config.rtp_payload_type = 127;
   audio_config.frequency = 16000;
   audio_config.channels = 2;
-  audio_config.codec = transport::kPcm16;
+  audio_config.codec = kPcm16;
   audio_config.use_external_decoder = false;
   Configure(audio_config);
 
diff --git a/media/cast/audio_receiver/audio_receiver.cc b/media/cast/audio_receiver/audio_receiver.cc
index bb97498..c4eaaa7 100644
--- a/media/cast/audio_receiver/audio_receiver.cc
+++ b/media/cast/audio_receiver/audio_receiver.cc
@@ -291,8 +291,7 @@ void AudioReceiver::PlayoutTimeout() {
   }
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
-  scoped_ptr<transport::EncodedAudioFrame> encoded_frame(
-      new transport::EncodedAudioFrame());
+  scoped_ptr<EncodedAudioFrame> encoded_frame(new EncodedAudioFrame());
 
   if (!audio_buffer_->GetEncodedAudioFrame(encoded_frame.get(),
                                            &rtp_timestamp, &next_frame)) {
@@ -323,8 +322,7 @@ void AudioReceiver::GetEncodedAudioFrame(
 
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
-  scoped_ptr<transport::EncodedAudioFrame> encoded_frame(
-      new transport::EncodedAudioFrame());
+  scoped_ptr<EncodedAudioFrame> encoded_frame(new EncodedAudioFrame());
 
   if (!audio_buffer_->GetEncodedAudioFrame(encoded_frame.get(),
                                            &rtp_timestamp, &next_frame)) {
@@ -350,7 +348,7 @@ bool AudioReceiver::PostEncodedAudioFrame(
     const AudioFrameEncodedCallback& callback,
     uint32 rtp_timestamp,
     bool next_frame,
-    scoped_ptr<transport::EncodedAudioFrame>* encoded_frame) {
+    scoped_ptr<EncodedAudioFrame>* encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(audio_buffer_) << "Invalid function call in this configuration";
 
@@ -434,7 +432,7 @@ base::TimeTicks AudioReceiver::GetPlayoutTime(base::TimeTicks now,
 }
 
 bool AudioReceiver::DecryptAudioFrame(
-    scoped_ptr<transport::EncodedAudioFrame>* audio_frame) {
+    scoped_ptr<EncodedAudioFrame>* audio_frame) {
   DCHECK(decryptor_) << "Invalid state";
 
   if (!decryptor_->SetCounter(GetAesNonce((*audio_frame)->frame_id,
diff --git a/media/cast/audio_receiver/audio_receiver.h b/media/cast/audio_receiver/audio_receiver.h
index 43f5391..1cc14ee 100644
--- a/media/cast/audio_receiver/audio_receiver.h
+++ b/media/cast/audio_receiver/audio_receiver.h
@@ -79,11 +79,10 @@ class AudioReceiver : public base::NonThreadSafe,
   // Time to pull out the audio even though we are missing data.
   void PlayoutTimeout();
 
-  bool PostEncodedAudioFrame(
-      const AudioFrameEncodedCallback& callback,
-      uint32 rtp_timestamp,
-      bool next_frame,
-      scoped_ptr<transport::EncodedAudioFrame>* encoded_frame);
+  bool PostEncodedAudioFrame(const AudioFrameEncodedCallback& callback,
+                             uint32 rtp_timestamp,
+                             bool next_frame,
+                             scoped_ptr<EncodedAudioFrame>* encoded_frame);
 
   // Actual decoding implementation - should be called under the audio decoder
   // thread.
@@ -101,7 +100,7 @@ class AudioReceiver : public base::NonThreadSafe,
 
   // Decrypts the data within the |audio_frame| and replaces the data with the
   // decrypted string.
-  bool DecryptAudioFrame(scoped_ptr<transport::EncodedAudioFrame>* audio_frame);
+  bool DecryptAudioFrame(scoped_ptr<EncodedAudioFrame>* audio_frame);
 
   // Schedule the next RTCP report.
   void ScheduleNextRtcpReport();
@@ -118,7 +117,7 @@ class AudioReceiver : public base::NonThreadSafe,
   scoped_refptr<CastEnvironment> cast_environment_;
   base::WeakPtrFactory<AudioReceiver> weak_factory_;
 
-  const transport::AudioCodec codec_;
+  const AudioCodec codec_;
   const int frequency_;
   base::TimeDelta target_delay_delta_;
   scoped_ptr<Framer> audio_buffer_;
diff --git a/media/cast/audio_receiver/audio_receiver_unittest.cc b/media/cast/audio_receiver/audio_receiver_unittest.cc
index 02fe169..573287d 100644
--- a/media/cast/audio_receiver/audio_receiver_unittest.cc
+++ b/media/cast/audio_receiver/audio_receiver_unittest.cc
@@ -32,11 +32,10 @@ class TestAudioEncoderCallback :
     expected_playout_time_ = expected_playout_time;
   }
 
-  void DeliverEncodedAudioFrame(
-      scoped_ptr<transport::EncodedAudioFrame> audio_frame,
-      const base::TimeTicks& playout_time) {
+  void DeliverEncodedAudioFrame(scoped_ptr<EncodedAudioFrame> audio_frame,
+                                const base::TimeTicks& playout_time) {
     EXPECT_EQ(expected_frame_id_, audio_frame->frame_id);
-    EXPECT_EQ(transport::kPcm16, audio_frame->codec);
+    EXPECT_EQ(kPcm16, audio_frame->codec);
     EXPECT_EQ(expected_playout_time_, playout_time);
     num_called_++;
   }
@@ -72,7 +71,7 @@ class AudioReceiverTest : public ::testing::Test {
     audio_config_.rtp_payload_type = 127;
     audio_config_.frequency = 16000;
     audio_config_.channels = 1;
-    audio_config_.codec = transport::kPcm16;
+    audio_config_.codec = kPcm16;
     audio_config_.use_external_decoder = false;
     audio_config_.feedback_ssrc = 1234;
     testing_clock_.Advance(
@@ -80,7 +79,7 @@ class AudioReceiverTest : public ::testing::Test {
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
         task_runner_, task_runner_, task_runner_, task_runner_,
-        task_runner_, GetDefaultCastLoggingConfig());
+        GetDefaultCastLoggingConfig());
     test_audio_encoder_callback_ = new TestAudioEncoderCallback();
   }
 
@@ -95,7 +94,7 @@ class AudioReceiverTest : public ::testing::Test {
   static void DummyDeletePacket(const uint8* packet) {};
 
   virtual void SetUp() {
-    payload_.assign(kMaxIpPacketSize, 0);
+    payload_.assign(kIpPacketSize, 0);
     rtp_header_.is_key_frame = true;
     rtp_header_.frame_id = 0;
     rtp_header_.packet_id = 0;
@@ -122,7 +121,7 @@ TEST_F(AudioReceiverTest, GetOnePacketEncodedframe) {
 
   receiver_->IncomingParsedRtpPacket(payload_.data(),
       payload_.size(), rtp_header_);
-  transport::EncodedAudioFrame audio_frame;
+  EncodedAudioFrame audio_frame;
   base::TimeTicks playout_time;
   test_audio_encoder_callback_->SetExpectedResult(0, testing_clock_.NowTicks());
 
@@ -149,7 +148,7 @@ TEST_F(AudioReceiverTest, MultiplePendingGetCalls) {
   receiver_->IncomingParsedRtpPacket(payload_.data(), payload_.size(),
                                      rtp_header_);
 
-  transport::EncodedAudioFrame audio_frame;
+  EncodedAudioFrame audio_frame;
   base::TimeTicks playout_time;
   test_audio_encoder_callback_->SetExpectedResult(0, testing_clock_.NowTicks());
 
diff --git a/media/cast/audio_sender/audio_encoder.cc b/media/cast/audio_sender/audio_encoder.cc
index a642b77..c71329a 100644
--- a/media/cast/audio_sender/audio_encoder.cc
+++ b/media/cast/audio_sender/audio_encoder.cc
@@ -38,7 +38,7 @@ void LogAudioEncodedEvent(CastEnvironment* const cast_environment,
 class AudioEncoder::ImplBase {
  public:
   ImplBase(CastEnvironment* cast_environment,
-           transport::AudioCodec codec, int num_channels, int sampling_rate,
+           AudioCodec codec, int num_channels, int sampling_rate,
            const FrameEncodedCallback& callback)
       : cast_environment_(cast_environment),
         codec_(codec), num_channels_(num_channels),
@@ -50,7 +50,7 @@ class AudioEncoder::ImplBase {
     CHECK_GT(samples_per_10ms_, 0);
     CHECK_EQ(sampling_rate % 100, 0);
     CHECK_LE(samples_per_10ms_ * num_channels_,
-             transport::EncodedAudioFrame::kMaxNumberOfSamples);
+             EncodedAudioFrame::kMaxNumberOfSamples);
   }
 
   virtual ~ImplBase() {}
@@ -76,8 +76,7 @@ class AudioEncoder::ImplBase {
       }
 
       if (buffer_fill_end_ == samples_per_10ms_) {
-        scoped_ptr<transport::EncodedAudioFrame> audio_frame(
-            new transport::EncodedAudioFrame());
+        scoped_ptr<EncodedAudioFrame> audio_frame(new EncodedAudioFrame());
         audio_frame->codec = codec_;
         audio_frame->frame_id = frame_id_++;
         audio_frame->samples = samples_per_10ms_;
@@ -107,7 +106,7 @@ class AudioEncoder::ImplBase {
   virtual bool EncodeFromFilledBuffer(std::string* out) = 0;
 
   CastEnvironment* const cast_environment_;
-  const transport::AudioCodec codec_;
+  const AudioCodec codec_;
   const int num_channels_;
   const int samples_per_10ms_;
   const FrameEncodedCallback callback_;
@@ -130,8 +129,8 @@ class AudioEncoder::OpusImpl : public AudioEncoder::ImplBase {
   OpusImpl(CastEnvironment* cast_environment,
            int num_channels, int sampling_rate, int bitrate,
            const FrameEncodedCallback& callback)
-      : ImplBase(cast_environment, transport::kOpus, num_channels,
-                 sampling_rate, callback),
+      : ImplBase(cast_environment, kOpus, num_channels, sampling_rate,
+                 callback),
         encoder_memory_(new uint8[opus_encoder_get_size(num_channels)]),
         opus_encoder_(reinterpret_cast<OpusEncoder*>(encoder_memory_.get())),
         buffer_(new float[num_channels * samples_per_10ms_]) {
@@ -204,8 +203,8 @@ class AudioEncoder::Pcm16Impl : public AudioEncoder::ImplBase {
   Pcm16Impl(CastEnvironment* cast_environment,
             int num_channels, int sampling_rate,
             const FrameEncodedCallback& callback)
-      : ImplBase(cast_environment, transport::kPcm16, num_channels,
-                 sampling_rate, callback),
+      : ImplBase(cast_environment, kPcm16, num_channels, sampling_rate,
+                 callback),
         buffer_(new int16[num_channels * samples_per_10ms_]) {}
 
   virtual ~Pcm16Impl() {}
@@ -247,12 +246,12 @@ AudioEncoder::AudioEncoder(
   insert_thread_checker_.DetachFromThread();
 
   switch (audio_config.codec) {
-    case transport::kOpus:
+    case kOpus:
       impl_.reset(new OpusImpl(
           cast_environment, audio_config.channels, audio_config.frequency,
           audio_config.bitrate, frame_encoded_callback));
       break;
-    case transport::kPcm16:
+    case kPcm16:
       impl_.reset(new Pcm16Impl(
           cast_environment, audio_config.channels, audio_config.frequency,
           frame_encoded_callback));
diff --git a/media/cast/audio_sender/audio_encoder.h b/media/cast/audio_sender/audio_encoder.h
index 1dd5dc4..4a22d19 100644
--- a/media/cast/audio_sender/audio_encoder.h
+++ b/media/cast/audio_sender/audio_encoder.h
@@ -24,7 +24,7 @@ namespace cast {
 
 class AudioEncoder : public base::RefCountedThreadSafe<AudioEncoder> {
  public:
-  typedef base::Callback<void(scoped_ptr<transport::EncodedAudioFrame>,
+  typedef base::Callback<void(scoped_ptr<EncodedAudioFrame>,
                               const base::TimeTicks&)> FrameEncodedCallback;
 
   AudioEncoder(const scoped_refptr<CastEnvironment>& cast_environment,
diff --git a/media/cast/audio_sender/audio_encoder_unittest.cc b/media/cast/audio_sender/audio_encoder_unittest.cc
index a2e3191..d721f71 100644
--- a/media/cast/audio_sender/audio_encoder_unittest.cc
+++ b/media/cast/audio_sender/audio_encoder_unittest.cc
@@ -26,7 +26,7 @@ namespace {
 
 class TestEncodedAudioFrameReceiver {
  public:
-  explicit TestEncodedAudioFrameReceiver(transport::AudioCodec codec) :
+  explicit TestEncodedAudioFrameReceiver(AudioCodec codec) :
       codec_(codec), frames_received_(0) {}
   virtual ~TestEncodedAudioFrameReceiver() {}
 
@@ -42,7 +42,7 @@ class TestEncodedAudioFrameReceiver {
     upper_bound_ = t;
   }
 
-  void FrameEncoded(scoped_ptr<transport::EncodedAudioFrame> encoded_frame,
+  void FrameEncoded(scoped_ptr<EncodedAudioFrame> encoded_frame,
                     const base::TimeTicks& recorded_time) {
     EXPECT_EQ(codec_, encoded_frame->codec);
     EXPECT_EQ(static_cast<uint8>(frames_received_ & 0xff),
@@ -58,7 +58,7 @@ class TestEncodedAudioFrameReceiver {
   }
 
  private:
-  const transport::AudioCodec codec_;
+  const AudioCodec codec_;
   int frames_received_;
   base::TimeTicks lower_bound_;
   base::TimeTicks upper_bound_;
@@ -97,13 +97,13 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
   virtual void SetUp() {
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
-        task_runner_, task_runner_, task_runner_, task_runner_, task_runner_,
+        task_runner_, task_runner_, task_runner_, task_runner_,
         GetDefaultCastLoggingConfig());
   }
 
   virtual ~AudioEncoderTest() {}
 
-  void RunTestForCodec(transport::AudioCodec codec) {
+  void RunTestForCodec(AudioCodec codec) {
     const TestScenario& scenario = GetParam();
     SCOPED_TRACE(::testing::Message()
                  << "Durations: " << scenario.ToString());
@@ -137,7 +137,7 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
   }
 
  private:
-  void CreateObjectsForCodec(transport::AudioCodec codec) {
+  void CreateObjectsForCodec(AudioCodec codec) {
     AudioSenderConfig audio_config;
     audio_config.codec = codec;
     audio_config.use_external_encoder = false;
@@ -175,11 +175,11 @@ class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
 };
 
 TEST_P(AudioEncoderTest, EncodeOpus) {
-  RunTestForCodec(transport::kOpus);
+  RunTestForCodec(kOpus);
 }
 
 TEST_P(AudioEncoderTest, EncodePcm16) {
-  RunTestForCodec(transport::kPcm16);
+  RunTestForCodec(kPcm16);
 }
 
 static const int64 kOneCall_3Millis[] = { 3 };
diff --git a/media/cast/audio_sender/audio_sender.cc b/media/cast/audio_sender/audio_sender.cc
index 9a89706..ef32cd0 100644
--- a/media/cast/audio_sender/audio_sender.cc
+++ b/media/cast/audio_sender/audio_sender.cc
@@ -10,6 +10,7 @@
 #include "crypto/encryptor.h"
 #include "crypto/symmetric_key.h"
 #include "media/cast/audio_sender/audio_encoder.h"
+#include "media/cast/cast_environment.h"
 #include "media/cast/rtcp/rtcp.h"
 #include "media/cast/transport/rtp_sender/rtp_sender.h"
 
@@ -57,7 +58,7 @@ AudioSender::AudioSender(
     const AudioSenderConfig& audio_config,
     transport::PacedPacketSender* const paced_packet_sender)
       : cast_environment_(cast_environment),
-        rtp_sender_(cast_environment->Clock(), &audio_config, NULL,
+        rtp_sender_(cast_environment, &audio_config, NULL,
                     paced_packet_sender),
         rtcp_feedback_(new LocalRtcpAudioSenderFeedback(this)),
         rtp_audio_sender_statistics_(
@@ -118,10 +119,9 @@ void AudioSender::InsertAudio(const AudioBus* audio_bus,
   audio_encoder_->InsertAudio(audio_bus, recorded_time, done_callback);
 }
 
-void AudioSender::InsertCodedAudioFrame(
-    const transport::EncodedAudioFrame* audio_frame,
-    const base::TimeTicks& recorded_time,
-    const base::Closure callback) {
+void AudioSender::InsertCodedAudioFrame(const EncodedAudioFrame* audio_frame,
+                                        const base::TimeTicks& recorded_time,
+                                        const base::Closure callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(audio_encoder_.get() == NULL) << "Invalid internal state";
 
@@ -130,7 +130,7 @@ void AudioSender::InsertCodedAudioFrame(
       GetVideoRtpTimestamp(recorded_time), kFrameIdUnknown);
 
   if (encryptor_) {
-    transport::EncodedAudioFrame encrypted_frame;
+    EncodedAudioFrame encrypted_frame;
     if (!EncryptAudioFrame(*audio_frame, &encrypted_frame)) {
       // Logging already done.
       return;
@@ -143,12 +143,12 @@ void AudioSender::InsertCodedAudioFrame(
 }
 
 void AudioSender::SendEncodedAudioFrame(
-    scoped_ptr<transport::EncodedAudioFrame> audio_frame,
+    scoped_ptr<EncodedAudioFrame> audio_frame,
     const base::TimeTicks& recorded_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   InitializeTimers();
   if (encryptor_) {
-    transport::EncodedAudioFrame encrypted_frame;
+    EncodedAudioFrame encrypted_frame;
     if (!EncryptAudioFrame(*audio_frame.get(), &encrypted_frame)) {
       // Logging already done.
       return;
@@ -159,9 +159,8 @@ void AudioSender::SendEncodedAudioFrame(
   }
 }
 
-bool AudioSender::EncryptAudioFrame(
-    const transport::EncodedAudioFrame& audio_frame,
-    transport::EncodedAudioFrame* encrypted_frame) {
+bool AudioSender::EncryptAudioFrame(const EncodedAudioFrame& audio_frame,
+                                    EncodedAudioFrame* encrypted_frame) {
   DCHECK(encryptor_) << "Invalid state";
 
   if (!encryptor_->SetCounter(GetAesNonce(audio_frame.frame_id, iv_mask_))) {
diff --git a/media/cast/audio_sender/audio_sender.h b/media/cast/audio_sender/audio_sender.h
index 3219635..85f7305 100644
--- a/media/cast/audio_sender/audio_sender.h
+++ b/media/cast/audio_sender/audio_sender.h
@@ -13,6 +13,7 @@
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "media/cast/cast_config.h"
+#include "media/cast/cast_environment.h"
 #include "media/cast/rtcp/rtcp.h"
 #include "media/cast/transport/rtp_sender/rtp_sender.h"
 
@@ -55,19 +56,17 @@ class AudioSender : public base::NonThreadSafe,
   // The closure callback is called from the main cast thread as soon as
   // the cast sender is done with the frame; it does not mean that the encoded
   // frame has been sent out.
-  void InsertCodedAudioFrame(
-      const transport::EncodedAudioFrame* audio_frame,
-      const base::TimeTicks& recorded_time,
-      const base::Closure callback);
+  void InsertCodedAudioFrame(const EncodedAudioFrame* audio_frame,
+                             const base::TimeTicks& recorded_time,
+                             const base::Closure callback);
 
   // Only called from the main cast thread.
   void IncomingRtcpPacket(const uint8* packet, size_t length,
                           const base::Closure callback);
 
  protected:
-  void SendEncodedAudioFrame(
-      scoped_ptr<transport::EncodedAudioFrame> audio_frame,
-      const base::TimeTicks& recorded_time);
+  void SendEncodedAudioFrame(scoped_ptr<EncodedAudioFrame> audio_frame,
+                             const base::TimeTicks& recorded_time);
 
  private:
   friend class LocalRtcpAudioSenderFeedback;
@@ -77,8 +76,8 @@ class AudioSender : public base::NonThreadSafe,
 
   // Caller must allocate the destination |encrypted_frame|. The data member
   // will be resized to hold the encrypted size.
-  bool EncryptAudioFrame(const transport::EncodedAudioFrame& audio_frame,
-                         transport::EncodedAudioFrame* encrypted_frame);
+  bool EncryptAudioFrame(const EncodedAudioFrame& audio_frame,
+                         EncodedAudioFrame* encrypted_frame);
 
   void ScheduleNextRtcpReport();
   void SendRtcpReport();
diff --git a/media/cast/audio_sender/audio_sender_unittest.cc b/media/cast/audio_sender/audio_sender_unittest.cc
index 4197456..7796950 100644
--- a/media/cast/audio_sender/audio_sender_unittest.cc
+++ b/media/cast/audio_sender/audio_sender_unittest.cc
@@ -38,9 +38,9 @@ class AudioSenderTest : public ::testing::Test {
   virtual void SetUp() {
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
-        task_runner_, task_runner_, task_runner_, task_runner_, task_runner_,
+        task_runner_, task_runner_, task_runner_, task_runner_,
         GetDefaultCastLoggingConfig());
-    audio_config_.codec = transport::kOpus;
+    audio_config_.codec = kOpus;
     audio_config_.use_external_encoder = false;
     audio_config_.frequency = kDefaultAudioSamplingRate;
     audio_config_.channels = 2;
diff --git a/media/cast/cast_config.cc b/media/cast/cast_config.cc
index 27745bc..c2c4cd9 100644
--- a/media/cast/cast_config.cc
+++ b/media/cast/cast_config.cc
@@ -46,8 +46,19 @@ VideoReceiverConfig::VideoReceiverConfig()
       max_frame_rate(kDefaultMaxFrameRate),
       decoder_faster_than_max_frame_rate(true) {}
 
+EncodedVideoFrame::EncodedVideoFrame() {}
+EncodedVideoFrame::~EncodedVideoFrame() {}
+
+EncodedAudioFrame::EncodedAudioFrame() {}
+EncodedAudioFrame::~EncodedAudioFrame() {}
+
 PcmAudioFrame::PcmAudioFrame() {}
 PcmAudioFrame::~PcmAudioFrame() {}
 
+// static
+void PacketReceiver::DeletePacket(const uint8* packet) {
+  delete [] packet;
+}
+
 }  // namespace cast
 }  // namespace media
diff --git a/media/cast/cast_config.h b/media/cast/cast_config.h
index 5f952db..7a89d61 100644
--- a/media/cast/cast_config.h
+++ b/media/cast/cast_config.h
@@ -13,7 +13,6 @@
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/transport/cast_transport_config.h"
 
 namespace media {
 namespace cast {
@@ -23,6 +22,17 @@ enum RtcpMode {
   kRtcpReducedSize,  // Reduced-size RTCP mode is described by RFC 5506.
 };
 
+enum VideoCodec {
+  kVp8,
+  kH264,
+};
+
+enum AudioCodec {
+  kOpus,
+  kPcm16,
+  kExternalAudio,
+};
+
 struct AudioSenderConfig {
   AudioSenderConfig();
 
@@ -41,7 +51,7 @@ struct AudioSenderConfig {
   int frequency;
   int channels;
   int bitrate;  // Set to <= 0 for "auto variable bitrate" (libopus knows best).
-  transport::AudioCodec codec;
+  AudioCodec codec;
 
   std::string aes_key;  // Binary string of size kAesKeySize.
   std::string aes_iv_mask;  // Binary string of size kAesKeySize.
@@ -73,7 +83,7 @@ struct VideoSenderConfig {
   int min_qp;
   int max_frame_rate;
   int max_number_of_video_buffers_used;  // Max value depend on codec.
-  transport::VideoCodec codec;
+  VideoCodec codec;
   int number_of_cores;
 
   std::string aes_key;  // Binary string of size kAesKeySize.
@@ -97,7 +107,7 @@ struct AudioReceiverConfig {
   bool use_external_decoder;
   int frequency;
   int channels;
-  transport::AudioCodec codec;
+  AudioCodec codec;
 
   std::string aes_key;  // Binary string of size kAesKeySize.
   std::string aes_iv_mask;  // Binary string of size kAesKeySize.
@@ -123,12 +133,23 @@ struct VideoReceiverConfig {
   // Some HW decoders can not run faster than the frame rate, preventing it
   // from catching up after a glitch.
   bool decoder_faster_than_max_frame_rate;
-  transport::VideoCodec codec;
+  VideoCodec codec;
 
   std::string aes_key;  // Binary string of size kAesKeySize.
   std::string aes_iv_mask;  // Binary string of size kAesKeySize.
 };
 
+struct EncodedVideoFrame {
+  EncodedVideoFrame();
+  ~EncodedVideoFrame();
+
+  VideoCodec codec;
+  bool key_frame;
+  uint32 frame_id;
+  uint32 last_referenced_frame_id;
+  std::string data;
+};
+
 // DEPRECATED: Do not use in new code.  Please migrate existing code to use
 // media::AudioBus.
 struct PcmAudioFrame {
@@ -140,6 +161,19 @@ struct PcmAudioFrame {
   std::vector<int16> samples;
 };
 
+struct EncodedAudioFrame {
+  EncodedAudioFrame();
+  ~EncodedAudioFrame();
+
+  AudioCodec codec;
+  uint32 frame_id;  // Needed to release the frame.
+  int samples;  // Needed send side to advance the RTP timestamp.
+                // Not used receive side.
+  // Support for max sampling rate of 48KHz, 2 channels, 100 ms duration.
+  static const int kMaxNumberOfSamples = 48 * 2 * 100;
+  std::string data;
+};
+
 typedef std::vector<uint8> Packet;
 typedef std::vector<Packet> PacketList;
 
diff --git a/media/cast/cast_defines.h b/media/cast/cast_defines.h
index ec2651e..e74fccb 100644
--- a/media/cast/cast_defines.h
+++ b/media/cast/cast_defines.h
@@ -24,7 +24,7 @@ const uint32 kStartFrameId = GG_UINT32_C(0xffffffff);
 
 // Number of skipped frames threshold in fps (as configured) per period above.
 const int kSkippedFramesThreshold = 3;
-const size_t kMaxIpPacketSize = 1500;
+const size_t kIpPacketSize = 1500;
 const int kStartRttMs = 20;
 const int64 kCastMessageUpdateIntervalMs = 33;
 const int64 kNackRepeatIntervalMs = 30;
diff --git a/media/cast/cast_environment.cc b/media/cast/cast_environment.cc
index 6b084b1..eac8308 100644
--- a/media/cast/cast_environment.cc
+++ b/media/cast/cast_environment.cc
@@ -18,7 +18,6 @@ CastEnvironment::CastEnvironment(
     scoped_refptr<TaskRunner> audio_decode_thread_proxy,
     scoped_refptr<TaskRunner> video_encode_thread_proxy,
     scoped_refptr<TaskRunner> video_decode_thread_proxy,
-    scoped_refptr<TaskRunner> transport_thread_proxy,
     const CastLoggingConfig& config)
     : clock_(clock),
       main_thread_proxy_(main_thread_proxy),
@@ -26,7 +25,6 @@ CastEnvironment::CastEnvironment(
       audio_decode_thread_proxy_(audio_decode_thread_proxy),
       video_encode_thread_proxy_(video_encode_thread_proxy),
       video_decode_thread_proxy_(video_decode_thread_proxy),
-      transport_thread_proxy_(transport_thread_proxy),
       logging_(new LoggingImpl(main_thread_proxy, config)) {
   DCHECK(main_thread_proxy) << "Main thread required";
 }
@@ -65,8 +63,6 @@ scoped_refptr<TaskRunner> CastEnvironment::GetMessageTaskRunnerForThread(
       return video_encode_thread_proxy_;
     case CastEnvironment::VIDEO_DECODER:
       return video_decode_thread_proxy_;
-    case CastEnvironment::TRANSPORT:
-      return transport_thread_proxy_;
     default:
       NOTREACHED() << "Invalid Thread identifier";
       return NULL;
@@ -85,8 +81,6 @@ bool CastEnvironment::CurrentlyOn(ThreadId identifier) {
       return video_encode_thread_proxy_->RunsTasksOnCurrentThread();
     case CastEnvironment::VIDEO_DECODER:
       return video_decode_thread_proxy_->RunsTasksOnCurrentThread();
-    case CastEnvironment::TRANSPORT:
-      return transport_thread_proxy_->RunsTasksOnCurrentThread();
     default:
       NOTREACHED() << "Invalid thread identifier";
       return false;
diff --git a/media/cast/cast_environment.h b/media/cast/cast_environment.h
index 31e4f50..8a13573 100644
--- a/media/cast/cast_environment.h
+++ b/media/cast/cast_environment.h
@@ -34,8 +34,6 @@ class CastEnvironment : public base::RefCountedThreadSafe<CastEnvironment> {
     VIDEO_ENCODER,
     // The video decoder thread is where the video decode processing is done.
     VIDEO_DECODER,
-     // The transport thread is where the transport processing is done.
-    TRANSPORT,
   };
 
   CastEnvironment(base::TickClock* clock,
@@ -44,7 +42,6 @@ class CastEnvironment : public base::RefCountedThreadSafe<CastEnvironment> {
                   scoped_refptr<base::TaskRunner> audio_decode_thread_proxy,
                   scoped_refptr<base::TaskRunner> video_encode_thread_proxy,
                   scoped_refptr<base::TaskRunner> video_decode_thread_proxy,
-                  scoped_refptr<base::TaskRunner> transport_thread_proxy,
                   const CastLoggingConfig& config);
 
   // These are the same methods in message_loop.h, but are guaranteed to either
@@ -68,22 +65,21 @@ class CastEnvironment : public base::RefCountedThreadSafe<CastEnvironment> {
   // Logging is not thread safe. Should always be called from the main thread.
   LoggingImpl* Logging();
 
-  scoped_refptr<base::TaskRunner> GetMessageTaskRunnerForThread(
-      ThreadId identifier);
-
  protected:
   virtual ~CastEnvironment();
 
  private:
   friend class base::RefCountedThreadSafe<CastEnvironment>;
 
+  scoped_refptr<base::TaskRunner> GetMessageTaskRunnerForThread(
+      ThreadId identifier);
+
   base::TickClock* const clock_;  // Not owned by this class.
   scoped_refptr<base::TaskRunner> main_thread_proxy_;
   scoped_refptr<base::TaskRunner> audio_encode_thread_proxy_;
   scoped_refptr<base::TaskRunner> audio_decode_thread_proxy_;
   scoped_refptr<base::TaskRunner> video_encode_thread_proxy_;
   scoped_refptr<base::TaskRunner> video_decode_thread_proxy_;
-  scoped_refptr<base::TaskRunner> transport_thread_proxy_;
 
   scoped_ptr<LoggingImpl> logging_;
 
diff --git a/media/cast/cast_receiver.h b/media/cast/cast_receiver.h
index f4769a15..75e6f68 100644
--- a/media/cast/cast_receiver.h
+++ b/media/cast/cast_receiver.h
@@ -28,7 +28,7 @@ typedef base::Callback<void(scoped_ptr<PcmAudioFrame>, const base::TimeTicks&)>
     AudioFrameDecodedCallback;
 
 // Callback in which the encoded audio frame and play-out time will be returned.
-typedef base::Callback<void(scoped_ptr<transport::EncodedAudioFrame>,
+typedef base::Callback<void(scoped_ptr<EncodedAudioFrame>,
     const base::TimeTicks&)> AudioFrameEncodedCallback;
 
 // Callback in which the raw frame and render time will be returned once
@@ -38,7 +38,7 @@ typedef base::Callback<void(const scoped_refptr<media::VideoFrame>& video_frame,
     VideoFrameDecodedCallback;
 
 // Callback in which the encoded video frame and render time will be returned.
-typedef base::Callback<void(scoped_ptr<transport::EncodedVideoFrame>,
+typedef base::Callback<void(scoped_ptr<EncodedVideoFrame>,
     const base::TimeTicks&)> VideoFrameEncodedCallback;
 
 // This Class is thread safe.
@@ -74,7 +74,7 @@ class CastReceiver {
 
   // All received RTP and RTCP packets for the call should be inserted to this
   // PacketReceiver.
-  virtual scoped_refptr<transport::PacketReceiver> packet_receiver() = 0;
+  virtual scoped_refptr<PacketReceiver> packet_receiver() = 0;
 
   // Polling interface to get audio and video frames from the CastReceiver.
   virtual scoped_refptr<FrameReceiver> frame_receiver() = 0;
diff --git a/media/cast/cast_receiver_impl.cc b/media/cast/cast_receiver_impl.cc
index 4f4feb1..e2c004f 100644
--- a/media/cast/cast_receiver_impl.cc
+++ b/media/cast/cast_receiver_impl.cc
@@ -66,7 +66,7 @@ class LocalFrameReceiver : public FrameReceiver {
 };
 
 // The video and audio receivers should only be called from the main thread.
-class LocalPacketReceiver : public transport::PacketReceiver {
+class LocalPacketReceiver : public PacketReceiver {
  public:
   LocalPacketReceiver(scoped_refptr<CastEnvironment> cast_environment,
                       AudioReceiver* audio_receiver,
@@ -149,9 +149,7 @@ CastReceiverImpl::CastReceiverImpl(
     const AudioReceiverConfig& audio_config,
     const VideoReceiverConfig& video_config,
     PacketSender* const packet_sender)
-    : pacer_(cast_environment->Clock(), packet_sender,
-          cast_environment->GetMessageTaskRunnerForThread(
-          CastEnvironment::TRANSPORT)),
+    : pacer_(cast_environment, packet_sender),
       audio_receiver_(cast_environment, audio_config, &pacer_),
       video_receiver_(cast_environment, video_config, &pacer_),
       frame_receiver_(new LocalFrameReceiver(cast_environment,
@@ -165,7 +163,7 @@ CastReceiverImpl::CastReceiverImpl(
 
 CastReceiverImpl::~CastReceiverImpl() {}
 
-scoped_refptr<transport::PacketReceiver> CastReceiverImpl::packet_receiver() {
+scoped_refptr<PacketReceiver> CastReceiverImpl::packet_receiver() {
   return packet_receiver_;
 }
 
diff --git a/media/cast/cast_receiver_impl.h b/media/cast/cast_receiver_impl.h
index 31ba736..9e175e1 100644
--- a/media/cast/cast_receiver_impl.h
+++ b/media/cast/cast_receiver_impl.h
@@ -31,7 +31,7 @@ class CastReceiverImpl : public CastReceiver {
 
   // All received RTP and RTCP packets for the call should be inserted to this
   // PacketReceiver.
-  virtual scoped_refptr<transport::PacketReceiver> packet_receiver() OVERRIDE;
+  virtual scoped_refptr<PacketReceiver> packet_receiver() OVERRIDE;
 
   // Interface to get audio and video frames from the CastReceiver.
   virtual scoped_refptr<FrameReceiver> frame_receiver() OVERRIDE;
@@ -41,7 +41,7 @@ class CastReceiverImpl : public CastReceiver {
   AudioReceiver audio_receiver_;
   VideoReceiver video_receiver_;
   scoped_refptr<FrameReceiver> frame_receiver_;
-  scoped_refptr<transport::PacketReceiver> packet_receiver_;
+  scoped_refptr<PacketReceiver> packet_receiver_;
 };
 
 }  // namespace cast
diff --git a/media/cast/cast_sender.h b/media/cast/cast_sender.h
index 886086f..25cac54 100644
--- a/media/cast/cast_sender.h
+++ b/media/cast/cast_sender.h
@@ -51,10 +51,9 @@ class FrameInput : public base::RefCountedThreadSafe<FrameInput> {
   // The callback is called from the main cast thread as soon as
   // the cast sender is done with the frame; it does not mean that the encoded
   // frame has been sent out.
-  virtual void InsertCodedAudioFrame(
-      const transport::EncodedAudioFrame* audio_frame,
-      const base::TimeTicks& recorded_time,
-      const base::Closure callback) = 0;
+  virtual void InsertCodedAudioFrame(const EncodedAudioFrame* audio_frame,
+                                     const base::TimeTicks& recorded_time,
+                                     const base::Closure callback) = 0;
 
  protected:
   virtual ~FrameInput() {}
@@ -85,7 +84,7 @@ class CastSender {
 
   // All RTCP packets for the session should be inserted to this object.
   // Can be called from any thread.
-  virtual scoped_refptr<transport::PacketReceiver> packet_receiver() = 0;
+  virtual scoped_refptr<PacketReceiver> packet_receiver() = 0;
 };
 
 }  // namespace cast
diff --git a/media/cast/cast_sender_impl.cc b/media/cast/cast_sender_impl.cc
index da4d4dd..8ec91b3 100644
--- a/media/cast/cast_sender_impl.cc
+++ b/media/cast/cast_sender_impl.cc
@@ -40,10 +40,9 @@ class LocalFrameInput : public FrameInput {
             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));
@@ -86,7 +85,7 @@ class LocalFrameInput : public FrameInput {
 //    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,
@@ -158,9 +157,7 @@ CastSenderImpl::CastSenderImpl(
     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,
@@ -177,7 +174,7 @@ 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_;
 }
 
diff --git a/media/cast/cast_sender_impl.h b/media/cast/cast_sender_impl.h
index 8f9823b..0fe50e2 100644
--- a/media/cast/cast_sender_impl.h
+++ b/media/cast/cast_sender_impl.h
@@ -38,14 +38,14 @@ class CastSenderImpl : public CastSender {
   virtual ~CastSenderImpl();
 
   virtual scoped_refptr<FrameInput> frame_input() OVERRIDE;
-  virtual scoped_refptr<transport::PacketReceiver> packet_receiver() OVERRIDE;
+  virtual scoped_refptr<PacketReceiver> packet_receiver() OVERRIDE;
 
  private:
   transport::PacedSender pacer_;
   AudioSender audio_sender_;
   VideoSender video_sender_;
   scoped_refptr<FrameInput> frame_input_;
-  scoped_refptr<transport::PacketReceiver> packet_receiver_;
+  scoped_refptr<PacketReceiver> packet_receiver_;
 };
 
 }  // namespace cast
diff --git a/media/cast/framer/frame_buffer.cc b/media/cast/framer/frame_buffer.cc
index 92e8a87..8161298 100644
--- a/media/cast/framer/frame_buffer.cc
+++ b/media/cast/framer/frame_buffer.cc
@@ -61,9 +61,8 @@ bool FrameBuffer::Complete() const {
   return num_packets_received_ - 1 == max_packet_id_;
 }
 
-bool FrameBuffer::GetEncodedAudioFrame(
-    transport::EncodedAudioFrame* audio_frame,
-    uint32* rtp_timestamp) const {
+bool FrameBuffer::GetEncodedAudioFrame(EncodedAudioFrame* audio_frame,
+                                       uint32* rtp_timestamp) const {
   if (!Complete()) return false;
 
   *rtp_timestamp = rtp_timestamp_;
@@ -82,9 +81,8 @@ bool FrameBuffer::GetEncodedAudioFrame(
   return true;
 }
 
-bool FrameBuffer::GetEncodedVideoFrame(
-    transport::EncodedVideoFrame* video_frame,
-    uint32* rtp_timestamp) const {
+bool FrameBuffer::GetEncodedVideoFrame(EncodedVideoFrame* video_frame,
+                                       uint32* rtp_timestamp) const {
   if (!Complete()) return false;
 
   *rtp_timestamp = rtp_timestamp_;
diff --git a/media/cast/framer/frame_buffer.h b/media/cast/framer/frame_buffer.h
index 4ce7f47..b99f2b2 100644
--- a/media/cast/framer/frame_buffer.h
+++ b/media/cast/framer/frame_buffer.h
@@ -25,10 +25,10 @@ class FrameBuffer {
                     const RtpCastHeader& rtp_header);
   bool Complete() const;
 
-  bool GetEncodedAudioFrame(transport::EncodedAudioFrame* audio_frame,
+  bool GetEncodedAudioFrame(EncodedAudioFrame* audio_frame,
                             uint32* rtp_timestamp) const;
 
-  bool GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame,
+  bool GetEncodedVideoFrame(EncodedVideoFrame* video_frame,
                             uint32* rtp_timestamp) const;
 
   bool is_key_frame() const { return is_key_frame_; }
diff --git a/media/cast/framer/frame_buffer_unittest.cc b/media/cast/framer/frame_buffer_unittest.cc
index 96d3570..fb14da3 100644
--- a/media/cast/framer/frame_buffer_unittest.cc
+++ b/media/cast/framer/frame_buffer_unittest.cc
@@ -15,7 +15,7 @@ class FrameBufferTest : public ::testing::Test {
   virtual ~FrameBufferTest() {}
 
   virtual void SetUp() {
-    payload_.assign(kMaxIpPacketSize, 0);
+    payload_.assign(kIpPacketSize, 0);
 
     // Build a default one packet frame - populate webrtc header.
     rtp_header_.is_key_frame = false;
@@ -34,7 +34,7 @@ class FrameBufferTest : public ::testing::Test {
 TEST_F(FrameBufferTest, EmptyBuffer) {
   EXPECT_FALSE(buffer_.Complete());
   EXPECT_FALSE(buffer_.is_key_frame());
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   EXPECT_FALSE(buffer_.GetEncodedVideoFrame(&frame, &rtp_timestamp));
 }
@@ -43,7 +43,7 @@ TEST_F(FrameBufferTest, DefaultOnePacketFrame) {
   buffer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
   EXPECT_TRUE(buffer_.Complete());
   EXPECT_FALSE(buffer_.is_key_frame());
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   EXPECT_TRUE(buffer_.GetEncodedVideoFrame(&frame, &rtp_timestamp));
   EXPECT_EQ(payload_.size(), frame.data.size());
@@ -60,7 +60,7 @@ TEST_F(FrameBufferTest, MultiplePacketFrame) {
   ++rtp_header_.packet_id;
   EXPECT_TRUE(buffer_.Complete());
   EXPECT_TRUE(buffer_.is_key_frame());
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   EXPECT_TRUE(buffer_.GetEncodedVideoFrame(&frame, &rtp_timestamp));
   EXPECT_EQ(3 * payload_.size(), frame.data.size());
diff --git a/media/cast/framer/framer.cc b/media/cast/framer/framer.cc
index c0cc433..01787f3 100644
--- a/media/cast/framer/framer.cc
+++ b/media/cast/framer/framer.cc
@@ -65,7 +65,7 @@ bool Framer::InsertPacket(const uint8* payload_data,
 }
 
 // This does not release the frame.
-bool Framer::GetEncodedAudioFrame(transport::EncodedAudioFrame* audio_frame,
+bool Framer::GetEncodedAudioFrame(EncodedAudioFrame* audio_frame,
                                   uint32* rtp_timestamp,
                                   bool* next_frame) {
   uint32 frame_id;
@@ -88,7 +88,7 @@ bool Framer::GetEncodedAudioFrame(transport::EncodedAudioFrame* audio_frame,
 }
 
 // This does not release the frame.
-bool Framer::GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame,
+bool Framer::GetEncodedVideoFrame(EncodedVideoFrame* video_frame,
                                   uint32* rtp_timestamp,
                                   bool* next_frame) {
   uint32 frame_id;
diff --git a/media/cast/framer/framer.h b/media/cast/framer/framer.h
index 095fb84..f6732d1 100644
--- a/media/cast/framer/framer.h
+++ b/media/cast/framer/framer.h
@@ -44,11 +44,11 @@ class Framer {
   // frame.
   // Returns false if the frame does not exist or if the frame is not complete
   // within the given time frame.
-  bool GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame,
+  bool GetEncodedVideoFrame(EncodedVideoFrame* video_frame,
                             uint32* rtp_timestamp,
                             bool* next_frame);
 
-  bool GetEncodedAudioFrame(transport::EncodedAudioFrame* audio_frame,
+  bool GetEncodedAudioFrame(EncodedAudioFrame* audio_frame,
                             uint32* rtp_timestamp,
                             bool* next_frame);
 
diff --git a/media/cast/framer/framer_unittest.cc b/media/cast/framer/framer_unittest.cc
index a910d4e..6640767 100644
--- a/media/cast/framer/framer_unittest.cc
+++ b/media/cast/framer/framer_unittest.cc
@@ -27,7 +27,7 @@ class FramerTest : public ::testing::Test {
     rtp_header_.max_packet_id = 0;
     rtp_header_.is_reference = false;
     rtp_header_.reference_frame_id = 0;
-    payload_.assign(kMaxIpPacketSize, 0);
+    payload_.assign(kIpPacketSize, 0);
 
     EXPECT_CALL(mock_rtp_payload_feedback_,
                 CastFeedback(testing::_)).WillRepeatedly(testing::Return());
@@ -42,7 +42,7 @@ class FramerTest : public ::testing::Test {
 
 
 TEST_F(FramerTest, EmptyState) {
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
@@ -50,7 +50,7 @@ TEST_F(FramerTest, EmptyState) {
 }
 
 TEST_F(FramerTest, AlwaysStartWithKey) {
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool complete = false;
@@ -76,7 +76,7 @@ TEST_F(FramerTest, AlwaysStartWithKey) {
 }
 
 TEST_F(FramerTest, CompleteFrame) {
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool complete = false;
@@ -115,7 +115,7 @@ TEST_F(FramerTest, CompleteFrame) {
 }
 
 TEST_F(FramerTest, DuplicatePackets) {
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool complete = false;
@@ -207,7 +207,7 @@ TEST_F(FramerTest, DuplicatePackets) {
 }
 
 TEST_F(FramerTest, ContinuousSequence) {
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool complete = false;
@@ -237,7 +237,7 @@ TEST_F(FramerTest, ContinuousSequence) {
 
 TEST_F(FramerTest, Wrap) {
   // Insert key frame, frame_id = 255 (will jump to that)
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool duplicate = false;
@@ -266,7 +266,7 @@ TEST_F(FramerTest, Wrap) {
 }
 
 TEST_F(FramerTest, Reset) {
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool complete = false;
@@ -283,7 +283,7 @@ TEST_F(FramerTest, Reset) {
 }
 
 TEST_F(FramerTest, RequireKeyAfterReset) {
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool duplicate = false;
@@ -307,7 +307,7 @@ TEST_F(FramerTest, RequireKeyAfterReset) {
 }
 
 TEST_F(FramerTest, BasicNonLastReferenceId) {
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool duplicate = false;
@@ -335,7 +335,7 @@ TEST_F(FramerTest, BasicNonLastReferenceId) {
 
 TEST_F(FramerTest, InOrderReferenceFrameSelection) {
   // Create pattern: 0, 1, 4, 5.
-  transport::EncodedVideoFrame frame;
+  EncodedVideoFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool duplicate = false;
@@ -395,7 +395,7 @@ TEST_F(FramerTest, InOrderReferenceFrameSelection) {
 
 TEST_F(FramerTest, AudioWrap) {
   // All audio frames are marked as key frames.
-  transport::EncodedAudioFrame frame;
+  EncodedAudioFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool duplicate = false;
@@ -435,7 +435,7 @@ TEST_F(FramerTest, AudioWrap) {
 
 TEST_F(FramerTest, AudioWrapWithMissingFrame) {
   // All audio frames are marked as key frames.
-  transport::EncodedAudioFrame frame;
+  EncodedAudioFrame frame;
   uint32 rtp_timestamp;
   bool next_frame = false;
   bool duplicate = false;
diff --git a/media/cast/rtcp/rtcp.cc b/media/cast/rtcp/rtcp.cc
index 9224875..090a808 100644
--- a/media/cast/rtcp/rtcp.cc
+++ b/media/cast/rtcp/rtcp.cc
@@ -216,8 +216,7 @@ bool Rtcp::IsRtcpPacket(const uint8* packet, size_t length) {
   if (length < kMinLengthOfRtcp) return false;
 
   uint8 packet_type = packet[1];
-  if (packet_type >= transport::kPacketTypeLow &&
-      packet_type <= transport::kPacketTypeHigh) {
+  if (packet_type >= kPacketTypeLow && packet_type <= kPacketTypeHigh) {
     return true;
   }
   return false;
diff --git a/media/cast/rtcp/rtcp_receiver_unittest.cc b/media/cast/rtcp/rtcp_receiver_unittest.cc
index ab80469..a91d8f0 100644
--- a/media/cast/rtcp/rtcp_receiver_unittest.cc
+++ b/media/cast/rtcp/rtcp_receiver_unittest.cc
@@ -156,7 +156,7 @@ class RtcpReceiverTest : public ::testing::Test {
       : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
         cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
             task_runner_, task_runner_, task_runner_, task_runner_,
-            task_runner_, GetDefaultCastLoggingConfig())),
+            GetDefaultCastLoggingConfig())),
         rtcp_receiver_(new RtcpReceiver(cast_environment_,
                                         &mock_sender_feedback_,
                                         &mock_receiver_feedback_,
diff --git a/media/cast/rtcp/rtcp_sender.cc b/media/cast/rtcp/rtcp_sender.cc
index 3ab3f41..ab4455b 100644
--- a/media/cast/rtcp/rtcp_sender.cc
+++ b/media/cast/rtcp/rtcp_sender.cc
@@ -68,7 +68,7 @@ bool ScanRtcpReceiverLogMessage(
     size_t* rtcp_log_size) {
   if (receiver_log_message.empty()) return false;
 
-  size_t remaining_space = media::cast::kMaxIpPacketSize - start_size;
+  size_t remaining_space = media::cast::kIpPacketSize - start_size;
 
   // We must have space for at least one message
   DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize +
@@ -114,7 +114,7 @@ bool ScanRtcpReceiverLogMessage(
   *rtcp_log_size = kRtcpCastLogHeaderSize +
       *number_of_frames * kRtcpReceiverFrameLogSize +
       *total_number_of_messages_to_send * kRtcpReceiverEventLogSize;
-  DCHECK_GE(media::cast::kMaxIpPacketSize,
+  DCHECK_GE(media::cast::kIpPacketSize,
             start_size + *rtcp_log_size) << "Not enough buffer space";
 
   VLOG(1) << "number of frames " << *number_of_frames;
@@ -159,7 +159,7 @@ void RtcpSender::SendRtcpFromRtpReceiver(
     NOTIMPLEMENTED();
   }
   std::vector<uint8> packet;
-  packet.reserve(kMaxIpPacketSize);
+  packet.reserve(kIpPacketSize);
 
   if (packet_type_flags & kRtcpRr) {
     BuildRR(report_block, &packet);
@@ -190,15 +190,15 @@ void RtcpSender::SendRtcpFromRtpReceiver(
 void RtcpSender::BuildRR(const transport::RtcpReportBlock* report_block,
                          std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 32, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 32 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 32, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 32 > kIpPacketSize) return;
 
   uint16 number_of_rows = (report_block) ? 7 : 1;
   packet->resize(start_size + 8);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
   big_endian_writer.WriteU8(0x80 + (report_block ? 1 : 0));
-  big_endian_writer.WriteU8(transport::kPacketTypeReceiverReport);
+  big_endian_writer.WriteU8(kPacketTypeReceiverReport);
   big_endian_writer.WriteU16(number_of_rows);
   big_endian_writer.WriteU32(ssrc_);
 
@@ -210,8 +210,8 @@ void RtcpSender::BuildRR(const transport::RtcpReportBlock* report_block,
 void RtcpSender::AddReportBlocks(const transport::RtcpReportBlock& report_block,
                                  std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 24 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 24, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 24 > kIpPacketSize) return;
 
   packet->resize(start_size + 24);
 
@@ -237,9 +237,9 @@ void RtcpSender::AddReportBlocks(const transport::RtcpReportBlock& report_block,
 
 void RtcpSender::BuildSdec(std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size +  12 + c_name_.length(), kMaxIpPacketSize)
+  DCHECK_LT(start_size +  12 + c_name_.length(), kIpPacketSize)
       << "Not enough buffer space";
-  if (start_size + 12 > kMaxIpPacketSize) return;
+  if (start_size + 12 > kIpPacketSize) return;
 
   // SDES Source Description.
   packet->resize(start_size + 10);
@@ -247,7 +247,7 @@ void RtcpSender::BuildSdec(std::vector<uint8>* packet) const {
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 10);
   // We always need to add one SDES CNAME.
   big_endian_writer.WriteU8(0x80 + 1);
-  big_endian_writer.WriteU8(transport::kPacketTypeSdes);
+  big_endian_writer.WriteU8(kPacketTypeSdes);
 
   // Handle SDES length later on.
   uint32 sdes_length_position = static_cast<uint32>(start_size) + 3;
@@ -281,15 +281,15 @@ void RtcpSender::BuildSdec(std::vector<uint8>* packet) const {
 void RtcpSender::BuildPli(uint32 remote_ssrc,
                           std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 12, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 12 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 12, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 12 > kIpPacketSize) return;
 
   packet->resize(start_size + 12);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 12);
   uint8 FMT = 1;  // Picture loss indicator.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
   big_endian_writer.WriteU16(2);  // Used fixed length of 2.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(remote_ssrc);  // Add the remote SSRC.
@@ -307,15 +307,15 @@ void RtcpSender::BuildPli(uint32 remote_ssrc,
 void RtcpSender::BuildRpsi(const RtcpRpsiMessage* rpsi,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 24 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 24, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 24 > kIpPacketSize) return;
 
   packet->resize(start_size + 24);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24);
   uint8 FMT = 3;  // Reference Picture Selection Indication.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
 
   // Calculate length.
   uint32 bits_required = 7;
@@ -361,9 +361,9 @@ void RtcpSender::BuildRemb(const RtcpRembMessage* remb,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   size_t remb_size = 20 + 4 * remb->remb_ssrcs.size();
-  DCHECK_LT(start_size + remb_size, kMaxIpPacketSize)
+  DCHECK_LT(start_size + remb_size, kIpPacketSize)
       << "Not enough buffer space";
-  if (start_size + remb_size > kMaxIpPacketSize) return;
+  if (start_size + remb_size > kIpPacketSize) return;
 
   packet->resize(start_size + remb_size);
 
@@ -372,7 +372,7 @@ void RtcpSender::BuildRemb(const RtcpRembMessage* remb,
   // Add application layer feedback.
   uint8 FMT = 15;
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
   big_endian_writer.WriteU8(0);
   big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size() + 4));
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
@@ -404,8 +404,8 @@ void RtcpSender::BuildRemb(const RtcpRembMessage* remb,
 void RtcpSender::BuildNack(const RtcpNackMessage* nack,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 16, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 16 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 16, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 16 > kIpPacketSize) return;
 
   packet->resize(start_size + 16);
 
@@ -413,7 +413,7 @@ void RtcpSender::BuildNack(const RtcpNackMessage* nack,
 
   uint8 FMT = 1;
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(transport::kPacketTypeGenericRtpFeedback);
+  big_endian_writer.WriteU8(kPacketTypeGenericRtpFeedback);
   big_endian_writer.WriteU8(0);
   size_t nack_size_pos = start_size + 3;
   big_endian_writer.WriteU8(3);
@@ -424,7 +424,7 @@ void RtcpSender::BuildNack(const RtcpNackMessage* nack,
   // The nack list should be sorted and not contain duplicates.
   size_t number_of_nack_fields = 0;
   size_t max_number_of_nack_fields = std::min<size_t>(kRtcpMaxNackFields,
-      (kMaxIpPacketSize - packet->size()) / 4);
+      (kIpPacketSize - packet->size()) / 4);
 
   std::list<uint16>::const_iterator it = nack->nack_list.begin();
   while (it != nack->nack_list.end() &&
@@ -443,8 +443,8 @@ void RtcpSender::BuildNack(const RtcpNackMessage* nack,
     }
     // Write the sequence number and the bitmask to the packet.
     start_size = packet->size();
-    DCHECK_LT(start_size + 4, kMaxIpPacketSize) << "Not enough buffer space";
-    if (start_size + 4 > kMaxIpPacketSize) return;
+    DCHECK_LT(start_size + 4, kIpPacketSize) << "Not enough buffer space";
+    if (start_size + 4 > kIpPacketSize) return;
 
     packet->resize(start_size + 4);
     net::BigEndianWriter big_endian_nack_writer(&((*packet)[start_size]), 4);
@@ -458,14 +458,14 @@ void RtcpSender::BuildNack(const RtcpNackMessage* nack,
 
 void RtcpSender::BuildBye(std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 8, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 8 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 8, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 8 > kIpPacketSize) return;
 
   packet->resize(start_size + 8);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
   big_endian_writer.WriteU8(0x80 + 1);
-  big_endian_writer.WriteU8(transport::kPacketTypeBye);
+  big_endian_writer.WriteU8(kPacketTypeBye);
   big_endian_writer.WriteU16(1);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 }
@@ -473,15 +473,15 @@ void RtcpSender::BuildBye(std::vector<uint8>* packet) const {
 void RtcpSender::BuildRrtr(const RtcpReceiverReferenceTimeReport* rrtr,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 20 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 20, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 20 > kIpPacketSize) return;
 
   packet->resize(start_size + 20);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 20);
 
   big_endian_writer.WriteU8(0x80);
-  big_endian_writer.WriteU8(transport::kPacketTypeXr);
+  big_endian_writer.WriteU8(kPacketTypeXr);
   big_endian_writer.WriteU16(4);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(4);  // Add block type.
@@ -496,15 +496,15 @@ void RtcpSender::BuildRrtr(const RtcpReceiverReferenceTimeReport* rrtr,
 void RtcpSender::BuildCast(const RtcpCastMessage* cast,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 20 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 20, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 20 > kIpPacketSize) return;
 
   packet->resize(start_size + 20);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 20);
   uint8 FMT = 15;  // Application layer feedback.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
   big_endian_writer.WriteU8(0);
   size_t cast_size_pos = start_size + 3; // Save length position.
   big_endian_writer.WriteU8(4);
@@ -519,7 +519,7 @@ void RtcpSender::BuildCast(const RtcpCastMessage* cast,
 
   size_t number_of_loss_fields = 0;
   size_t max_number_of_loss_fields = std::min<size_t>(kRtcpMaxCastLossFields,
-      (kMaxIpPacketSize - packet->size()) / 4);
+      (kIpPacketSize - packet->size()) / 4);
 
   MissingFramesAndPacketsMap::const_iterator frame_it =
       cast->missing_frames_and_packets_.begin();
@@ -591,7 +591,7 @@ void RtcpSender::BuildReceiverLog(RtcpReceiverLogMessage* receiver_log_message,
   net::BigEndianWriter big_endian_writer(&((*packet)[packet_start_size]),
                                          rtcp_log_size);
   big_endian_writer.WriteU8(0x80 + kReceiverLogSubtype);
-  big_endian_writer.WriteU8(transport::kPacketTypeApplicationDefined);
+  big_endian_writer.WriteU8(kPacketTypeApplicationDefined);
   big_endian_writer.WriteU16(static_cast<uint16>(2 + 2 * number_of_frames +
                              total_number_of_messages_to_send));
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
diff --git a/media/cast/rtcp/rtcp_sender_unittest.cc b/media/cast/rtcp/rtcp_sender_unittest.cc
index 9a84196..e3104c9 100644
--- a/media/cast/rtcp/rtcp_sender_unittest.cc
+++ b/media/cast/rtcp/rtcp_sender_unittest.cc
@@ -53,7 +53,7 @@ class TestRtcpTransport : public transport::PacedPacketSender {
   int packet_count() const { return packet_count_; }
 
  private:
-  uint8 expected_packet_[kMaxIpPacketSize];
+  uint8 expected_packet_[kIpPacketSize];
   size_t expected_packet_length_;
   int packet_count_;
 };
@@ -64,7 +64,7 @@ class RtcpSenderTest : public ::testing::Test {
       : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
         cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
             task_runner_, task_runner_, task_runner_, task_runner_,
-            task_runner_, GetDefaultCastLoggingConfig())),
+            GetDefaultCastLoggingConfig())),
         rtcp_sender_(new RtcpSender(cast_environment_,
                                     &test_transport_,
                                     kSendingSsrc,
diff --git a/media/cast/rtcp/rtcp_unittest.cc b/media/cast/rtcp/rtcp_unittest.cc
index 29e9a88..5b3d934 100644
--- a/media/cast/rtcp/rtcp_unittest.cc
+++ b/media/cast/rtcp/rtcp_unittest.cc
@@ -104,7 +104,7 @@ class RtcpTest : public ::testing::Test {
       : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
         cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
             task_runner_, task_runner_, task_runner_, task_runner_,
-            task_runner_, GetDefaultCastLoggingConfig())),
+            GetDefaultCastLoggingConfig())),
         transport_(cast_environment_, &testing_clock_) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
diff --git a/media/cast/rtcp/rtcp_utility.cc b/media/cast/rtcp/rtcp_utility.cc
index adf2a93..c0d72df 100644
--- a/media/cast/rtcp/rtcp_utility.cc
+++ b/media/cast/rtcp/rtcp_utility.cc
@@ -5,7 +5,6 @@
 #include "media/cast/rtcp/rtcp_utility.h"
 
 #include "base/logging.h"
-#include "media/cast/transport/cast_transport_defines.h"
 #include "net/base/big_endian.h"
 
 namespace media {
@@ -110,44 +109,44 @@ void RtcpParser::IterateTopLevel() {
     if (rtcp_block_end_ > rtcp_data_end_) return;  // Bad block!
 
     switch (header.PT) {
-      case transport::kPacketTypeSenderReport:
+      case kPacketTypeSenderReport:
         // number of Report blocks
         number_of_blocks_ = header.IC;
         ParseSR();
         return;
-      case transport::kPacketTypeReceiverReport:
+      case kPacketTypeReceiverReport:
         // number of Report blocks
         number_of_blocks_ = header.IC;
         ParseRR();
         return;
-      case transport::kPacketTypeSdes:
+      case kPacketTypeSdes:
         // number of Sdes blocks
         number_of_blocks_ = header.IC;
         if (!ParseSdes()) {
           break;  // Nothing supported found, continue to next block!
         }
         return;
-      case transport::kPacketTypeBye:
+      case kPacketTypeBye:
         number_of_blocks_ = header.IC;
         if (!ParseBye()) {
           // Nothing supported found, continue to next block!
           break;
         }
         return;
-      case transport::kPacketTypeApplicationDefined:
+      case kPacketTypeApplicationDefined:
         if (!ParseApplicationDefined(header.IC)) {
           // Nothing supported found, continue to next block!
           break;
         }
         return;
-      case transport::kPacketTypeGenericRtpFeedback:  // Fall through!
-      case transport::kPacketTypePayloadSpecific:
+      case kPacketTypeGenericRtpFeedback:  // Fall through!
+      case kPacketTypePayloadSpecific:
         if (!ParseFeedBackCommon(header)) {
           // Nothing supported found, continue to next block!
           break;
         }
         return;
-      case transport::kPacketTypeXr:
+      case kPacketTypeXr:
         if (!ParseExtendedReport()) {
           break;  // Nothing supported found, continue to next block!
         }
@@ -617,9 +616,8 @@ bool RtcpParser::ParseCastSenderLogItem() {
 }
 
 bool RtcpParser::ParseFeedBackCommon(const RtcpCommonHeader& header) {
-  DCHECK((header.PT == transport::kPacketTypeGenericRtpFeedback) ||
-         (header.PT == transport::kPacketTypePayloadSpecific)) <<
-          "Invalid state";
+  DCHECK((header.PT == kPacketTypeGenericRtpFeedback) ||
+         (header.PT == kPacketTypePayloadSpecific)) << "Invalid state";
 
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
 
@@ -637,7 +635,7 @@ bool RtcpParser::ParseFeedBackCommon(const RtcpCommonHeader& header) {
 
   rtcp_data_ += 12;
 
-  if (header.PT == transport::kPacketTypeGenericRtpFeedback) {
+  if (header.PT == kPacketTypeGenericRtpFeedback) {
     // Transport layer feedback
     switch (header.IC) {
       case 1:
@@ -670,7 +668,7 @@ bool RtcpParser::ParseFeedBackCommon(const RtcpCommonHeader& header) {
     EndCurrentBlock();
     return false;
 
-  } else if (header.PT == transport::kPacketTypePayloadSpecific) {
+  } else if (header.PT == kPacketTypePayloadSpecific) {
     // Payload specific feedback
     switch (header.IC) {
       case 1:
diff --git a/media/cast/rtcp/rtcp_utility.h b/media/cast/rtcp/rtcp_utility.h
index be7c88f..5cf55d9 100644
--- a/media/cast/rtcp/rtcp_utility.h
+++ b/media/cast/rtcp/rtcp_utility.h
@@ -240,6 +240,20 @@ struct RtcpCommonHeader {
   uint16 length_in_octets;
 };
 
+enum RtcpPacketTypes {
+  kPacketTypeLow = 194,  // SMPTE time-code mapping.
+  kPacketTypeInterArrivalJitterReport = 195,
+  kPacketTypeSenderReport = 200,
+  kPacketTypeReceiverReport = 201,
+  kPacketTypeSdes = 202,
+  kPacketTypeBye = 203,
+  kPacketTypeApplicationDefined = 204,
+  kPacketTypeGenericRtpFeedback = 205,
+  kPacketTypePayloadSpecific = 206,
+  kPacketTypeXr = 207,
+  kPacketTypeHigh = 210,  // Port Mapping.
+};
+
 class RtcpParser {
  public:
   RtcpParser(const uint8* rtcp_data, size_t rtcp_length);
diff --git a/media/cast/rtcp/test_rtcp_packet_builder.cc b/media/cast/rtcp/test_rtcp_packet_builder.cc
index 79d585f..f4117f5 100644
--- a/media/cast/rtcp/test_rtcp_packet_builder.cc
+++ b/media/cast/rtcp/test_rtcp_packet_builder.cc
@@ -11,7 +11,7 @@ namespace cast {
 
 TestRtcpPacketBuilder::TestRtcpPacketBuilder()
     : ptr_of_length_(NULL),
-      big_endian_writer_(buffer_, kMaxIpPacketSize) {
+      big_endian_writer_(buffer_, kIpPacketSize) {
 }
 
 void TestRtcpPacketBuilder::AddSr(uint32 sender_ssrc,
diff --git a/media/cast/rtcp/test_rtcp_packet_builder.h b/media/cast/rtcp/test_rtcp_packet_builder.h
index 3a34dc0..9b63a37 100644
--- a/media/cast/rtcp/test_rtcp_packet_builder.h
+++ b/media/cast/rtcp/test_rtcp_packet_builder.h
@@ -86,7 +86,7 @@ class TestRtcpPacketBuilder {
                            uint16 event_timesamp_delta);
 
   const uint8* Packet();
-  int Length() { return kMaxIpPacketSize - big_endian_writer_.remaining(); }
+  int Length() { return kIpPacketSize - big_endian_writer_.remaining(); }
 
  private:
   void AddRtcpHeader(int payload, int format_or_count);
@@ -94,7 +94,7 @@ class TestRtcpPacketBuilder {
 
   // Where the length field of the current packet is.
   // Note: 0 is not a legal value, it is used for "uninitialized".
-  uint8 buffer_[kMaxIpPacketSize];
+  uint8 buffer_[kIpPacketSize];
   char* ptr_of_length_;
   net::BigEndianWriter big_endian_writer_;
 };
diff --git a/media/cast/rtp_receiver/rtp_parser/rtp_parser.h b/media/cast/rtp_receiver/rtp_parser/rtp_parser.h
index 2746aba..f0a16b9 100644
--- a/media/cast/rtp_receiver/rtp_parser/rtp_parser.h
+++ b/media/cast/rtp_receiver/rtp_parser/rtp_parser.h
@@ -22,8 +22,8 @@ struct RtpParserConfig {
 
   uint32 ssrc;
   int payload_type;
-  transport::AudioCodec audio_codec;
-  transport::VideoCodec video_codec;
+  AudioCodec audio_codec;
+  VideoCodec video_codec;
   int audio_channels;
 };
 
diff --git a/media/cast/test/encode_decode_test.cc b/media/cast/test/encode_decode_test.cc
index 3bc13b3..170e5f2 100644
--- a/media/cast/test/encode_decode_test.cc
+++ b/media/cast/test/encode_decode_test.cc
@@ -77,8 +77,7 @@ class EncodeDecodeTest : public ::testing::Test {
         // CastEnvironment will only be used by the vp8 decoder; Enable only the
         // video decoder and main threads.
         cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
-            NULL, NULL, NULL, task_runner_, NULL,
-            GetDefaultCastLoggingConfig())),
+            NULL, NULL, NULL, task_runner_, GetDefaultCastLoggingConfig())),
         test_callback_(new EncodeDecodeTestFrameCallback()) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
@@ -119,7 +118,7 @@ class EncodeDecodeTest : public ::testing::Test {
 };
 
 TEST_F(EncodeDecodeTest, BasicEncodeDecode) {
-  transport::EncodedVideoFrame encoded_frame;
+  EncodedVideoFrame encoded_frame;
   // Encode frame.
   encoder_->Encode(video_frame_, &encoded_frame);
   EXPECT_GT(encoded_frame.data.size(), GG_UINT64_C(0));
diff --git a/media/cast/test/end2end_unittest.cc b/media/cast/test/end2end_unittest.cc
index 432b69f..08b7f15 100644
--- a/media/cast/test/end2end_unittest.cc
+++ b/media/cast/test/end2end_unittest.cc
@@ -73,7 +73,7 @@ class LoopBackTransport : public PacketSender {
         cast_environment_(cast_environment) {
   }
 
-  void RegisterPacketReceiver(transport::PacketReceiver* packet_receiver) {
+  void RegisterPacketReceiver(PacketReceiver* packet_receiver) {
     DCHECK(packet_receiver);
     packet_receiver_ = packet_receiver;
   }
@@ -86,7 +86,7 @@ class LoopBackTransport : public PacketSender {
     uint8* packet_copy = new uint8[packet.size()];
     memcpy(packet_copy, packet.data(), packet.size());
     packet_receiver_->ReceivedPacket(packet_copy, packet.size(),
-        base::Bind(transport::PacketReceiver::DeletePacket, packet_copy));
+        base::Bind(PacketReceiver::DeletePacket, packet_copy));
     return true;
   }
 
@@ -108,7 +108,7 @@ class LoopBackTransport : public PacketSender {
         packet_copy[kCommonRtpHeaderLength] &= kCastReferenceFrameIdBitReset;
       }
       packet_receiver_->ReceivedPacket(packet_copy, packet.size(),
-          base::Bind(transport::PacketReceiver::DeletePacket, packet_copy));
+          base::Bind(PacketReceiver::DeletePacket, packet_copy));
     }
     return true;
   }
@@ -126,7 +126,7 @@ class LoopBackTransport : public PacketSender {
   }
 
  private:
-  transport::PacketReceiver* packet_receiver_;
+  PacketReceiver* packet_receiver_;
   bool send_packets_;
   bool drop_packets_belonging_to_odd_frames_;
   bool reset_reference_frame_id_;
@@ -203,9 +203,8 @@ class TestReceiverAudioCallback :
                 1);
   }
 
-  void CheckCodedPcmAudioFrame(
-      scoped_ptr<transport::EncodedAudioFrame> audio_frame,
-      const base::TimeTicks& playout_time) {
+  void CheckCodedPcmAudioFrame(scoped_ptr<EncodedAudioFrame> audio_frame,
+                               const base::TimeTicks& playout_time) {
     ++num_called_;
 
     EXPECT_FALSE(expected_frame_.empty());  // Test for bug in test code.
@@ -335,7 +334,7 @@ class End2EndTest : public ::testing::Test {
       : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
         cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
             task_runner_, task_runner_, task_runner_, task_runner_,
-            task_runner_, EnableCastLoggingConfig())),
+            EnableCastLoggingConfig())),
         start_time_(),
         sender_to_receiver_(cast_environment_),
         receiver_to_sender_(cast_environment_),
@@ -345,7 +344,7 @@ class End2EndTest : public ::testing::Test {
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
   }
 
-  void SetupConfig(transport::AudioCodec audio_codec,
+  void SetupConfig(AudioCodec audio_codec,
                    int audio_sampling_frequency,
                    // TODO(miu): 3rd arg is meaningless?!?
                    bool external_audio_decoder,
@@ -387,7 +386,7 @@ class End2EndTest : public ::testing::Test {
     video_sender_config_.max_frame_rate = 30;
     video_sender_config_.max_number_of_video_buffers_used =
         max_number_of_video_buffers_used;
-    video_sender_config_.codec = transport::kVp8;
+    video_sender_config_.codec = kVp8;
     video_sender_config_.number_of_cores = 1;
 
     video_receiver_config_.feedback_ssrc =
@@ -474,7 +473,7 @@ class End2EndTest : public ::testing::Test {
 // Audio and video test without packet loss using raw PCM 16 audio "codec";
 // This test is too slow. Disabled for now: crbug.com/329333.
 TEST_F(End2EndTest, DISABLED_LoopNoLossPcm16) {
-  SetupConfig(transport::kPcm16, 32000, false, 1);
+  SetupConfig(kPcm16, 32000, false, 1);
   Create();
 
   int video_start = 1;
@@ -547,7 +546,7 @@ TEST_F(End2EndTest, DISABLED_LoopNoLossPcm16) {
 // This tests our external decoder interface for Audio.
 // Audio test without packet loss using raw PCM 16 audio "codec";
 TEST_F(End2EndTest, MAYBE_LoopNoLossPcm16ExternalDecoder) {
-  SetupConfig(transport::kPcm16, 32000, true, 1);
+  SetupConfig(kPcm16, 32000, true, 1);
   Create();
 
   int i = 0;
@@ -580,7 +579,7 @@ TEST_F(End2EndTest, MAYBE_LoopNoLossPcm16ExternalDecoder) {
 #endif
 // This tests our Opus audio codec without video.
 TEST_F(End2EndTest, MAYBE_LoopNoLossOpus) {
-  SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 1);
+  SetupConfig(kOpus, kDefaultAudioSamplingRate, false, 1);
   Create();
 
   int i = 0;
@@ -624,7 +623,7 @@ TEST_F(End2EndTest, MAYBE_LoopNoLossOpus) {
 // TODO(miu): Test disabled because of non-determinism.
 // http://crbug.com/314233
 TEST_F(End2EndTest, DISABLED_StartSenderBeforeReceiver) {
-  SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 1);
+  SetupConfig(kOpus, kDefaultAudioSamplingRate, false, 1);
   Create();
 
   int video_start = 1;
@@ -703,7 +702,7 @@ TEST_F(End2EndTest, DISABLED_StartSenderBeforeReceiver) {
 
 // This tests a network glitch lasting for 10 video frames.
 TEST_F(End2EndTest, GlitchWith3Buffers) {
-  SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
+  SetupConfig(kOpus, kDefaultAudioSamplingRate, false, 3);
   video_sender_config_.rtp_max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
@@ -752,7 +751,7 @@ TEST_F(End2EndTest, GlitchWith3Buffers) {
 }
 
 TEST_F(End2EndTest, DropEveryOtherFrame3Buffers) {
-  SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
+  SetupConfig(kOpus, kDefaultAudioSamplingRate, false, 3);
   video_sender_config_.rtp_max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
@@ -787,7 +786,7 @@ TEST_F(End2EndTest, DropEveryOtherFrame3Buffers) {
 }
 
 TEST_F(End2EndTest, ResetReferenceFrameId) {
-  SetupConfig(transport::kOpus, kDefaultAudioSamplingRate, false, 3);
+  SetupConfig(kOpus, kDefaultAudioSamplingRate, false, 3);
   video_sender_config_.rtp_max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
@@ -814,7 +813,7 @@ TEST_F(End2EndTest, ResetReferenceFrameId) {
 }
 
 TEST_F(End2EndTest, CryptoVideo) {
-  SetupConfig(transport::kPcm16, 32000, false, 1);
+  SetupConfig(kPcm16, 32000, false, 1);
 
   video_sender_config_.aes_iv_mask =
       ConvertFromBase16String("1234567890abcdeffedcba0987654321");
@@ -854,7 +853,7 @@ TEST_F(End2EndTest, CryptoVideo) {
 #define MAYBE_CryptoAudio CryptoAudio
 #endif
 TEST_F(End2EndTest, MAYBE_CryptoAudio) {
-  SetupConfig(transport::kPcm16, 32000, false, 1);
+  SetupConfig(kPcm16, 32000, false, 1);
 
   audio_sender_config_.aes_iv_mask =
      ConvertFromBase16String("abcdeffedcba12345678900987654321");
@@ -909,7 +908,7 @@ TEST_F(End2EndTest, MAYBE_CryptoAudio) {
 // Video test without packet loss; This test is targeted at testing the logging
 // aspects of the end2end, but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, VideoLogging) {
-  SetupConfig(transport::kPcm16, 32000, false, 1);
+  SetupConfig(kPcm16, 32000, false, 1);
   Create();
 
   int video_start = 1;
@@ -967,9 +966,13 @@ TEST_F(End2EndTest, VideoLogging) {
   // Choose a packet, and verify that all events were logged.
   event_log = (++(packet_it->second.packet_map.begin()))->second.type;
   EXPECT_TRUE((std::find(event_log.begin(), event_log.end(),
+               kPacketSentToPacer)) != event_log.end());
+  EXPECT_TRUE((std::find(event_log.begin(), event_log.end(),
+               kPacketSentToNetwork)) != event_log.end());
+  EXPECT_TRUE((std::find(event_log.begin(), event_log.end(),
                kPacketReceived)) != event_log.end());
   // Verify that there were no other events logged with respect to this frame.
-  EXPECT_EQ(1u, event_log.size());
+  EXPECT_EQ(3u, event_log.size());
 }
 
 // TODO(mikhal): Crashes on the bots. Re-enable. http://crbug.com/329563
@@ -981,7 +984,7 @@ TEST_F(End2EndTest, VideoLogging) {
 // Audio test without packet loss; This test is targeted at testing the logging
 // aspects of the end2end, but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, MAYBE_AudioLogging) {
-  SetupConfig(transport::kPcm16, 32000, false, 1);
+  SetupConfig(kPcm16, 32000, false, 1);
   Create();
 
   int audio_diff = kFrameTimerMs;
diff --git a/media/cast/test/receiver.cc b/media/cast/test/receiver.cc
index dafda4e..0731c4f 100644
--- a/media/cast/test/receiver.cc
+++ b/media/cast/test/receiver.cc
@@ -112,7 +112,7 @@ AudioReceiverConfig GetAudioReceiverConfig() {
   audio_config.use_external_decoder = false;
   audio_config.frequency = 48000;
   audio_config.channels = 2;
-  audio_config.codec = transport::kOpus;
+  audio_config.codec = kOpus;
   return audio_config;
 }
 
@@ -133,7 +133,7 @@ VideoReceiverConfig GetVideoReceiverConfig() {
   video_config.use_external_decoder = false;
 
   VLOG(1) << "Using VP8";
-  video_config.codec = transport::kVp8;
+  video_config.codec = kVp8;
   return video_config;
 }
 
@@ -232,7 +232,6 @@ int main(int argc, char** argv) {
                                    audio_thread.message_loop_proxy(),
                                    NULL,
                                    video_thread.message_loop_proxy(),
-                                   main_thread.message_loop_proxy(),
                                    media::cast::GetDefaultCastLoggingConfig()));
 
   media::cast::AudioReceiverConfig audio_config =
@@ -250,7 +249,7 @@ int main(int argc, char** argv) {
       video_config,
       transport->packet_sender()));
 
-  media::cast::transport::PacketReceiver* packet_receiver =
+  media::cast::PacketReceiver* packet_receiver =
       cast_receiver->packet_receiver();
 
   int send_to_port, receive_port;
diff --git a/media/cast/test/sender.cc b/media/cast/test/sender.cc
index 5cd93e4..2e2e7b6 100644
--- a/media/cast/test/sender.cc
+++ b/media/cast/test/sender.cc
@@ -128,7 +128,7 @@ AudioSenderConfig GetAudioSenderConfig() {
   audio_config.frequency = kAudioSamplingFrequency;
   audio_config.channels = kAudioChannels;
   audio_config.bitrate = 64000;
-  audio_config.codec = transport::kOpus;
+  audio_config.codec = kOpus;
   return audio_config;
 }
 
@@ -178,7 +178,7 @@ VideoSenderConfig GetVideoSenderConfig() {
   video_config.min_qp = 4;
   video_config.max_qp = 40;
   video_config.max_frame_rate = 30;
-  video_config.codec = transport::kVp8;
+  video_config.codec = kVp8;
   video_config.max_number_of_video_buffers_used = 1;
   video_config.number_of_cores = 1;
   return video_config;
@@ -315,7 +315,6 @@ int main(int argc, char** argv) {
       NULL,
       video_thread.message_loop_proxy(),
       NULL,
-      main_thread.message_loop_proxy(),
       media::cast::GetDefaultCastLoggingConfig()));
 
   media::cast::AudioSenderConfig audio_config =
@@ -333,8 +332,7 @@ int main(int argc, char** argv) {
       NULL,  // VideoEncoderController.
       transport->packet_sender()));
 
-  media::cast::transport::PacketReceiver* packet_receiver =
-      cast_sender->packet_receiver();
+  media::cast::PacketReceiver* packet_receiver = cast_sender->packet_receiver();
 
   int send_to_port, receive_port;
   media::cast::GetPorts(&send_to_port, &receive_port);
diff --git a/media/cast/transport/cast_transport.gyp b/media/cast/transport/cast_transport.gyp
index 1183872..d486761 100644
--- a/media/cast/transport/cast_transport.gyp
+++ b/media/cast/transport/cast_transport.gyp
@@ -19,8 +19,6 @@
         '<(DEPTH)/net/net.gyp:net',
       ],
       'sources': [
-        'cast_transport_config.cc',
-        'cast_transport_config.h', 
         'cast_transport_defines.h', 
         'cast_transport_sender.h',
         'pacing/paced_sender.cc',
diff --git a/media/cast/transport/cast_transport_config.cc b/media/cast/transport/cast_transport_config.cc
deleted file mode 100644
index d38b2d3..0000000
--- a/media/cast/transport/cast_transport_config.cc
+++ /dev/null
@@ -1,41 +0,0 @@
-// 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/transport/cast_transport_config.h"
-
-namespace media {
-namespace cast {
-namespace transport {
-
-namespace {
-  const int kDefaultRtpHistoryMs = 1000;
-  const int kDefaultRtpMaxDelayMs = 100;
-}  // namespace
-
-CastTransportConfig::CastTransportConfig()
-    : sender_ssrc(0),
-      rtp_history_ms(kDefaultRtpHistoryMs),
-      rtp_max_delay_ms(kDefaultRtpMaxDelayMs),
-      rtp_payload_type(0),
-      frequency(0),
-      channels(0),
-      aes_key (""),
-      aes_iv_mask(0) {}
-
-CastTransportConfig::~CastTransportConfig() {}
-
-EncodedVideoFrame::EncodedVideoFrame() {}
-EncodedVideoFrame::~EncodedVideoFrame() {}
-
-EncodedAudioFrame::EncodedAudioFrame() {}
-EncodedAudioFrame::~EncodedAudioFrame() {}
-
-// static
-void PacketReceiver::DeletePacket(const uint8* packet) {
-  delete [] packet;
-}
-
-}  // namespace transport
-}  // namespace cast
-}  // namespace media
diff --git a/media/cast/transport/cast_transport_config.h b/media/cast/transport/cast_transport_config.h
deleted file mode 100644
index fa1d214..0000000
--- a/media/cast/transport/cast_transport_config.h
+++ /dev/null
@@ -1,101 +0,0 @@
- // 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.
-
-#ifndef MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_CONFIG_H_
-#define MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_CONFIG_H_
-
-#include <string>
-#include <vector>
-
-#include "base/basictypes.h"
-#include "base/callback.h"
-#include "base/memory/ref_counted.h"
-
-namespace media {
-namespace cast {
-namespace transport {
-
-enum RtcpMode {
-  kRtcpCompound,  // Compound RTCP mode is described by RFC 4585.
-  kRtcpReducedSize,  // Reduced-size RTCP mode is described by RFC 5506.
-};
-
-enum VideoCodec {
-  kVp8,
-  kH264,
-};
-
-enum AudioCodec {
-  kOpus,
-  kPcm16,
-  kExternalAudio,
-};
-
-struct CastTransportConfig {
-  CastTransportConfig();
-  ~CastTransportConfig();
-  uint32 sender_ssrc;
-
-  VideoCodec video_codec;
-  AudioCodec audio_codec;
-
-  int rtp_history_ms;
-  int rtp_max_delay_ms;
-  int rtp_payload_type;
-
-  int frequency;
-  int channels;
-
-  std::string aes_key;  // Binary string of size kAesKeySize.
-  std::string aes_iv_mask;  // Binary string of size kAesBlockSize.
-};
-
-struct EncodedVideoFrame {
-  EncodedVideoFrame();
-  ~EncodedVideoFrame();
-
-  VideoCodec codec;
-  bool key_frame;
-  uint32 frame_id;
-  uint32 last_referenced_frame_id;
-  std::string data;
-};
-
-struct EncodedAudioFrame {
-  EncodedAudioFrame();
-  ~EncodedAudioFrame();
-
-  AudioCodec codec;
-  uint32 frame_id;  // Needed to release the frame.
-  int samples;  // Needed send side to advance the RTP timestamp.
-                // Not used receive side.
-  // Support for max sampling rate of 48KHz, 2 channels, 100 ms duration.
-  static const int kMaxNumberOfSamples = 48 * 2 * 100;
-  std::string data;
-};
-
-typedef std::vector<uint8> Packet;
-typedef std::vector<Packet> PacketList;
-
-class PacketReceiver : public base::RefCountedThreadSafe<PacketReceiver> {
- public:
-  // All packets received from the network should be delivered via this
-  // function.
-  virtual void ReceivedPacket(const uint8* packet, size_t length,
-                              const base::Closure callback) = 0;
-
-  static void DeletePacket(const uint8* packet);
-
- protected:
-  virtual ~PacketReceiver() {}
-
- private:
-  friend class base::RefCountedThreadSafe<PacketReceiver>;
-};
-
-}  // namespace transport
-}  // namespace cast
-}  // namespace media
-
-#endif // MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_CONFIG_H_
diff --git a/media/cast/transport/cast_transport_defines.h b/media/cast/transport/cast_transport_defines.h
index 600fc3d..611981c 100644
--- a/media/cast/transport/cast_transport_defines.h
+++ b/media/cast/transport/cast_transport_defines.h
@@ -6,46 +6,14 @@
 #define MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_DEFINES_H_
 
 #include <list>
-#include <map>
-#include <set>
-
 #include "base/basictypes.h"
-#include "base/time/time.h"
 
 namespace media {
 namespace cast {
 namespace transport {
 
-enum CastTransportStatus {
-  UNINITIALIZED,
-  INITIALIZED,
-  INVALID_CRYPTO_CONFIG,
-  SOCKET_ERROR,
-  // TODO(mikhal): Add.
-};
-
-const size_t kMaxIpPacketSize = 1500;
-// Each uint16 represents one packet id within a cast frame.
-typedef std::set<uint16> PacketIdSet;
-// Each uint8 represents one cast frame.
-typedef std::map<uint8, PacketIdSet> MissingFramesAndPacketsMap;
-
 // Rtcp defines.
 
-enum RtcpPacketTypes {
-  kPacketTypeLow = 194,  // SMPTE time-code mapping.
-  kPacketTypeInterArrivalJitterReport = 195,
-  kPacketTypeSenderReport = 200,
-  kPacketTypeReceiverReport = 201,
-  kPacketTypeSdes = 202,
-  kPacketTypeBye = 203,
-  kPacketTypeApplicationDefined = 204,
-  kPacketTypeGenericRtpFeedback = 205,
-  kPacketTypePayloadSpecific = 206,
-  kPacketTypeXr = 207,
-  kPacketTypeHigh = 210,  // Port Mapping.
-};
-
 // Log messages form sender to receiver.
 enum RtcpSenderFrameStatus {
   kRtcpSenderFrameStatusUnknown = 0,
diff --git a/media/cast/transport/cast_transport_sender.h b/media/cast/transport/cast_transport_sender.h
index 55fb71d..5cfb40d 100644
--- a/media/cast/transport/cast_transport_sender.h
+++ b/media/cast/transport/cast_transport_sender.h
@@ -1,10 +1,10 @@
 // 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.
-
-// This is the main interface for the cast transport sender. The cast sender
-// handles the cast pipeline from encoded frames (both audio and video), to
-// encryption, packetization and transport.
+//
+// This is the main interface for the cast net sender. The cast sender handles
+// the cast pipeline from encoded frames (both audio and video), to encryption,
+// packetization and transport.
 // All configurations are done at creation.
 
 #ifndef MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_SENDER_H_
@@ -13,7 +13,7 @@
 #include "base/basictypes.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/tick_clock.h"
-#include "media/cast/transport/cast_transport_defines.h"
+#include "media/cast/net/cast_transport_defines.h"
 
 namespace media {
 class AudioBus;
@@ -24,53 +24,46 @@ namespace media {
 namespace cast {
 namespace transport {
 
-typedef base::Callback<void(CastTransportStatus status)>
-    CastTransportStatusCallback;
+class CastNetNotification {
+  public:
+    enum CastNetStatus {
+      UNINITIALIZED,
+      INITIALIZED,
+      INVALID_CRYPTO_CONFIG,
+      SOCKET_ERROR,
+      // TODO(mikhal): Add.
+    };
+
+ virtual void NotifyStatusChange(CastNetStatus result) = 0;
+ virtual ~CastNetNotification() {}
+};
 
 // This Class is not thread safe.
-// The application should only trigger this class from the transport thread.
-class CastTransportSender : public base::NonThreadSafe {
+// The application should only trigger this class from one thread.
+class CastNetSender : public base::NonThreadSafe {
  public:
-  static CastTransportSender* CreateCastNetSender(
+  static CastNetSender* CreateCastNetSender(
       base::TickClock* clock,
-      const CastTransportConfig& config,
-      const CastTransportStatusCallback& status_callback,
-      scoped_refptr<base::TaskRunner> transport_task_runner);
-
-  virtual ~CastTransportSender() {}
+      const CastNetConfig& config,
+      CastNetNotification* const notifier,
+      scoped_refptr<PacketReceiver> packet_receiver);
 
-  // Sets the Cast packet receiver. Should be called after creation on the
-  // Cast sender.
-  virtual void SetPacketReceiver(
-      scoped_refptr<PacketReceiver> packet_receiver) = 0;
-
-  // The following two functions handle the encoded media frames (audio and
-  // video) to be processed.
-  // Frames will be encrypted, packetized and transmitted to the network.
-  virtual void InsertCodedAudioFrame(const EncodedAudioFrame* audio_frame,
+  virtual ~CastNetSender() {}
+  virtual void InsertCodedAudioFrame(const AudioBus* audio_bus,
                                      const base::TimeTicks& recorded_time) = 0;
 
   virtual void InsertCodedVideoFrame(const EncodedVideoFrame* video_frame,
                                      const base::TimeTicks& capture_time) = 0;
 
-  // Builds an RTCP packet and sends it to the network.
   virtual void SendRtcpFromRtpSender(
       uint32 packet_type_flags,
       const RtcpSenderInfo& sender_info,
       const RtcpDlrrReportBlock& dlrr,
       const RtcpSenderLogMessage& sender_log) = 0;
 
-  // Retransmision request.
   virtual void ResendPackets(
       const MissingFramesAndPacketsMap& missing_packets) = 0;
-
-  // Retrieves audio RTP statistics.
-  virtual void RtpAudioStatistics(const base::TimeTicks& now,
-                                  RtcpSenderInfo* sender_info) = 0;
-
-  // Retrieves audio RTP statistics.
-  virtual void RtpVideoStatistics(const base::TimeTicks& now,
-                                  RtcpSenderInfo* sender_info) = 0;
+};
 
 }  // namespace transport
 }  // namespace cast
diff --git a/media/cast/transport/pacing/paced_sender.cc b/media/cast/transport/pacing/paced_sender.cc
index b860eb79..3a342b5 100644
--- a/media/cast/transport/pacing/paced_sender.cc
+++ b/media/cast/transport/pacing/paced_sender.cc
@@ -16,12 +16,10 @@ static const int64 kPacingIntervalMs = 10;
 // bursts of packets.
 static const size_t kPacingMaxBurstsPerFrame = 3;
 
-PacedSender::PacedSender(base::TickClock* clock,
-                         PacketSender* transport,
-                         scoped_refptr<base::TaskRunner> transport_task_runner)
-    : clock_(clock),
+PacedSender::PacedSender(scoped_refptr<CastEnvironment> cast_environment,
+                         PacketSender* transport)
+    : cast_environment_(cast_environment),
       transport_(transport),
-      transport_task_runner_(transport_task_runner),
       burst_size_(1),
       packets_sent_in_burst_(0),
       weak_factory_(this) {
@@ -31,15 +29,24 @@ PacedSender::PacedSender(base::TickClock* clock,
 PacedSender::~PacedSender() {}
 
 bool PacedSender::SendPackets(const PacketList& packets) {
+  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
+  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
+  cast_environment_->Logging()->InsertPacketListEvent(now, kPacketSentToPacer,
+                                                      packets);
   return SendPacketsToTransport(packets, &packet_list_);
 }
 
 bool PacedSender::ResendPackets(const PacketList& packets) {
+  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
+  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
+  cast_environment_->Logging()->InsertPacketListEvent(now, kPacketRetransmited,
+                                                      packets);
   return SendPacketsToTransport(packets, &resend_packet_list_);
 }
 
 bool PacedSender::SendPacketsToTransport(const PacketList& packets,
                                          PacketList* packets_not_sent) {
+  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   UpdateBurstSize(packets.size());
 
   if (!packets_not_sent->empty()) {
@@ -64,32 +71,39 @@ bool PacedSender::SendPacketsToTransport(const PacketList& packets,
   packets_sent_in_burst_ += packets_to_send.size();
   if (packets_to_send.empty()) return true;
 
+  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
+  cast_environment_->Logging()->InsertPacketListEvent(now, kPacketSentToNetwork,
+                                                      packets);
   return transport_->SendPackets(packets_to_send);
 }
 
 bool PacedSender::SendRtcpPacket(const Packet& packet) {
+  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   // We pass the RTCP packets straight through.
   return transport_->SendPacket(packet);
 }
 
 void PacedSender::ScheduleNextSend() {
   base::TimeDelta time_to_next = time_last_process_ -
-      clock_->NowTicks() + base::TimeDelta::FromMilliseconds(kPacingIntervalMs);
+      cast_environment_->Clock()->NowTicks() +
+      base::TimeDelta::FromMilliseconds(kPacingIntervalMs);
 
   time_to_next = std::max(time_to_next, base::TimeDelta());
 
-  transport_task_runner_->PostDelayedTask(FROM_HERE,
+  cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&PacedSender::SendNextPacketBurst, weak_factory_.GetWeakPtr()),
-      time_to_next);
+                 time_to_next);
 }
 
 void PacedSender::SendNextPacketBurst() {
+  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   SendStoredPackets();
-  time_last_process_ = clock_->NowTicks();
+  time_last_process_ = cast_environment_->Clock()->NowTicks();
   ScheduleNextSend();
 }
 
 void PacedSender::SendStoredPackets() {
+  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (packet_list_.empty() && resend_packet_list_.empty()) return;
 
   size_t packets_to_send = burst_size_;
@@ -125,6 +139,7 @@ void PacedSender::SendStoredPackets() {
 }
 
 void PacedSender::UpdateBurstSize(size_t packets_to_send) {
+  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   packets_to_send = std::max(packets_to_send,
       resend_packet_list_.size() + packet_list_.size());
 
diff --git a/media/cast/transport/pacing/paced_sender.h b/media/cast/transport/pacing/paced_sender.h
index c487d18..2f91a46 100644
--- a/media/cast/transport/pacing/paced_sender.h
+++ b/media/cast/transport/pacing/paced_sender.h
@@ -15,8 +15,8 @@
 #include "base/time/default_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
-#include "media/cast/cast_config.h"  // PacketSender
-#include "media/cast/transport/cast_transport_config.h"
+#include "media/cast/cast_config.h"
+#include "media/cast/cast_environment.h"
 
 namespace media {
 namespace cast {
@@ -39,9 +39,8 @@ class PacedSender : public PacedPacketSender,
                     public base::NonThreadSafe,
                     public base::SupportsWeakPtr<PacedSender> {
  public:
-  PacedSender(base::TickClock* clock,
-              PacketSender* transport,
-              scoped_refptr<base::TaskRunner> transport_task_runner);
+  PacedSender(scoped_refptr<CastEnvironment> cast_environment,
+              PacketSender* transport);
   virtual ~PacedSender();
 
   virtual bool SendPackets(const PacketList& packets) OVERRIDE;
@@ -64,10 +63,8 @@ class PacedSender : public PacedPacketSender,
   void SendStoredPackets();
   void UpdateBurstSize(size_t num_of_packets);
 
-  // Not owned by this class.
-  base::TickClock* const clock_;
+  scoped_refptr<CastEnvironment> cast_environment_;
   PacketSender* transport_;
-  scoped_refptr<base::TaskRunner> transport_task_runner_;
 
   size_t burst_size_;
   size_t packets_sent_in_burst_;
diff --git a/media/cast/transport/pacing/paced_sender_unittest.cc b/media/cast/transport/pacing/paced_sender_unittest.cc
index 9d8e2a8..ec23b7f 100644
--- a/media/cast/transport/pacing/paced_sender_unittest.cc
+++ b/media/cast/transport/pacing/paced_sender_unittest.cc
@@ -59,8 +59,10 @@ class PacedSenderTest : public ::testing::Test {
 
   virtual void SetUp() {
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
-    paced_sender_.reset(
-        new PacedSender(&testing_clock_, &mock_transport_, task_runner_));
+    cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
+        task_runner_, task_runner_, task_runner_, task_runner_,
+        GetDefaultCastLoggingConfig());
+    paced_sender_.reset(new PacedSender(cast_environment_, &mock_transport_));
   }
 
   PacketList CreatePacketList(size_t packet_size, int num_of_packets_in_frame) {
@@ -75,6 +77,7 @@ class PacedSenderTest : public ::testing::Test {
   TestPacketSender mock_transport_;
   scoped_refptr<test::FakeTaskRunner> task_runner_;
   scoped_ptr<PacedSender> paced_sender_;
+  scoped_refptr<CastEnvironment> cast_environment_;
 };
 
 TEST_F(PacedSenderTest, PassThroughRtcp) {
diff --git a/media/cast/transport/rtcp/rtcp_builder.cc b/media/cast/transport/rtcp/rtcp_builder.cc
index 405052a..705582e 100644
--- a/media/cast/transport/rtcp/rtcp_builder.cc
+++ b/media/cast/transport/rtcp/rtcp_builder.cc
@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "base/logging.h"
+#include "media/cast/rtcp/rtcp_utility.h"
 #include "media/cast/transport/cast_transport_defines.h"
 #include "media/cast/transport/pacing/paced_sender.h"
 #include "net/base/big_endian.h"
@@ -20,13 +21,6 @@ namespace media {
 namespace cast {
 namespace transport {
 
-namespace {
-// RFC 3550 page 44, including end null.
-static const size_t kRtcpCnameSize = 256;
-static const uint32 kCast = ('C' << 24) + ('A' << 16) + ('S' << 8) + 'T';
-static const uint8 kSenderLogSubtype = 1;
-};
-
 RtcpBuilder::RtcpBuilder(PacedPacketSender* outgoing_transport,
                              uint32 sending_ssrc,
                              const std::string& c_name)
@@ -54,7 +48,7 @@ void RtcpBuilder::SendRtcpFromRtpSender(uint32 packet_type_flags,
   }
 
   std::vector<uint8> packet;
-  packet.reserve(kMaxIpPacketSize);
+  packet.reserve(kIpPacketSize);
   if (packet_type_flags & kRtcpSr) {
     DCHECK(sender_info) << "Invalid argument";
     BuildSR(*sender_info, NULL, &packet);
@@ -82,8 +76,8 @@ void RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
                             std::vector<uint8>* packet) const {
   // Sender report.
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 52, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 52 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 52, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 52 > kIpPacketSize) return;
 
   uint16 number_of_rows = (report_block) ? 12 : 6;
   packet->resize(start_size + 28);
@@ -107,8 +101,8 @@ void RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
 void RtcpBuilder::AddReportBlocks(const RtcpReportBlock& report_block,
                                     std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 24 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 24, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 24 > kIpPacketSize) return;
 
   packet->resize(start_size + 24);
 
@@ -134,9 +128,9 @@ void RtcpBuilder::AddReportBlocks(const RtcpReportBlock& report_block,
 
 void RtcpBuilder::BuildSdec(std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size +  12 + c_name_.length(), kMaxIpPacketSize)
+  DCHECK_LT(start_size +  12 + c_name_.length(), kIpPacketSize)
       << "Not enough buffer space";
-  if (start_size + 12 > kMaxIpPacketSize) return;
+  if (start_size + 12 > kIpPacketSize) return;
 
   // SDES Source Description.
   packet->resize(start_size + 10);
@@ -177,8 +171,8 @@ void RtcpBuilder::BuildSdec(std::vector<uint8>* packet) const {
 
 void RtcpBuilder::BuildBye(std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 8, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 8 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 8, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 8 > kIpPacketSize) return;
 
   packet->resize(start_size + 8);
 
@@ -209,8 +203,8 @@ void RtcpBuilder::BuildBye(std::vector<uint8>* packet) const {
 void RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock* dlrr,
                                 std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 24 > kMaxIpPacketSize) return;
+  DCHECK_LT(start_size + 24, kIpPacketSize) << "Not enough buffer space";
+  if (start_size + 24 > kIpPacketSize) return;
 
   packet->resize(start_size + 24);
 
@@ -232,7 +226,7 @@ void RtcpBuilder::BuildSenderLog(RtcpSenderLogMessage* sender_log_message,
   DCHECK(sender_log_message);
   DCHECK(packet);
   size_t start_size = packet->size();
-  size_t remaining_space = kMaxIpPacketSize - start_size;
+  size_t remaining_space = kIpPacketSize - start_size;
   DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
        << "Not enough buffer space";
   if (remaining_space < kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
diff --git a/media/cast/transport/rtcp/rtcp_builder_unittest.cc b/media/cast/transport/rtcp/rtcp_builder_unittest.cc
index 275659b7..c5f2759 100644
--- a/media/cast/transport/rtcp/rtcp_builder_unittest.cc
+++ b/media/cast/transport/rtcp/rtcp_builder_unittest.cc
@@ -51,7 +51,7 @@ class TestRtcpTransport : public PacedPacketSender {
   int packet_count() const { return packet_count_; }
 
  private:
-  uint8 expected_packet_[kMaxIpPacketSize];
+  uint8 expected_packet_[kIpPacketSize];
   size_t expected_packet_length_;
   int packet_count_;
 };
diff --git a/media/cast/transport/rtp_sender/packet_storage/packet_storage.cc b/media/cast/transport/rtp_sender/packet_storage/packet_storage.cc
index 7d6f62f..7b9f801 100644
--- a/media/cast/transport/rtp_sender/packet_storage/packet_storage.cc
+++ b/media/cast/transport/rtp_sender/packet_storage/packet_storage.cc
@@ -21,11 +21,11 @@ typedef TimeToPacketMap::iterator TimeToPacketIterator;
 class StoredPacket {
  public:
   StoredPacket() {
-    packet_.reserve(kMaxIpPacketSize);
+    packet_.reserve(kIpPacketSize);
   }
 
   void Save(const Packet* packet) {
-    DCHECK_LT(packet->size(), kMaxIpPacketSize) << "Invalid argument";
+    DCHECK_LT(packet->size(), kIpPacketSize) << "Invalid argument";
     packet_.clear();
     packet_.insert(packet_.begin(), packet->begin(), packet->end());
   }
diff --git a/media/cast/transport/rtp_sender/packet_storage/packet_storage.h b/media/cast/transport/rtp_sender/packet_storage/packet_storage.h
index e881618..0c9ce3b 100644
--- a/media/cast/transport/rtp_sender/packet_storage/packet_storage.h
+++ b/media/cast/transport/rtp_sender/packet_storage/packet_storage.h
@@ -14,8 +14,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
-#include "media/cast/transport/cast_transport_config.h"
-#include "media/cast/transport/cast_transport_defines.h"
+#include "media/cast/cast_config.h"
 
 namespace media {
 namespace cast {
diff --git a/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer.cc b/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer.cc
index 707f6aa..aafe93f 100644
--- a/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer.cc
+++ b/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer.cc
@@ -22,7 +22,7 @@ static const uint8 kRtpMarkerBitMask = 0x80;
 RtpPacketizerConfig::RtpPacketizerConfig()
     : audio(false),
       payload_type(-1),
-      max_payload_length(kMaxIpPacketSize - 28),  // Default is IP-v4/UDP.
+      max_payload_length(kIpPacketSize - 28),  // Default is IP-v4/UDP.
       sequence_number(0),
       rtp_timestamp(0),
       frequency(8000),
diff --git a/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer_unittest.cc b/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer_unittest.cc
index 85a5969..aaf349d 100644
--- a/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer_unittest.cc
+++ b/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer_unittest.cc
@@ -6,6 +6,7 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
+#include "media/cast/cast_config.h"
 #include "media/cast/transport/pacing/paced_sender.h"
 #include "media/cast/transport/rtp_sender/packet_storage/packet_storage.h"
 #include "media/cast/transport/rtp_sender/rtp_packetizer/test/rtp_header_parser.h"
diff --git a/media/cast/transport/rtp_sender/rtp_sender.cc b/media/cast/transport/rtp_sender/rtp_sender.cc
index f06d6e1..cbb9a4e 100644
--- a/media/cast/transport/rtp_sender/rtp_sender.cc
+++ b/media/cast/transport/rtp_sender/rtp_sender.cc
@@ -6,6 +6,7 @@
 
 #include "base/logging.h"
 #include "base/rand_util.h"
+#include "media/cast/rtcp/rtcp_defines.h"
 #include "media/cast/transport/cast_transport_defines.h"
 #include "media/cast/transport/pacing/paced_sender.h"
 #include "net/base/big_endian.h"
@@ -14,23 +15,26 @@ namespace media {
 namespace cast {
 namespace transport {
 
-RtpSender::RtpSender(base::TickClock* clock,
+RtpSender::RtpSender(scoped_refptr<CastEnvironment> cast_environment,
                      const AudioSenderConfig* audio_config,
                      const VideoSenderConfig* video_config,
                      PacedPacketSender* transport)
-    : config_(),
+    : cast_environment_(cast_environment),
+      config_(),
       transport_(transport) {
   // Store generic cast config and create packetizer config.
   DCHECK(audio_config || video_config) << "Invalid argument";
   if (audio_config) {
-    storage_.reset(new PacketStorage(clock, audio_config->rtp_history_ms));
+    storage_.reset(new PacketStorage(cast_environment->Clock(),
+                                     audio_config->rtp_history_ms));
     config_.audio = true;
     config_.ssrc = audio_config->sender_ssrc;
     config_.payload_type = audio_config->rtp_payload_type;
     config_.frequency = audio_config->frequency;
     config_.audio_codec = audio_config->codec;
   } else {
-    storage_.reset(new PacketStorage(clock, video_config->rtp_history_ms));
+    storage_.reset(new PacketStorage(cast_environment->Clock(),
+                                     video_config->rtp_history_ms));
     config_.audio = false;
     config_.ssrc = video_config->sender_ssrc;
     config_.payload_type = video_config->rtp_payload_type;
diff --git a/media/cast/transport/rtp_sender/rtp_sender.h b/media/cast/transport/rtp_sender/rtp_sender.h
index cc704a1..cb2c12f 100644
--- a/media/cast/transport/rtp_sender/rtp_sender.h
+++ b/media/cast/transport/rtp_sender/rtp_sender.h
@@ -31,7 +31,7 @@ class PacedPacketSender;
 // acknowledged by the remote peer or timed out.
 class RtpSender {
  public:
-  RtpSender(base::TickClock* clock,
+  RtpSender(scoped_refptr<CastEnvironment> cast_environment,
             const AudioSenderConfig* audio_config,
             const VideoSenderConfig* video_config,
             PacedPacketSender* transport);
@@ -53,6 +53,7 @@ class RtpSender {
  private:
   void UpdateSequenceNumber(std::vector<uint8>* packet);
 
+  scoped_refptr<CastEnvironment> cast_environment_;
   RtpPacketizerConfig config_;
   scoped_ptr<RtpPacketizer> packetizer_;
   scoped_ptr<PacketStorage> storage_;
diff --git a/media/cast/transport/transport/transport.h b/media/cast/transport/transport/transport.h
index a275697..9e69196 100644
--- a/media/cast/transport/transport/transport.h
+++ b/media/cast/transport/transport/transport.h
@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef MEDIA_CAST_TRANSPORT_TRANSPORT_TRANSPORT_H_
-#define MEDIA_CAST_TRANSPORT_TRANSPORT_TRANSPORT_H_
+#ifndef MEDIA_CAST_TEST_TRANSPORT_TRANSPORT_H_
+#define MEDIA_CAST_TEST_TRANSPORT_TRANSPORT_H_
 
 #include "base/memory/scoped_ptr.h"
-#include "media/cast/cast_config.h"  // PacketSender
-#include "media/cast/transport/cast_transport_config.h"
+#include "media/cast/cast_config.h"
+#include "media/cast/cast_environment.h"
 #include "net/udp/udp_server_socket.h"
 
 
@@ -51,4 +51,4 @@ class Transport {
 }  // namespace cast
 }  // namespace media
 
-#endif  // MEDIA_CAST_TRANSPORT_TRANSPORT_TRANSPORT_H_
+#endif  // MEDIA_CAST_TEST_TRANSPORT_TRANSPORT_H_
diff --git a/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc b/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc
index ade419b..12c54428 100644
--- a/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc
+++ b/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc
@@ -54,7 +54,7 @@ void Vp8Decoder::InitDecoder() {
   }
 }
 
-bool Vp8Decoder::Decode(const transport::EncodedVideoFrame* encoded_frame,
+bool Vp8Decoder::Decode(const EncodedVideoFrame* encoded_frame,
                         const base::TimeTicks render_time,
                         const VideoFrameDecodedCallback& frame_decoded_cb) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::VIDEO_DECODER));
diff --git a/media/cast/video_receiver/codecs/vp8/vp8_decoder.h b/media/cast/video_receiver/codecs/vp8/vp8_decoder.h
index 361a71e..6a93c41 100644
--- a/media/cast/video_receiver/codecs/vp8/vp8_decoder.h
+++ b/media/cast/video_receiver/codecs/vp8/vp8_decoder.h
@@ -29,7 +29,7 @@ class Vp8Decoder : public base::NonThreadSafe {
   // Will return false in case of error, and then it's up to the caller to
   // release the memory.
   // Ownership of the encoded_frame does not pass to the Vp8Decoder.
-  bool Decode(const transport::EncodedVideoFrame* encoded_frame,
+  bool Decode(const EncodedVideoFrame* encoded_frame,
               const base::TimeTicks render_time,
               const VideoFrameDecodedCallback& frame_decoded_cb);
 
diff --git a/media/cast/video_receiver/video_decoder.cc b/media/cast/video_receiver/video_decoder.cc
index d7ce09f..aaa6811 100644
--- a/media/cast/video_receiver/video_decoder.cc
+++ b/media/cast/video_receiver/video_decoder.cc
@@ -17,10 +17,10 @@ VideoDecoder::VideoDecoder(const VideoReceiverConfig& video_config,
     : codec_(video_config.codec),
       vp8_decoder_() {
   switch (video_config.codec) {
-    case transport::kVp8:
+    case kVp8:
       vp8_decoder_.reset(new Vp8Decoder(cast_environment));
       break;
-    case transport::kH264:
+    case kH264:
       NOTIMPLEMENTED();
       break;
   }
@@ -28,11 +28,10 @@ VideoDecoder::VideoDecoder(const VideoReceiverConfig& video_config,
 
 VideoDecoder::~VideoDecoder() {}
 
-bool VideoDecoder::DecodeVideoFrame(
-    const transport::EncodedVideoFrame* encoded_frame,
-    const base::TimeTicks render_time,
-    const VideoFrameDecodedCallback&
-    frame_decoded_cb) {
+bool VideoDecoder::DecodeVideoFrame(const EncodedVideoFrame* encoded_frame,
+                                    const base::TimeTicks render_time,
+                                    const VideoFrameDecodedCallback&
+                                    frame_decoded_cb) {
   DCHECK(encoded_frame->codec == codec_) << "Invalid codec";
   DCHECK_GT(encoded_frame->data.size(), GG_UINT64_C(0)) << "Empty video frame";
   return vp8_decoder_->Decode(encoded_frame, render_time, frame_decoded_cb);
diff --git a/media/cast/video_receiver/video_decoder.h b/media/cast/video_receiver/video_decoder.h
index f1146ae..97a8a62 100644
--- a/media/cast/video_receiver/video_decoder.h
+++ b/media/cast/video_receiver/video_decoder.h
@@ -26,12 +26,12 @@ class VideoDecoder : public base::NonThreadSafe {
 
   // Decode a video frame. Decoded (raw) frame will be returned via the
   // provided callback
-  bool DecodeVideoFrame(const transport::EncodedVideoFrame* encoded_frame,
+  bool DecodeVideoFrame(const EncodedVideoFrame* encoded_frame,
                         const base::TimeTicks render_time,
                         const VideoFrameDecodedCallback& frame_decoded_cb);
 
  private:
-  transport::VideoCodec codec_;
+  VideoCodec codec_;
   scoped_ptr<Vp8Decoder> vp8_decoder_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoDecoder);
diff --git a/media/cast/video_receiver/video_decoder_unittest.cc b/media/cast/video_receiver/video_decoder_unittest.cc
index 1d9cf77..0987dd4 100644
--- a/media/cast/video_receiver/video_decoder_unittest.cc
+++ b/media/cast/video_receiver/video_decoder_unittest.cc
@@ -43,10 +43,10 @@ class VideoDecoderTest : public ::testing::Test {
     : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
       cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
           task_runner_, task_runner_, task_runner_, task_runner_,
-          task_runner_, GetDefaultCastLoggingConfig())),
+          GetDefaultCastLoggingConfig())),
       test_callback_(new DecodeTestFrameCallback()) {
     // Configure to vp8.
-    config_.codec = transport::kVp8;
+    config_.codec = kVp8;
     config_.use_external_decoder = false;
     decoder_.reset(new VideoDecoder(config_, cast_environment_));
     testing_clock_.Advance(
@@ -65,9 +65,9 @@ class VideoDecoderTest : public ::testing::Test {
 
 // TODO(pwestin): EXPECT_DEATH tests can not pass valgrind.
 TEST_F(VideoDecoderTest, DISABLED_SizeZero) {
-  transport::EncodedVideoFrame encoded_frame;
+  EncodedVideoFrame encoded_frame;
   base::TimeTicks render_time;
-  encoded_frame.codec = transport::kVp8;
+  encoded_frame.codec = kVp8;
   EXPECT_DEATH(
       decoder_->DecodeVideoFrame(
           &encoded_frame, render_time,
diff --git a/media/cast/video_receiver/video_receiver.cc b/media/cast/video_receiver/video_receiver.cc
index 8976468..d304d8b 100644
--- a/media/cast/video_receiver/video_receiver.cc
+++ b/media/cast/video_receiver/video_receiver.cc
@@ -159,7 +159,7 @@ void VideoReceiver::GetRawVideoFrame(
 // Called when we have a frame to decode.
 void VideoReceiver::DecodeVideoFrame(
     const VideoFrameDecodedCallback& callback,
-    scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
+    scoped_ptr<EncodedVideoFrame> encoded_frame,
     const base::TimeTicks& render_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   // Hand the ownership of the encoded frame to the decode thread.
@@ -170,7 +170,7 @@ void VideoReceiver::DecodeVideoFrame(
 
 // Utility function to run the decoder on a designated decoding thread.
 void VideoReceiver::DecodeVideoFrameThread(
-    scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
+    scoped_ptr<EncodedVideoFrame> encoded_frame,
     const base::TimeTicks render_time,
     const VideoFrameDecodedCallback& frame_decoded_callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::VIDEO_DECODER));
@@ -186,7 +186,7 @@ void VideoReceiver::DecodeVideoFrameThread(
 }
 
 bool VideoReceiver::DecryptVideoFrame(
-    scoped_ptr<transport::EncodedVideoFrame>* video_frame) {
+    scoped_ptr<EncodedVideoFrame>* video_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(decryptor_) << "Invalid state";
 
@@ -210,8 +210,7 @@ bool VideoReceiver::DecryptVideoFrame(
 void VideoReceiver::GetEncodedVideoFrame(
     const VideoFrameEncodedCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
-      new transport::EncodedVideoFrame());
+  scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
 
@@ -246,7 +245,7 @@ void VideoReceiver::GetEncodedVideoFrame(
 // If the frame is too old to be rendered we set the don't show flag in the
 // video bitstream where possible.
 bool VideoReceiver::PullEncodedVideoFrame(uint32 rtp_timestamp,
-    bool next_frame, scoped_ptr<transport::EncodedVideoFrame>* encoded_frame,
+    bool next_frame, scoped_ptr<EncodedVideoFrame>* encoded_frame,
     base::TimeTicks* render_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
@@ -279,8 +278,7 @@ bool VideoReceiver::PullEncodedVideoFrame(uint32 rtp_timestamp,
 
   base::TimeDelta dont_show_timeout_delta =
       base::TimeDelta::FromMilliseconds(-kDontShowTimeoutMs);
-  if (codec_ == transport::kVp8 &&
-      time_until_render < dont_show_timeout_delta) {
+  if (codec_ == kVp8 && time_until_render < dont_show_timeout_delta) {
     (*encoded_frame)->data[0] &= 0xef;
     VLOG(1) << "Don't show frame "
             << static_cast<int>((*encoded_frame)->frame_id)
@@ -302,8 +300,7 @@ void VideoReceiver::PlayoutTimeout() {
 
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
-  scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
-      new transport::EncodedVideoFrame());
+  scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
 
   if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &rtp_timestamp,
                                      &next_frame)) {
diff --git a/media/cast/video_receiver/video_receiver.h b/media/cast/video_receiver/video_receiver.h
index bb7b3a7..404f9f6 100644
--- a/media/cast/video_receiver/video_receiver.h
+++ b/media/cast/video_receiver/video_receiver.h
@@ -61,7 +61,7 @@ class VideoReceiver : public base::NonThreadSafe,
                                const RtpCastHeader& rtp_header);
 
   void DecodeVideoFrameThread(
-      scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
+      scoped_ptr<EncodedVideoFrame> encoded_frame,
       const base::TimeTicks render_time,
       const VideoFrameDecodedCallback& frame_decoded_callback);
 
@@ -72,16 +72,15 @@ class VideoReceiver : public base::NonThreadSafe,
   void CastFeedback(const RtcpCastMessage& cast_message);
 
   void DecodeVideoFrame(const VideoFrameDecodedCallback& callback,
-                        scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
+                        scoped_ptr<EncodedVideoFrame> encoded_frame,
                         const base::TimeTicks& render_time);
 
-  bool DecryptVideoFrame(scoped_ptr<transport::EncodedVideoFrame>* video_frame);
+  bool DecryptVideoFrame(scoped_ptr<EncodedVideoFrame>* video_frame);
 
-  bool PullEncodedVideoFrame(
-      uint32 rtp_timestamp,
-      bool next_frame,
-      scoped_ptr<transport::EncodedVideoFrame>* encoded_frame,
-      base::TimeTicks* render_time);
+  bool PullEncodedVideoFrame(uint32 rtp_timestamp,
+                             bool next_frame,
+                             scoped_ptr<EncodedVideoFrame>* encoded_frame,
+                             base::TimeTicks* render_time);
 
   void PlayoutTimeout();
 
@@ -105,7 +104,7 @@ class VideoReceiver : public base::NonThreadSafe,
   scoped_ptr<VideoDecoder> video_decoder_;
   scoped_refptr<CastEnvironment> cast_environment_;
   scoped_ptr<Framer> framer_;
-  const transport::VideoCodec codec_;
+  const VideoCodec codec_;
   base::TimeDelta target_delay_delta_;
   base::TimeDelta frame_delay_;
   scoped_ptr<LocalRtpVideoData> incoming_payload_callback_;
diff --git a/media/cast/video_receiver/video_receiver_unittest.cc b/media/cast/video_receiver/video_receiver_unittest.cc
index e382371..e13f0f5 100644
--- a/media/cast/video_receiver/video_receiver_unittest.cc
+++ b/media/cast/video_receiver/video_receiver_unittest.cc
@@ -35,10 +35,10 @@ class TestVideoReceiverCallback :
     ++num_called_;
   }
 
-  void FrameToDecode(scoped_ptr<transport::EncodedVideoFrame> video_frame,
+  void FrameToDecode(scoped_ptr<EncodedVideoFrame> video_frame,
       const base::TimeTicks& render_time) {
     EXPECT_TRUE(video_frame->key_frame);
-    EXPECT_EQ(transport::kVp8, video_frame->codec);
+    EXPECT_EQ(kVp8, video_frame->codec);
     ++num_called_;
   }
 
@@ -69,12 +69,12 @@ class VideoReceiverTest : public ::testing::Test {
  protected:
   VideoReceiverTest() {
     // Configure to use vp8 software implementation.
-    config_.codec = transport::kVp8;
+    config_.codec = kVp8;
     config_.use_external_decoder = false;
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
         task_runner_, task_runner_, task_runner_, task_runner_,
-        task_runner_, GetDefaultCastLoggingConfig());
+        GetDefaultCastLoggingConfig());
     receiver_.reset(new
         PeerVideoReceiver(cast_environment_, config_, &mock_transport_));
     testing_clock_.Advance(
diff --git a/media/cast/video_sender/codecs/vp8/vp8_encoder.cc b/media/cast/video_sender/codecs/vp8/vp8_encoder.cc
index 595a0ca..54852f0 100644
--- a/media/cast/video_sender/codecs/vp8/vp8_encoder.cc
+++ b/media/cast/video_sender/codecs/vp8/vp8_encoder.cc
@@ -11,7 +11,6 @@
 #include "base/logging.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/transport/cast_transport_config.h"
 #include "third_party/libvpx/source/libvpx/vpx/vp8cx.h"
 
 namespace media {
@@ -128,7 +127,7 @@ void Vp8Encoder::InitEncode(int number_of_cores) {
 }
 
 bool Vp8Encoder::Encode(const scoped_refptr<media::VideoFrame>& video_frame,
-                        transport::EncodedVideoFrame* encoded_image) {
+                        EncodedVideoFrame* encoded_image) {
   // Image in vpx_image_t format.
   // Input image is const. VP8's raw image is not defined as const.
   raw_image_->planes[PLANE_Y] =
@@ -197,7 +196,7 @@ bool Vp8Encoder::Encode(const scoped_refptr<media::VideoFrame>& video_frame,
   if (total_size == 0) return true;
 
   // Populate the encoded frame.
-  encoded_image->codec = transport::kVp8;
+  encoded_image->codec = kVp8;
   encoded_image->last_referenced_frame_id = latest_frame_id_to_reference;
   encoded_image->frame_id = ++last_encoded_frame_id_;
 
diff --git a/media/cast/video_sender/codecs/vp8/vp8_encoder.h b/media/cast/video_sender/codecs/vp8/vp8_encoder.h
index e39bc16..0405630 100644
--- a/media/cast/video_sender/codecs/vp8/vp8_encoder.h
+++ b/media/cast/video_sender/codecs/vp8/vp8_encoder.h
@@ -31,7 +31,7 @@ class Vp8Encoder {
 
   // Encode a raw image (as a part of a video stream).
   bool Encode(const scoped_refptr<media::VideoFrame>& video_frame,
-              transport::EncodedVideoFrame* encoded_image);
+              EncodedVideoFrame* encoded_image);
 
   // Update the encoder with a new target bit rate.
   void UpdateRates(uint32 new_bitrate);
diff --git a/media/cast/video_sender/external_video_encoder.cc b/media/cast/video_sender/external_video_encoder.cc
index 6bba936..4d6607a 100644
--- a/media/cast/video_sender/external_video_encoder.cc
+++ b/media/cast/video_sender/external_video_encoder.cc
@@ -12,7 +12,6 @@
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/transport/cast_transport_config.h"
 #include "media/video/video_encode_accelerator.h"
 
 namespace {
@@ -79,10 +78,10 @@ class LocalVideoEncodeAcceleratorClient
 
     VideoCodecProfile output_profile = media::VIDEO_CODEC_PROFILE_UNKNOWN;
     switch (video_config.codec) {
-      case transport::kVp8:
+      case kVp8:
         output_profile = media::VP8PROFILE_MAIN;
         break;
-      case transport::kH264:
+      case kH264:
         output_profile = media::H264PROFILE_MAIN;
         break;
     }
@@ -264,8 +263,7 @@ class LocalVideoEncodeAcceleratorClient
       NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
       return;
     }
-    scoped_ptr<transport::EncodedVideoFrame>
-        encoded_frame(new transport::EncodedVideoFrame());
+    scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
 
     encoded_frame->codec = codec_;
     encoded_frame->key_frame = key_frame;
@@ -322,7 +320,7 @@ class LocalVideoEncodeAcceleratorClient
 
   scoped_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
   int max_frame_rate_;
-  transport::VideoCodec codec_;
+  VideoCodec codec_;
   uint32 last_encoded_frame_id_;
 
   // Shared memory buffers for input/output with the VideoAccelerator.
diff --git a/media/cast/video_sender/external_video_encoder_unittest.cc b/media/cast/video_sender/external_video_encoder_unittest.cc
index b159280..f99569d 100644
--- a/media/cast/video_sender/external_video_encoder_unittest.cc
+++ b/media/cast/video_sender/external_video_encoder_unittest.cc
@@ -38,9 +38,8 @@ class TestVideoEncoderCallback :
     expected_capture_time_ = expected_capture_time;
   }
 
-  void DeliverEncodedVideoFrame(
-      scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
-      const base::TimeTicks& capture_time) {
+  void DeliverEncodedVideoFrame(scoped_ptr<EncodedVideoFrame> encoded_frame,
+                                const base::TimeTicks& capture_time) {
     EXPECT_EQ(expected_key_frame_, encoded_frame->key_frame);
     EXPECT_EQ(expected_frame_id_, encoded_frame->frame_id);
     EXPECT_EQ(expected_last_referenced_frame_id_,
@@ -79,7 +78,7 @@ class ExternalVideoEncoderTest : public ::testing::Test {
     video_config_.min_qp = 0;
     video_config_.max_frame_rate = 30;
     video_config_.max_number_of_video_buffers_used = 3;
-    video_config_.codec = transport::kVp8;
+    video_config_.codec = kVp8;
     gfx::Size size(video_config_.width, video_config_.height);
     video_frame_ =  media::VideoFrame::CreateFrame(VideoFrame::I420,
         size, gfx::Rect(size), size, base::TimeDelta());
@@ -91,7 +90,7 @@ class ExternalVideoEncoderTest : public ::testing::Test {
   virtual void SetUp() {
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
-        task_runner_, task_runner_, task_runner_, task_runner_, task_runner_,
+        task_runner_, task_runner_, task_runner_, task_runner_,
         GetDefaultCastLoggingConfig());
     video_encoder_.reset(new ExternalVideoEncoder(
         cast_environment_,
diff --git a/media/cast/video_sender/video_encoder.h b/media/cast/video_sender/video_encoder.h
index 43d6e8c..2536024 100644
--- a/media/cast/video_sender/video_encoder.h
+++ b/media/cast/video_sender/video_encoder.h
@@ -20,7 +20,7 @@ namespace cast {
 // All these functions are called from the main cast thread.
 class VideoEncoder {
  public:
-  typedef base::Callback<void(scoped_ptr<transport::EncodedVideoFrame>,
+  typedef base::Callback<void(scoped_ptr<EncodedVideoFrame>,
                               const base::TimeTicks&)> FrameEncodedCallback;
 
   virtual ~VideoEncoder() {}
diff --git a/media/cast/video_sender/video_encoder_impl.cc b/media/cast/video_sender/video_encoder_impl.cc
index 88e49ce..4ca9d23 100644
--- a/media/cast/video_sender/video_encoder_impl.cc
+++ b/media/cast/video_sender/video_encoder_impl.cc
@@ -29,7 +29,7 @@ VideoEncoderImpl::VideoEncoderImpl(
       cast_environment_(cast_environment),
       skip_next_frame_(false),
       skip_count_(0) {
-  if (video_config.codec == transport::kVp8) {
+  if (video_config.codec == kVp8) {
     vp8_encoder_.reset(new Vp8Encoder(video_config, max_unacked_frames));
   } else {
     DCHECK(false) << "Invalid config";  // Codec not supported.
@@ -47,7 +47,7 @@ bool VideoEncoderImpl::EncodeVideoFrame(
     const base::TimeTicks& capture_time,
     const FrameEncodedCallback& frame_encoded_callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  if (video_config_.codec != transport::kVp8) return false;
+  if (video_config_.codec != kVp8) return false;
 
   if (skip_next_frame_) {
     ++skip_count_;
@@ -81,8 +81,7 @@ void VideoEncoderImpl::EncodeVideoFrameEncoderThread(
       dynamic_config.latest_frame_id_to_reference);
   vp8_encoder_->UpdateRates(dynamic_config.bit_rate);
 
-  scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
-      new transport::EncodedVideoFrame());
+  scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
   bool retval = vp8_encoder_->Encode(video_frame, encoded_frame.get());
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
diff --git a/media/cast/video_sender/video_encoder_impl.h b/media/cast/video_sender/video_encoder_impl.h
index 5c42490..992d684 100644
--- a/media/cast/video_sender/video_encoder_impl.h
+++ b/media/cast/video_sender/video_encoder_impl.h
@@ -21,7 +21,7 @@ namespace cast {
 // the video encoder thread.
 class VideoEncoderImpl : public VideoEncoder {
  public:
-  typedef base::Callback<void(scoped_ptr<transport::EncodedVideoFrame>,
+  typedef base::Callback<void(scoped_ptr<EncodedVideoFrame>,
                               const base::TimeTicks&)> FrameEncodedCallback;
 
   VideoEncoderImpl(scoped_refptr<CastEnvironment> cast_environment,
diff --git a/media/cast/video_sender/video_encoder_impl_unittest.cc b/media/cast/video_sender/video_encoder_impl_unittest.cc
index 8522f87..8d60200 100644
--- a/media/cast/video_sender/video_encoder_impl_unittest.cc
+++ b/media/cast/video_sender/video_encoder_impl_unittest.cc
@@ -36,9 +36,8 @@ class TestVideoEncoderCallback :
     expected_capture_time_ = expected_capture_time;
   }
 
-  void DeliverEncodedVideoFrame(
-      scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
-      const base::TimeTicks& capture_time) {
+  void DeliverEncodedVideoFrame(scoped_ptr<EncodedVideoFrame> encoded_frame,
+                                const base::TimeTicks& capture_time) {
     EXPECT_EQ(expected_key_frame_, encoded_frame->key_frame);
     EXPECT_EQ(expected_frame_id_, encoded_frame->frame_id);
     EXPECT_EQ(expected_last_referenced_frame_id_,
@@ -76,7 +75,7 @@ class VideoEncoderImplTest : public ::testing::Test {
     video_config_.min_qp = 0;
     video_config_.max_frame_rate = 30;
     video_config_.max_number_of_video_buffers_used = 3;
-    video_config_.codec = transport::kVp8;
+    video_config_.codec = kVp8;
     gfx::Size size(video_config_.width, video_config_.height);
     video_frame_ =  media::VideoFrame::CreateFrame(VideoFrame::I420,
         size, gfx::Rect(size), size, base::TimeDelta());
@@ -89,7 +88,7 @@ class VideoEncoderImplTest : public ::testing::Test {
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
         task_runner_, task_runner_, task_runner_, task_runner_,
-        task_runner_, GetDefaultCastLoggingConfig());
+        GetDefaultCastLoggingConfig());
   }
 
   void Configure(uint8 max_unacked_frames) {
diff --git a/media/cast/video_sender/video_sender.cc b/media/cast/video_sender/video_sender.cc
index 355cdef..1f27ba7 100644
--- a/media/cast/video_sender/video_sender.cc
+++ b/media/cast/video_sender/video_sender.cc
@@ -61,7 +61,7 @@ VideoSender::VideoSender(
       max_frame_rate_(video_config.max_frame_rate),
       cast_environment_(cast_environment),
       rtcp_feedback_(new LocalRtcpVideoSenderFeedback(this)),
-      rtp_sender_(new transport::RtpSender(cast_environment->Clock(),
+      rtp_sender_(new transport::RtpSender(cast_environment,
                                            NULL,
                                            &video_config,
                                            paced_packet_sender)),
@@ -148,14 +148,13 @@ void VideoSender::InsertRawVideoFrame(
 }
 
 void VideoSender::SendEncodedVideoFrameMainThread(
-    scoped_ptr<transport::EncodedVideoFrame> video_frame,
+    scoped_ptr<EncodedVideoFrame> video_frame,
     const base::TimeTicks& capture_time) {
   SendEncodedVideoFrame(video_frame.get(), capture_time);
 }
 
-bool VideoSender::EncryptVideoFrame(
-    const transport::EncodedVideoFrame& video_frame,
-    transport::EncodedVideoFrame* encrypted_frame) {
+bool VideoSender::EncryptVideoFrame(const EncodedVideoFrame& video_frame,
+                                    EncodedVideoFrame* encrypted_frame) {
   DCHECK(encryptor_) << "Invalid state";
 
   if (!encryptor_->SetCounter(GetAesNonce(video_frame.frame_id, iv_mask_))) {
@@ -175,14 +174,13 @@ bool VideoSender::EncryptVideoFrame(
   return true;
 }
 
-void VideoSender::SendEncodedVideoFrame(
-    const transport::EncodedVideoFrame* encoded_frame,
-    const base::TimeTicks& capture_time) {
+void VideoSender::SendEncodedVideoFrame(const EncodedVideoFrame* encoded_frame,
+                                        const base::TimeTicks& capture_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
 
   if (encryptor_) {
-    transport::EncodedVideoFrame encrypted_video_frame;
+    EncodedVideoFrame encrypted_video_frame;
 
     if (!EncryptVideoFrame(*encoded_frame, &encrypted_video_frame)) {
       // Logging already done.
diff --git a/media/cast/video_sender/video_sender.h b/media/cast/video_sender/video_sender.h
index 13acf40..9439de9 100644
--- a/media/cast/video_sender/video_sender.h
+++ b/media/cast/video_sender/video_sender.h
@@ -91,22 +91,22 @@ class VideoSender : public base::NonThreadSafe,
   void ScheduleNextSkippedFramesCheck();
   void SkippedFramesCheck();
 
-  void SendEncodedVideoFrame(const transport::EncodedVideoFrame* video_frame,
+  void SendEncodedVideoFrame(const EncodedVideoFrame* video_frame,
                              const base::TimeTicks& capture_time);
   void ResendFrame(uint32 resend_frame_id);
   void ReceivedAck(uint32 acked_frame_id);
   void UpdateFramesInFlight();
 
   void SendEncodedVideoFrameMainThread(
-      scoped_ptr<transport::EncodedVideoFrame> video_frame,
+      scoped_ptr<EncodedVideoFrame> video_frame,
       const base::TimeTicks& capture_time);
 
   void InitializeTimers();
 
   // Caller must allocate the destination |encrypted_video_frame| the data
   // member will be resized to hold the encrypted size.
-  bool EncryptVideoFrame(const transport::EncodedVideoFrame& encoded_frame,
-                         transport::EncodedVideoFrame* encrypted_video_frame);
+  bool EncryptVideoFrame(const EncodedVideoFrame& encoded_frame,
+                         EncodedVideoFrame* encrypted_video_frame);
 
   const base::TimeDelta rtp_max_delay_;
   const int max_frame_rate_;
diff --git a/media/cast/video_sender/video_sender_unittest.cc b/media/cast/video_sender/video_sender_unittest.cc
index 0f0852d..d12b4f4 100644
--- a/media/cast/video_sender/video_sender_unittest.cc
+++ b/media/cast/video_sender/video_sender_unittest.cc
@@ -70,7 +70,7 @@ class VideoSenderTest : public ::testing::Test {
     video_config.min_qp = 0;
     video_config.max_frame_rate = 30;
     video_config.max_number_of_video_buffers_used = 1;
-    video_config.codec = transport::kVp8;
+    video_config.codec = kVp8;
 
     if (external) {
       video_sender_.reset(new PeerVideoSender(cast_environment_,
@@ -86,8 +86,8 @@ class VideoSenderTest : public ::testing::Test {
   virtual void SetUp() {
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
-        task_runner_, task_runner_, task_runner_, task_runner_,
-        task_runner_, GetDefaultCastLoggingConfig());
+       task_runner_, task_runner_, task_runner_, task_runner_,
+       GetDefaultCastLoggingConfig());
   }
 
   scoped_refptr<media::VideoFrame> GetNewVideoFrame() {