Cast: Make vp8 3-buffer mode work

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 192 matching lines @@
     } else {
       packet_pipe_ = loopback_pipe.Pass();
     }
     packet_pipe_->InitOnIOThread(task_runner, clock);
   }
 
   virtual bool SendPacket(PacketRef packet,
                           const base::Closure& cb) OVERRIDE {
     DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
     if (!send_packets_)
-      return false;
+      return true;
 
     bytes_sent_ += packet->data.size();
     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));
     packet_pipe_->Send(packet_copy.Pass());
@@ skipping 175 matching lines @@
     EXPECT_EQ(expected_video_frame.height,
               video_frame->visible_rect().height());
 
     gfx::Size size(expected_video_frame.width, expected_video_frame.height);
     scoped_refptr<media::VideoFrame> expected_I420_frame =
         media::VideoFrame::CreateFrame(
             VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta());
     PopulateVideoFrame(expected_I420_frame.get(),
                        expected_video_frame.start_value);
 
-    EXPECT_GE(I420PSNR(expected_I420_frame, video_frame), kVideoAcceptedPSNR);
+    if (expected_video_frame.should_be_continuous) {
+      EXPECT_GE(I420PSNR(expected_I420_frame, video_frame), kVideoAcceptedPSNR);
+    }
 
     EXPECT_NEAR(
         (playout_time - expected_video_frame.playout_time).InMillisecondsF(),
         0.0,
         kMaxAllowedPlayoutErrorMs);
     VLOG_IF(1, !last_playout_time_.is_null())
         << "Video frame playout time delta (compared to last frame) is "
         << (playout_time - last_playout_time_).InMicroseconds() << " usec.";
     last_playout_time_ = playout_time;
 
@@ skipping 561 matching lines @@
     RunTasks(kFrameTimerMs - kAudioFrameDurationMs);
     audio_diff += kFrameTimerMs;
     video_start++;
   }
   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(CODEC_VIDEO_VP8, CODEC_AUDIO_OPUS,
-            kDefaultAudioSamplingRate, 3);
+TEST_F(End2EndTest, DropEveryOtherFrame3Buffers) {
+  Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_OPUS, kDefaultAudioSamplingRate, 3);
+  int target_delay = 300;
   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.
-  const int frames_before_glitch = 20;
-  for (int i = 0; i < frames_before_glitch; ++i) {
-    capture_time = testing_clock_sender_->NowTicks();
-    SendVideoFrame(video_start, capture_time);
-    test_receiver_video_callback_->AddExpectedResult(
-        video_start,
-        video_sender_config_.width,
-        video_sender_config_.height,
-        capture_time + base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
-        true);
-    cast_receiver_->RequestDecodedVideoFrame(
-        base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
-                   test_receiver_video_callback_));
-    RunTasks(kFrameTimerMs);
-    video_start++;
-  }
-
-  // Introduce a glitch lasting for 10 frames.
-  sender_to_receiver_.SetSendPackets(false);
-  for (int i = 0; i < 10; ++i) {
-    capture_time = testing_clock_sender_->NowTicks();
-    // First 3 will be sent and lost.
-    SendVideoFrame(video_start, capture_time);
-    RunTasks(kFrameTimerMs);
-    video_start++;
-  }
-  sender_to_receiver_.SetSendPackets(true);
-  RunTasks(100);
-  capture_time = testing_clock_sender_->NowTicks();
-
-  // Frame 1 should be acked by now and we should have an opening to send 4.
-  SendVideoFrame(video_start, capture_time);
-  RunTasks(kFrameTimerMs);
-
-  // Frames 1-3 are old frames by now, and therefore should be decoded, but
-  // not rendered. The next frame we expect to render is frame #4.
-  test_receiver_video_callback_->AddExpectedResult(
-      video_start,
-      video_sender_config_.width,
-      video_sender_config_.height,
-      capture_time + base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
-      true);
-
-  cast_receiver_->RequestDecodedVideoFrame(
-      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(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;
+      base::TimeDelta::FromMilliseconds(target_delay);
+  video_receiver_config_.rtp_max_delay_ms = target_delay;
   Create();
   sender_to_receiver_.DropAllPacketsBelongingToOddFrames();
 
   int video_start = kVideoStart;
   base::TimeTicks capture_time;
 
   int i = 0;
   for (; i < 20; ++i) {
     capture_time = testing_clock_sender_->NowTicks();
     SendVideoFrame(video_start, capture_time);
 
     if (i % 2 == 0) {
       test_receiver_video_callback_->AddExpectedResult(
           video_start,
           video_sender_config_.width,
           video_sender_config_.height,
           capture_time +
-              base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
+              base::TimeDelta::FromMilliseconds(target_delay),
           i == 0);
 
       // GetRawVideoFrame will not return the frame until we are close in
       // time before we should render the frame.
       cast_receiver_->RequestDecodedVideoFrame(
           base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                      test_receiver_video_callback_));
     }
     RunTasks(kFrameTimerMs);
     video_start++;
   }
 
-  RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
+  RunTasks(2 * kFrameTimerMs + target_delay);  // Empty the pipeline.
   EXPECT_EQ(i / 2, test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoVideo) {
   Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1);
 
   video_sender_config_.aes_iv_mask =
       ConvertFromBase16String("1234567890abcdeffedcba0987654321");
   video_sender_config_.aes_key =
       ConvertFromBase16String("deadbeefcafeb0b0b0b0cafedeadbeef");
@@ skipping 422 matching lines @@
   EXPECT_LT(jump, 220u);
 }
 
 // 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