[Cast] Clean-up RtpCastHeader and RtpParser, removing the last WebRTC dependency.

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 36 matching lines @@
 namespace {
 
 static const int64 kStartMillisecond = INT64_C(1245);
 static const int kAudioChannels = 2;
 static const double kSoundFrequency = 314.15926535897;  // Freq of sine wave.
 static const float kSoundVolume = 0.5f;
 static const int kVideoHdWidth = 1280;
 static const int kVideoHdHeight = 720;
 static const int kVideoQcifWidth = 176;
 static const int kVideoQcifHeight = 144;
-static const int kCommonRtpHeaderLength = 12;
-static const uint8 kCastReferenceFrameIdBitReset = 0xDF;  // Mask is 0x40.
 
 // Since the video encoded and decoded an error will be introduced; when
 // comparing individual pixels the error can be quite large; we allow a PSNR of
 // at least |kVideoAcceptedPSNR|.
 static const double kVideoAcceptedPSNR = 38.0;
 
 // The tests are commonly implemented with |kFrameTimerMs| RunTask function;
 // a normal video is 30 fps hence the 33 ms between frames.
 static const int kFrameTimerMs = 33;
 
@@ skipping 115 matching lines @@
   transport::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 {
  public:
   explicit LoopBackTransport(scoped_refptr<CastEnvironment> cast_environment)
       : send_packets_(true),
         drop_packets_belonging_to_odd_frames_(false),
-        reset_reference_frame_id_(false),
         cast_environment_(cast_environment) {}
 
   void SetPacketReceiver(
       const transport::PacketReceiverCallback& packet_receiver) {
     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();
     }
   }
 
   virtual bool SendPacket(transport::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;
     }
 
     scoped_ptr<Packet> packet_copy(new Packet(packet->data));
-    if (reset_reference_frame_id_) {
-      // Reset the is_reference bit in the cast header.
-      (*packet_copy)[kCommonRtpHeaderLength] &= kCastReferenceFrameIdBitReset;
-    }
     packet_pipe_->Send(packet_copy.Pass());
     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; }
-
   void SetPacketPipe(scoped_ptr<test::PacketPipe> pipe) {
     // Append the loopback pipe to the end.
     pipe->AppendToPipe(packet_pipe_.Pass());
     packet_pipe_ = pipe.Pass();
   }
 
  private:
   bool send_packets_;
   bool drop_packets_belonging_to_odd_frames_;
-  bool reset_reference_frame_id_;
   scoped_refptr<CastEnvironment> cast_environment_;
   scoped_ptr<test::PacketPipe> packet_pipe_;
 };
 
 // Class that verifies the audio frames coming out of the receiver.
 class TestReceiverAudioCallback
     : public base::RefCountedThreadSafe<TestReceiverAudioCallback> {
  public:
   struct ExpectedAudioFrame {
     scoped_ptr<AudioBus> audio_bus;
@@ skipping 725 matching lines @@
                      test_receiver_video_callback_));
     }
     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, ResetReferenceFrameId) {

[miu, 2014/04/23 23:41:58]

I removed this test because it's not a good test: Not only does it violate the
abstraction layers in the code, but it's not functionally correct (it ignores
the fact that clearing the "reference frame id bit" reduces the size of the Cast
header in the packet by one byte).

-  Configure(transport::kVp8, transport::kOpus, kDefaultAudioSamplingRate,
-            false, 3);
-  video_sender_config_.rtp_config.max_delay_ms = 67;
-  video_receiver_config_.rtp_max_delay_ms = 67;
-  Create();
-  sender_to_receiver_.AlwaysResetReferenceFrameId();
-
-  int frames_counter = 0;
-  for (; frames_counter < 10; ++frames_counter) {
-    const base::TimeTicks send_time = testing_clock_sender_->NowTicks();
-    SendVideoFrame(frames_counter, send_time);
-
-    test_receiver_video_callback_->AddExpectedResult(
-        frames_counter,
-        video_sender_config_.width,
-        video_sender_config_.height,
-        send_time,
-        true);
-
-    // 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) {
   Configure(transport::kVp8, transport::kPcm16, 32000, false, 1);
 
   transport_video_config_.base.aes_iv_mask =
       ConvertFromBase16String("1234567890abcdeffedcba0987654321");
   transport_video_config_.base.aes_key =
       ConvertFromBase16String("deadbeefcafeb0b0b0b0cafedeadbeef");
 
   video_receiver_config_.aes_iv_mask = transport_video_config_.base.aes_iv_mask;
   video_receiver_config_.aes_key = transport_video_config_.base.aes_key;
@@ skipping 219 matching lines @@
            event_counter_for_frame.begin();
        it != event_counter_for_frame.end();
        ++it) {
     received_count += it->second.counter[kAudioFrameReceived];
     encoded_count += it->second.counter[kAudioFrameEncoded];
   }
 
   EXPECT_EQ(num_audio_frames_requested, received_count);
   EXPECT_EQ(num_audio_frames_requested, encoded_count);
 
