Revert 243647 "Cast:Adding cast_transport_config and cleaning up"

trunk/src/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 55 matching lines @@
 class LoopBackTransport : public PacketSender {
  public:
   explicit LoopBackTransport(scoped_refptr<CastEnvironment> cast_environment)
       : packet_receiver_(NULL),
         send_packets_(true),
         drop_packets_belonging_to_odd_frames_(false),
         reset_reference_frame_id_(false),
         cast_environment_(cast_environment) {
   }
 
-  void RegisterPacketReceiver(transport::PacketReceiver* packet_receiver) {
+  void RegisterPacketReceiver(PacketReceiver* packet_receiver) {
     DCHECK(packet_receiver);
     packet_receiver_ = packet_receiver;
   }
 
   virtual bool SendPacket(const Packet& packet) OVERRIDE {
     DCHECK(packet_receiver_);
     DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
     if (!send_packets_) return false;
 
     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;
   }
 
   virtual bool SendPackets(const PacketList& packets) OVERRIDE {
     DCHECK(packet_receiver_);
     DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
     if (!send_packets_) return false;
 
     for (size_t i = 0; i < packets.size(); ++i) {
       const Packet& packet = packets[i];
       if (drop_packets_belonging_to_odd_frames_) {
         uint32 frame_id = packet[13];
         if (frame_id % 2 == 1) continue;
       }
       uint8* packet_copy = new uint8[packet.size()];
       memcpy(packet_copy, packet.data(), packet.size());
       if (reset_reference_frame_id_) {
         // Reset the is_reference bit in the cast header.
         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;
   }
 
   void SetSendPackets(bool send_packets) {
     send_packets_ = send_packets;
   }
 
   void DropAllPacketsBelongingToOddFrames() {
     drop_packets_belonging_to_odd_frames_ = true;
   }
 
   void AlwaysResetReferenceFrameId() {
     reset_reference_frame_id_ = true;
   }
 
  private:
-  transport::PacketReceiver* packet_receiver_;
+  PacketReceiver* packet_receiver_;
   bool send_packets_;
   bool drop_packets_belonging_to_odd_frames_;
   bool reset_reference_frame_id_;
   scoped_refptr<CastEnvironment> cast_environment_;
 };
 
 // Class that verifies the audio frames coming out of the receiver.
 class TestReceiverAudioCallback :
      public base::RefCountedThreadSafe<TestReceiverAudioCallback>  {
  public:
@@ skipping 56 matching lines @@
     CheckBasicAudioFrame(audio_frame, playout_time);
     ExpectedAudioFrame expected_audio_frame = expected_frame_.front();
     expected_frame_.pop_front();
     if (audio_frame->samples.size() == 0) return;  // No more checks needed.
 
     EXPECT_NEAR(CountZeroCrossings(expected_audio_frame.audio_frame.samples),
                 CountZeroCrossings(audio_frame->samples),
                 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.
     ExpectedAudioFrame expected_audio_frame = expected_frame_.front();
     expected_frame_.pop_front();
 
     EXPECT_EQ(static_cast<int>(audio_frame->data.size()),
         2 * kAudioChannels * expected_sampling_frequency_ / 100);
 
     base::TimeDelta time_since_recording =
@@ skipping 109 matching lines @@
   return config;
 }
 // The actual test class, generate synthetic data for both audio and video and
 // send those through the sender and receiver and analyzes the result.
 class End2EndTest : public ::testing::Test {
  protected:
   End2EndTest()
       : 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_),
         test_receiver_audio_callback_(new TestReceiverAudioCallback()),
         test_receiver_video_callback_(new TestReceiverVideoCallback()) {
     testing_clock_.Advance(
         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,
                    int max_number_of_video_buffers_used) {
     audio_sender_config_.sender_ssrc = 1;
     audio_sender_config_.incoming_feedback_ssrc = 2;
     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 21 matching lines @@
     video_sender_config_.width = kVideoWidth;
     video_sender_config_.height = kVideoHeight;
     video_sender_config_.max_bitrate = 5000000;
     video_sender_config_.min_bitrate = 1000000;
     video_sender_config_.start_bitrate = 5000000;
     video_sender_config_.max_qp = 30;
     video_sender_config_.min_qp = 4;
     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 =
         video_sender_config_.incoming_feedback_ssrc;
     video_receiver_config_.incoming_ssrc =
         video_sender_config_.sender_ssrc;
     video_receiver_config_.rtp_payload_type =
         video_sender_config_.rtp_payload_type;
     video_receiver_config_.use_external_decoder = false;
     video_receiver_config_.codec = video_sender_config_.codec;
@@ skipping 66 matching lines @@
 
   scoped_refptr<TestReceiverAudioCallback> test_receiver_audio_callback_;
   scoped_refptr<TestReceiverVideoCallback> test_receiver_video_callback_;
 
   scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
 };
 
 // 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;
   int audio_diff = kFrameTimerMs;
   int i = 0;
 
   std::cout << "Progress ";
   for (; i < 10; ++i) {
     int num_10ms_blocks = audio_diff / 10;
     audio_diff -= num_10ms_blocks * 10;
@@ skipping 52 matching lines @@
 // TODO(mikhal): Crashes on the Win7 x64 bots. Re-enable.
 // http://crbug.com/329563
 #if defined(OS_WIN)
 #define MAYBE_LoopNoLossPcm16ExternalDecoder DISABLED_LoopNoLossPcm16ExternalDecoder
 #else
 #define MAYBE_LoopNoLossPcm16ExternalDecoder LoopNoLossPcm16ExternalDecoder
 #endif
 // 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;
   for (; i < 10; ++i) {
     base::TimeTicks send_time = testing_clock_.NowTicks();
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10)));
     test_receiver_audio_callback_->AddExpectedResult(
         ToPcmAudioFrame(*audio_bus, audio_sender_config_.frequency),
         1, send_time);
@@ skipping 12 matching lines @@
 }
 
 // TODO(mikhal): Crashes on the bots. Re-enable. http://crbug.com/329563
 #if defined(OS_WIN)
 #define MAYBE_LoopNoLossOpus DISABLED_LoopNoLossOpus
 #else
 #define MAYBE_LoopNoLossOpus LoopNoLossOpus
 #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;
   for (; i < 10; ++i) {
     int num_10ms_blocks = 3;
     base::TimeTicks send_time = testing_clock_.NowTicks();
 
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
 
@@ skipping 23 matching lines @@
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(i - 1, test_receiver_audio_callback_->number_times_called());
 }
 
 // This tests start sending audio and video before the receiver is ready.
 //
 // 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;
   int audio_diff = kFrameTimerMs;
 
   sender_to_receiver_.SetSendPackets(false);
 
   for (int i = 0; i < 3; ++i) {
     int num_10ms_blocks = audio_diff / 10;
     audio_diff -= num_10ms_blocks * 10;
@@ skipping 58 matching lines @@
     video_start++;
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(j - number_of_audio_frames_to_ignore,
             test_receiver_audio_callback_->number_times_called());
   EXPECT_EQ(j, test_receiver_video_callback_->number_times_called());
 }
 
 // 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();
 
   int video_start = 50;
   base::TimeTicks send_time = testing_clock_.NowTicks();
   SendVideoFrame(video_start, send_time);
   RunTasks(kFrameTimerMs);
 
   test_receiver_video_callback_->AddExpectedResult(video_start,
@@ skipping 28 matching lines @@
 
   frame_receiver_->GetRawVideoFrame(
       base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
           test_receiver_video_callback_));
 
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(2, test_receiver_video_callback_->number_times_called());
 }
 
 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();
   sender_to_receiver_.DropAllPacketsBelongingToOddFrames();
 
   int video_start = 50;
   base::TimeTicks send_time;
 
   std::cout << "Progress ";
   int i = 0;
@@ skipping 14 matching lines @@
     RunTasks(kFrameTimerMs);
     std::cout << " " << i << std::flush;
     video_start++;
   }
   std::cout << std::endl;
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(i / 2, test_receiver_video_callback_->number_times_called());
 }
 
 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();
   sender_to_receiver_.AlwaysResetReferenceFrameId();
 
   int frames_counter = 0;
   for (; frames_counter < 20; ++frames_counter) {
     const base::TimeTicks send_time = testing_clock_.NowTicks();
     SendVideoFrame(frames_counter, send_time);
 
     test_receiver_video_callback_->AddExpectedResult(frames_counter,
         video_sender_config_.width, video_sender_config_.height, send_time);
 
     // GetRawVideoFrame will not return the frame until we are close to the
     // time in which we should render the frame.
     frame_receiver_->GetRawVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(frames_counter,
             test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoVideo) {
-  SetupConfig(transport::kPcm16, 32000, false, 1);
+  SetupConfig(kPcm16, 32000, false, 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;
 
   Create();
@@ skipping 19 matching lines @@
             test_receiver_video_callback_->number_times_called());
 }
 
 // TODO(mikhal): Crashes on the bots. Re-enable. http://crbug.com/329563
 #if defined(OS_WIN)
 #define MAYBE_CryptoAudio DISABLED_CryptoAudio
 #else
 #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");
   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();
@@ skipping 34 matching lines @@
     }
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(frames_counter - 1,
             test_receiver_audio_callback_->number_times_called());
 }
 
 // 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;
   int i = 0;
   for (; i < 1; ++i) {
     base::TimeTicks send_time = testing_clock_.NowTicks();
     test_receiver_video_callback_->AddExpectedResult(video_start,
         video_sender_config_.width, video_sender_config_.height, send_time);
 
     SendVideoFrame(video_start, send_time);
@@ skipping 37 matching lines @@
 
   // Packet logging.
   // Verify that all packet related events were logged.
   PacketRawMap packet_raw_log = logging->GetPacketRawData();
   // Every rtp_timestamp should have only one entry.
   EXPECT_EQ(static_cast<unsigned int>(i), packet_raw_log.size());
   PacketRawMap::const_iterator packet_it = packet_raw_log.begin();
   // 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
 #if defined(OS_WIN)
 #define MAYBE_AudioLogging DISABLED_AudioLogging
 #else
 #define MAYBE_AudioLogging AudioLogging
 #endif
 // 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;
   int i = 0;
 
   for (; i < 10; ++i) {
     int num_10ms_blocks = audio_diff / 10;
     audio_diff -= num_10ms_blocks * 10;
     base::TimeTicks send_time = testing_clock_.NowTicks();
 
@@ skipping 59 matching lines @@
 }
 
 
 // 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