Cast: Reshuffle files under media/cast

media/cast/test/end2end_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This test generate synthetic data. For audio it's a sinusoid waveform with
 // frequency kSoundFrequency and different amplitudes. For video it's a pattern
 // that is shifting by one pixel per frame, each pixels neighbors right and down
 // is this pixels value +1, since the pixel value is 8 bit it will wrap
 // frequently within the image. Visually this will create diagonally color bands
 // that moves across the screen
@@ skipping 11 matching lines @@
 #include "base/sys_byteorder.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_receiver.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/simple_event_subscriber.h"
+#include "media/cast/net/cast_transport_config.h"
+#include "media/cast/net/cast_transport_defines.h"
+#include "media/cast/net/cast_transport_sender.h"
+#include "media/cast/net/cast_transport_sender_impl.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "media/cast/test/skewed_single_thread_task_runner.h"
 #include "media/cast/test/skewed_tick_clock.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/udp_proxy.h"
 #include "media/cast/test/utility/video_utility.h"
-#include "media/cast/transport/cast_transport_config.h"
-#include "media/cast/transport/cast_transport_defines.h"
-#include "media/cast/transport/cast_transport_sender.h"
-#include "media/cast/transport/cast_transport_sender_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 static const int64 kStartMillisecond = INT64_C(1245);
 static const int kAudioChannels = 2;
 static const double kSoundFrequency = 314.15926535897;  // Freq of sine wave.
@@ skipping 37 matching lines @@
   compressed.reserve(base_16.size() / 2);
 
   std::vector<uint8> v;
   if (!base::HexStringToBytes(base_16, &v)) {
     NOTREACHED();
   }
   compressed.assign(reinterpret_cast<const char*>(&v[0]), v.size());
   return compressed;
 }
 
-void UpdateCastTransportStatus(transport::CastTransportStatus status) {
-  bool result = (status == transport::TRANSPORT_AUDIO_INITIALIZED ||
-                 status == transport::TRANSPORT_VIDEO_INITIALIZED);
+void UpdateCastTransportStatus(CastTransportStatus status) {
+  bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
+                 status == TRANSPORT_VIDEO_INITIALIZED);
   EXPECT_TRUE(result);
 }
 
 void AudioInitializationStatus(CastInitializationStatus status) {
   EXPECT_EQ(STATUS_AUDIO_INITIALIZED, status);
 }
 
 void VideoInitializationStatus(CastInitializationStatus status) {
   EXPECT_EQ(STATUS_VIDEO_INITIALIZED, status);
 }
@@ skipping 48 matching lines @@
   }
   return event_counter_for_packet;
 }
 
 }  // namespace
 
 // Shim that turns forwards packets from a test::PacketPipe to a
 // PacketReceiverCallback.
 class LoopBackPacketPipe : public test::PacketPipe {
  public:
-  LoopBackPacketPipe(const transport::PacketReceiverCallback& packet_receiver)
+  LoopBackPacketPipe(const PacketReceiverCallback& packet_receiver)
       : packet_receiver_(packet_receiver) {}
 
   virtual ~LoopBackPacketPipe() {}
 
   // PacketPipe implementations.
-  virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
+  virtual void Send(scoped_ptr<Packet> packet) OVERRIDE {
     packet_receiver_.Run(packet.Pass());
   }
 
  private:
-  transport::PacketReceiverCallback packet_receiver_;
+  PacketReceiverCallback packet_receiver_;
 };
 
 // Class that sends the packet direct from sender into the receiver with the
 // ability to drop packets between the two.