-  std::map<RtpTimestamp, LoggingEventCounts>::iterator map_it =
-      event_counter_for_frame.begin();
+  // Verify that each frame have the expected types of events logged.
+  for (std::map<RtpTimestamp, LoggingEventCounts>::const_iterator map_it =
+           event_counter_for_frame.begin();
+       map_it != event_counter_for_frame.end(); ++map_it) {
+    int total_event_count_for_frame = 0;
+    for (int j = 0; j < kNumOfLoggingEvents; ++j)
+      total_event_count_for_frame += map_it->second.counter[j];
 
-  // Verify that each frame have the expected types of events logged.

[miu, 2014/04/23 23:41:58]

imcheng: Looks like this isn't broken anymore.  In any case, the tests pass when
I iterate over the entire map now.  :)

-  // TODO(imcheng): This only checks the first frame. This doesn't work
-  // properly for all frames because:
-  // 1. kAudioPlayoutDelay and kAudioFrameDecoded RTP timestamps aren't
-  // exactly aligned with those of kAudioFrameReceived and kAudioFrameEncoded.
-  // Note that these RTP timestamps are output from webrtc::AudioCodingModule
-  // which are different from RTP timestamps that the cast library generates
-  // during the encode step (and which are sent to receiver). The first frame
-  // just happen to be aligned.
-  // 2. Currently, kAudioFrameDecoded and kAudioPlayoutDelay are logged per
-  // audio bus.
-  // Both 1 and 2 may change since we are currently refactoring audio_decoder.
-  // 3. There is no guarantee that exactly one kAudioAckSent is sent per frame.
-  int total_event_count_for_frame = 0;
-  for (int j = 0; j < kNumOfLoggingEvents; ++j)
-    total_event_count_for_frame += map_it->second.counter[j];
+    int expected_event_count_for_frame = 0;
 
-  int expected_event_count_for_frame = 0;
+    EXPECT_EQ(1, map_it->second.counter[kAudioFrameReceived]);
+    expected_event_count_for_frame +=
+        map_it->second.counter[kAudioFrameReceived];
 
-  EXPECT_EQ(1, map_it->second.counter[kAudioFrameReceived]);
-  expected_event_count_for_frame += map_it->second.counter[kAudioFrameReceived];
+    EXPECT_EQ(1, map_it->second.counter[kAudioFrameEncoded]);
+    expected_event_count_for_frame +=
+        map_it->second.counter[kAudioFrameEncoded];
 
-  EXPECT_EQ(1, map_it->second.counter[kAudioFrameEncoded]);
-  expected_event_count_for_frame += map_it->second.counter[kAudioFrameEncoded];
+    EXPECT_EQ(1, map_it->second.counter[kAudioPlayoutDelay]);
+    expected_event_count_for_frame +=
+        map_it->second.counter[kAudioPlayoutDelay];
 
-  EXPECT_EQ(1, map_it->second.counter[kAudioPlayoutDelay]);
-  expected_event_count_for_frame += map_it->second.counter[kAudioPlayoutDelay];
+    EXPECT_EQ(1, map_it->second.counter[kAudioFrameDecoded]);
+    expected_event_count_for_frame +=
+        map_it->second.counter[kAudioFrameDecoded];
 
-  EXPECT_EQ(1, map_it->second.counter[kAudioFrameDecoded]);
-  expected_event_count_for_frame += map_it->second.counter[kAudioFrameDecoded];
+    EXPECT_GT(map_it->second.counter[kAudioAckSent], 0);
+    expected_event_count_for_frame += map_it->second.counter[kAudioAckSent];
 
-  EXPECT_GT(map_it->second.counter[kAudioAckSent], 0);
-  expected_event_count_for_frame += map_it->second.counter[kAudioAckSent];
-
-  // 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);
+    // 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::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
   Create();
 
   int frames_counter = 0;
   int received_counter = 0;
   for (; frames_counter < 1000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     frame_receiver_->GetRawVideoFrame(
         base::Bind(&CountVideoFrame, &received_counter));
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(1000, received_counter);
 }
 
 // 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