-class LoopBackTransport : public transport::PacketSender {
+class LoopBackTransport : public PacketSender {
  public:
   explicit LoopBackTransport(scoped_refptr<CastEnvironment> cast_environment)
       : send_packets_(true),
         drop_packets_belonging_to_odd_frames_(false),
         cast_environment_(cast_environment) {}
 
   void SetPacketReceiver(
-      const transport::PacketReceiverCallback& packet_receiver,
+      const PacketReceiverCallback& packet_receiver,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       base::TickClock* clock) {
     scoped_ptr<test::PacketPipe> loopback_pipe(
         new LoopBackPacketPipe(packet_receiver));
     if (packet_pipe_) {
       packet_pipe_->AppendToPipe(loopback_pipe.Pass());
     } else {
       packet_pipe_ = loopback_pipe.Pass();
     }
     packet_pipe_->InitOnIOThread(task_runner, clock);
   }
 
-  virtual bool SendPacket(transport::PacketRef packet,
+  virtual bool SendPacket(PacketRef packet,
                           const base::Closure& cb) OVERRIDE {
     DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
     if (!send_packets_)
       return false;
 
     if (drop_packets_belonging_to_odd_frames_) {
       uint32 frame_id = packet->data[13];
       if (frame_id % 2 == 1)
         return true;
     }
@@ skipping 81 matching lines @@
         0.0,
         kMaxAllowedPlayoutErrorMs);
     VLOG_IF(1, !last_playout_time_.is_null())
         << "Audio frame playout time delta (compared to last frame) is "
         << (playout_time - last_playout_time_).InMicroseconds() << " usec.";
     last_playout_time_ = playout_time;
 
     EXPECT_TRUE(is_continuous);
   }
 
-  void CheckCodedAudioFrame(scoped_ptr<transport::EncodedFrame> audio_frame) {
+  void CheckCodedAudioFrame(scoped_ptr<EncodedFrame> audio_frame) {
     ASSERT_TRUE(!!audio_frame);
     ASSERT_FALSE(expected_frames_.empty());
     const ExpectedAudioFrame& expected_audio_frame =
         *(expected_frames_.front());
     // Note: Just peeking here.  Will delegate to CheckAudioFrame() to pop.
 
     // We need to "decode" the encoded audio frame.  The codec is simply to
     // swizzle the bytes of each int16 from host-->network-->host order to get
     // interleaved int16 PCM.  Then, make an AudioBus out of that.
     const int num_elements = audio_frame->data.size() / sizeof(int16);
@@ skipping 130 matching lines @@
         receiver_to_sender_(cast_environment_receiver_),
         sender_to_receiver_(cast_environment_sender_),
         test_receiver_audio_callback_(new TestReceiverAudioCallback()),
         test_receiver_video_callback_(new TestReceiverVideoCallback()) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     cast_environment_sender_->Logging()->AddRawEventSubscriber(
         &event_subscriber_sender_);
   }
 
-  void Configure(transport::Codec video_codec,
-                 transport::Codec audio_codec,
+  void Configure(Codec video_codec,
+                 Codec audio_codec,
                  int audio_sampling_frequency,
                  int max_number_of_video_buffers_used) {
     audio_sender_config_.ssrc = 1;
     audio_sender_config_.incoming_feedback_ssrc = 2;
     audio_sender_config_.target_playout_delay =
         base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs);
     audio_sender_config_.rtp_payload_type = 96;
     audio_sender_config_.use_external_encoder = false;
     audio_sender_config_.frequency = audio_sampling_frequency;
     audio_sender_config_.channels = kAudioChannels;
@@ skipping 102 matching lines @@
     }
   }
 
   void Create() {
     cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
                                           audio_receiver_config_,
                                           video_receiver_config_,
                                           &receiver_to_sender_);
 
     net::IPEndPoint dummy_endpoint;
-    transport_sender_.reset(new transport::CastTransportSenderImpl(
+    transport_sender_.reset(new CastTransportSenderImpl(
         NULL,
         testing_clock_sender_,
         dummy_endpoint,
         base::Bind(&UpdateCastTransportStatus),
         base::Bind(&End2EndTest::LogRawEvents, base::Unretained(this)),
         base::TimeDelta::FromSeconds(1),
         task_runner_sender_,
         &sender_to_receiver_));
 
     cast_sender_ =
@@ skipping 159 matching lines @@
   base::TimeDelta max_video_playout_curvature_;
   base::TimeTicks last_video_playout_time_;
   base::TimeDelta last_video_playout_delta_;
   base::TimeTicks last_audio_playout_time_;
 
   scoped_refptr<CastEnvironment> cast_environment_sender_;
   scoped_refptr<CastEnvironment> cast_environment_receiver_;
 
   LoopBackTransport receiver_to_sender_;
   LoopBackTransport sender_to_receiver_;
-  scoped_ptr<transport::CastTransportSenderImpl> transport_sender_;
+  scoped_ptr<CastTransportSenderImpl> transport_sender_;
 
   scoped_ptr<CastReceiver> cast_receiver_;
   scoped_ptr<CastSender> cast_sender_;
   scoped_refptr<AudioFrameInput> audio_frame_input_;
   scoped_refptr<VideoFrameInput> video_frame_input_;
 
   scoped_refptr<TestReceiverAudioCallback> test_receiver_audio_callback_;
   scoped_refptr<TestReceiverVideoCallback> test_receiver_video_callback_;
 
   scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
 
   SimpleEventSubscriber event_subscriber_sender_;
   std::vector<FrameEvent> frame_events_;
   std::vector<PacketEvent> packet_events_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > audio_ticks_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > video_ticks_;
   // |transport_sender_| has a RepeatingTimer which needs a MessageLoop.
   base::MessageLoop message_loop_;
 };
 
 TEST_F(End2EndTest, LoopNoLossPcm16) {
-  Configure(transport::CODEC_VIDEO_VP8, transport::CODEC_AUDIO_PCM16, 32000, 1);
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1);
   // Reduce video resolution to allow processing multiple frames within a
   // reasonable time frame.
   video_sender_config_.width = kVideoQcifWidth;
   video_sender_config_.height = kVideoQcifHeight;
   Create();
 
   const int kNumIterations = 50;
   int video_start = kVideoStart;
   int audio_diff = kFrameTimerMs;
   int num_audio_frames_requested = 0;
@@ skipping 33 matching lines @@
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(num_audio_frames_requested,
             test_receiver_audio_callback_->number_times_called());
   EXPECT_EQ(kNumIterations,
             test_receiver_video_callback_->number_times_called());
 }
 
 // This tests our external decoder interface for Audio.
 // Audio test without packet loss using raw PCM 16 audio "codec";
 TEST_F(End2EndTest, LoopNoLossPcm16ExternalDecoder) {
-  Configure(transport::CODEC_VIDEO_VP8, transport::CODEC_AUDIO_PCM16, 32000, 1);
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1);
   Create();
 
   const int kNumIterations = 10;
   for (int i = 0; i < kNumIterations; ++i) {
     FeedAudioFrames(1, true);
     RunTasks(kAudioFrameDurationMs);
     cast_receiver_->RequestEncodedAudioFrame(
         base::Bind(&TestReceiverAudioCallback::CheckCodedAudioFrame,
                    test_receiver_audio_callback_));
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(kNumIterations,
             test_receiver_audio_callback_->number_times_called());
 }
 
 // This tests our Opus audio codec without video.
 TEST_F(End2EndTest, LoopNoLossOpus) {
-  Configure(transport::CODEC_VIDEO_VP8, transport::CODEC_AUDIO_OPUS,
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_OPUS,
             kDefaultAudioSamplingRate, 1);
   Create();
 
   const int kNumIterations = 300;
   for (int i = 0; i < kNumIterations; ++i) {
     // Opus introduces a tiny delay before the sinewave starts; so don't examine
     // the first frame.
     const bool examine_audio_data = i > 0;
     FeedAudioFrames(1, examine_audio_data);
     RunTasks(kAudioFrameDurationMs);
     RequestAudioFrames(1, examine_audio_data);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(kNumIterations,
             test_receiver_audio_callback_->number_times_called());
 }
 
 // This tests start sending audio and video at start-up time before the receiver
 // is ready; it sends 2 frames before the receiver comes online.
 //
 // Test disabled due to flakiness: It appears that the RTCP synchronization
 // sometimes kicks in, and sometimes doesn't.  When it does, there's a sharp
 // discontinuity in the timeline, throwing off the test expectations.  See TODOs
 // in audio_receiver.cc for likely cause(s) of this bug.
 // http://crbug.com/356942
 TEST_F(End2EndTest, DISABLED_StartSenderBeforeReceiver) {
-  Configure(transport::CODEC_VIDEO_VP8, transport::CODEC_AUDIO_PCM16,
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16,
             kDefaultAudioSamplingRate, 1);
   Create();
 
   int video_start = kVideoStart;
   int audio_diff = kFrameTimerMs;
 
   sender_to_receiver_.SetSendPackets(false);
 
   const int test_delay_ms = 100;
 
@@ skipping 68 matching lines @@
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(num_audio_frames_requested,
             test_receiver_audio_callback_->number_times_called());
   EXPECT_EQ(10, test_receiver_video_callback_->number_times_called());
 }
 
 // This tests a network glitch lasting for 10 video frames.
 // Flaky. See crbug.com/351596.
 TEST_F(End2EndTest, DISABLED_GlitchWith3Buffers) {
-  Configure(transport::CODEC_VIDEO_VP8, transport::CODEC_AUDIO_OPUS,
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_OPUS,
             kDefaultAudioSamplingRate, 3);
   video_sender_config_.target_playout_delay =
       base::TimeDelta::FromMilliseconds(67);
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
 
   int video_start = kVideoStart;
   base::TimeTicks capture_time;
   // Frames will rendered on completion until the render time stabilizes, i.e.
   // we got enough data.
@@ skipping 44 matching lines @@
       base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                  test_receiver_video_callback_));
 
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(frames_before_glitch + 1,
             test_receiver_video_callback_->number_times_called());
 }
 
 // Disabled due to flakiness and crashiness.  http://crbug.com/360951
 TEST_F(End2EndTest, DISABLED_DropEveryOtherFrame3Buffers) {
-  Configure(transport::CODEC_VIDEO_VP8, transport::CODEC_AUDIO_OPUS,
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_OPUS,
             kDefaultAudioSamplingRate, 3);
   video_sender_config_.target_playout_delay =
       base::TimeDelta::FromMilliseconds(67);
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
   sender_to_receiver_.DropAllPacketsBelongingToOddFrames();
 
   int video_start = kVideoStart;
   base::TimeTicks capture_time;
 
@@ skipping 19 matching lines @@
     }
     RunTasks(kFrameTimerMs);
     video_start++;
   }
 
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(i / 2, test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoVideo) {
-  Configure(transport::CODEC_VIDEO_VP8, transport::CODEC_AUDIO_PCM16, 32000, 1);
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1);
 
   video_sender_config_.aes_iv_mask =
       ConvertFromBase16String("1234567890abcdeffedcba0987654321");
   video_sender_config_.aes_key =
       ConvertFromBase16String("deadbeefcafeb0b0b0b0cafedeadbeef");
 
   video_receiver_config_.aes_iv_mask =
       video_sender_config_.aes_iv_mask;
   video_receiver_config_.aes_key =
       video_sender_config_.aes_key;
@@ skipping 17 matching lines @@
     cast_receiver_->RequestDecodedVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(frames_counter,
             test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoAudio) {
-  Configure(transport::CODEC_VIDEO_VP8, transport::CODEC_AUDIO_PCM16, 32000, 1);
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1);
 
   audio_sender_config_.aes_iv_mask =
       ConvertFromBase16String("abcdeffedcba12345678900987654321");
   audio_sender_config_.aes_key =
       ConvertFromBase16String("deadbeefcafecafedeadbeefb0b0b0b0");
 
   audio_receiver_config_.aes_iv_mask =
       audio_sender_config_.aes_iv_mask;
   audio_receiver_config_.aes_key =
       audio_sender_config_.aes_key;
 
   Create();
 
   const int kNumIterations = 3;
   const int kNumAudioFramesPerIteration = 2;
   for (int i = 0; i < kNumIterations; ++i) {
     FeedAudioFrames(kNumAudioFramesPerIteration, true);
     RunTasks(kNumAudioFramesPerIteration * kAudioFrameDurationMs);
     RequestAudioFrames(kNumAudioFramesPerIteration, true);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(kNumIterations * kNumAudioFramesPerIteration,
             test_receiver_audio_callback_->number_times_called());
 }
 
 // Video test without packet loss - tests the logging aspects of the end2end,
 // but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, VideoLogging) {
-  Configure(transport::CODEC_VIDEO_VP8, transport::CODEC_AUDIO_PCM16, 32000, 1);
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1);
   Create();
 
   int video_start = kVideoStart;
   const int num_frames = 5;
   for (int i = 0; i < num_frames; ++i) {
     base::TimeTicks capture_time = testing_clock_sender_->NowTicks();
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
         video_sender_config_.width,
         video_sender_config_.height,
@@ skipping 103 matching lines @@
 
     // Verify that there were no other events logged with respect to this
     // packet. (i.e. Total event count = expected event count)
     EXPECT_EQ(total_event_count_for_packet, expected_event_count_for_packet);
   }
 }
 
 // Audio test without packet loss - tests the logging aspects of the end2end,
 // but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, AudioLogging) {
-  Configure(transport::CODEC_VIDEO_VP8, transport::CODEC_AUDIO_PCM16, 32000, 1);
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1);
   Create();
 
   int audio_diff = kFrameTimerMs;
   const int kNumVideoFrames = 10;
   int num_audio_frames_requested = 0;
   for (int i = 0; i < kNumVideoFrames; ++i) {
     const int num_audio_frames = audio_diff / kAudioFrameDurationMs;
     audio_diff -= num_audio_frames * kAudioFrameDurationMs;
 
     FeedAudioFrames(num_audio_frames, true);
@@ skipping 60 matching lines @@
     expected_event_count_for_frame +=
         map_it->second.counter[FRAME_ACK_RECEIVED];
 
     // Verify that there were no other events logged with respect to this frame.
     // (i.e. Total event count = expected event count)
     EXPECT_EQ(total_event_count_for_frame, expected_event_count_for_frame);
   }
 }
 
 TEST_F(End2EndTest, BasicFakeSoftwareVideo) {
-  Configure(transport::CODEC_VIDEO_FAKE, transport::CODEC_AUDIO_PCM16, 32000,
+  Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000,
             1);
   Create();
   StartBasicPlayer();
   SetReceiverSkew(1.0, base::TimeDelta::FromMilliseconds(1));
 
   // Expect very smooth playout when there is no clock skew.
   SetExpectedVideoPlayoutSmoothness(
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 99 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 101 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) / 100);
 
   int frames_counter = 0;
   for (; frames_counter < 1000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(1000ul, video_ticks_.size());
 }
 
 TEST_F(End2EndTest, ReceiverClockFast) {
-  Configure(transport::CODEC_VIDEO_FAKE, transport::CODEC_AUDIO_PCM16, 32000,
+  Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000,
             1);
   Create();
   StartBasicPlayer();
   SetReceiverSkew(2.0, base::TimeDelta::FromMicroseconds(1234567));
 
   int frames_counter = 0;
   for (; frames_counter < 10000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(10000ul, video_ticks_.size());
 }
 
 TEST_F(End2EndTest, ReceiverClockSlow) {
-  Configure(transport::CODEC_VIDEO_FAKE, transport::CODEC_AUDIO_PCM16, 32000,
+  Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000,
             1);
   Create();
   StartBasicPlayer();
   SetReceiverSkew(0.5, base::TimeDelta::FromMicroseconds(-765432));
 
   int frames_counter = 0;
   for (; frames_counter < 10000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(10000ul, video_ticks_.size());
 }
 
 TEST_F(End2EndTest, SmoothPlayoutWithFivePercentClockRateSkew) {
-  Configure(transport::CODEC_VIDEO_FAKE, transport::CODEC_AUDIO_PCM16, 32000,
+  Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000,
             1);
   Create();
   StartBasicPlayer();
   SetReceiverSkew(1.05, base::TimeDelta::FromMilliseconds(-42));
 
   // Expect smooth playout when there is 5% skew.
   SetExpectedVideoPlayoutSmoothness(
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 90 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 110 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) / 10);
 
   int frames_counter = 0;
   for (; frames_counter < 10000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(10000ul, video_ticks_.size());
 }
 
 TEST_F(End2EndTest, EvilNetwork) {
-  Configure(transport::CODEC_VIDEO_FAKE, transport::CODEC_AUDIO_PCM16, 32000,
+  Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000,
             1);
   receiver_to_sender_.SetPacketPipe(test::EvilNetwork().Pass());
   sender_to_receiver_.SetPacketPipe(test::EvilNetwork().Pass());
   Create();
   StartBasicPlayer();
 
   int frames_counter = 0;
   for (; frames_counter < 10000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   base::TimeTicks test_end = testing_clock_receiver_->NowTicks();
   RunTasks(100 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_GT(video_ticks_.size(), 100ul);
   EXPECT_LT((video_ticks_.back().second - test_end).InMilliseconds(), 1000);
 }
 
 // TODO(pwestin): Add repeatable packet loss test.
 // TODO(pwestin): Add test for misaligned send get calls.
 // TODO(pwestin): Add more tests that does not resample.
 // TODO(pwestin): Add test when we have starvation for our RunTask.
 
 }  // namespace cast
 }  // namespace media