[Cast] Clean-up: Merge RtpReceiver+AudioReceiver+VideoReceiver-->FrameReceiver.

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 548 matching lines @@
       test_receiver_audio_callback_->AddExpectedResult(
           *audio_bus,
           capture_time + delay +
               base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs));
       audio_frame_input_->InsertAudio(audio_bus.Pass(), capture_time);
     }
   }
 
   void RequestAudioFrames(int count, bool with_check) {
     for (int i = 0; i < count; ++i) {
-      frame_receiver_->GetRawAudioFrame(
+      cast_receiver_->RequestDecodedAudioFrame(
           base::Bind(with_check ? &TestReceiverAudioCallback::CheckAudioFrame :
                                   &TestReceiverAudioCallback::IgnoreAudioFrame,
                      test_receiver_audio_callback_));
     }
   }
 
   void Create() {
     cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
                                           audio_receiver_config_,
                                           video_receiver_config_,
@@ skipping 24 matching lines @@
     receiver_to_sender_.SetPacketReceiver(cast_sender_->packet_receiver(),
                                           task_runner_,
                                           &testing_clock_);
     sender_to_receiver_.SetPacketReceiver(cast_receiver_->packet_receiver(),
                                           task_runner_,
                                           &testing_clock_);
 
     audio_frame_input_ = cast_sender_->audio_frame_input();
     video_frame_input_ = cast_sender_->video_frame_input();
 
-    frame_receiver_ = cast_receiver_->frame_receiver();
-
     audio_bus_factory_.reset(
         new TestAudioBusFactory(audio_sender_config_.channels,
                                 audio_sender_config_.frequency,
                                 kSoundFrequency,
                                 kSoundVolume));
   }
 
   virtual ~End2EndTest() {
     cast_environment_sender_->Logging()->RemoveRawEventSubscriber(
         &event_subscriber_sender_);
@@ skipping 51 matching lines @@
         EXPECT_GE(max_video_playout_curvature_.InMicroseconds(),
                   abs_curvature.InMicroseconds());
       }
       last_video_playout_delta_ = delta;
     }
     last_video_playout_time_ = playout_time;
 
     video_ticks_.push_back(std::make_pair(
         testing_clock_receiver_->NowTicks(),
         playout_time));
-    frame_receiver_->GetRawVideoFrame(
+    cast_receiver_->RequestDecodedVideoFrame(
         base::Bind(&End2EndTest::BasicPlayerGotVideoFrame,
                    base::Unretained(this)));
   }
 
   void BasicPlayerGotAudioFrame(scoped_ptr<AudioBus> audio_bus,
                                 const base::TimeTicks& playout_time,
                                 bool is_continuous) {
     VLOG_IF(1, !last_audio_playout_time_.is_null())
         << "Audio frame playout time delta (compared to last frame) is "
         << (playout_time - last_audio_playout_time_).InMicroseconds()
         << " usec.";
     last_audio_playout_time_ = playout_time;
 
     audio_ticks_.push_back(std::make_pair(
         testing_clock_receiver_->NowTicks(),
         playout_time));
-    frame_receiver_->GetRawAudioFrame(
+    cast_receiver_->RequestDecodedAudioFrame(
         base::Bind(&End2EndTest::BasicPlayerGotAudioFrame,
                    base::Unretained(this)));
   }
 
   void StartBasicPlayer() {
-    frame_receiver_->GetRawVideoFrame(
+    cast_receiver_->RequestDecodedVideoFrame(
         base::Bind(&End2EndTest::BasicPlayerGotVideoFrame,
                    base::Unretained(this)));
-    frame_receiver_->GetRawAudioFrame(
+    cast_receiver_->RequestDecodedAudioFrame(
         base::Bind(&End2EndTest::BasicPlayerGotAudioFrame,
                    base::Unretained(this)));
   }
 
   void LogRawEvents(const std::vector<PacketEvent>& packet_events) {
     EXPECT_FALSE(packet_events.empty());
     for (std::vector<media::cast::PacketEvent>::const_iterator it =
              packet_events.begin();
          it != packet_events.end();
          ++it) {
@@ skipping 37 matching lines @@
   scoped_refptr<CastEnvironment> cast_environment_receiver_;
 
   LoopBackTransport receiver_to_sender_;
   LoopBackTransport sender_to_receiver_;
   scoped_ptr<transport::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<FrameReceiver> frame_receiver_;
 
   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_;
@@ skipping 31 matching lines @@
     SendVideoFrame(video_start, testing_clock_sender_->NowTicks());
 
     if (num_audio_frames > 0)
       RunTasks(kAudioFrameDurationMs);  // Advance clock forward.
     if (num_audio_frames > 1)
       FeedAudioFrames(num_audio_frames - 1, true);
 
     RequestAudioFrames(num_audio_frames, true);
     num_audio_frames_requested += num_audio_frames;
 
-    frame_receiver_->GetRawVideoFrame(
+    cast_receiver_->RequestDecodedVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
 
     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(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::kVp8, transport::kPcm16, 32000, 1);
   Create();
 
   const int kNumIterations = 10;
   for (int i = 0; i < kNumIterations; ++i) {
     FeedAudioFrames(1, true);
     RunTasks(kAudioFrameDurationMs);
-    frame_receiver_->GetCodedAudioFrame(
+    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) {
@@ skipping 87 matching lines @@
     SendVideoFrame(video_start, testing_clock_sender_->NowTicks());
 
     if (num_audio_frames > 0)
       RunTasks(kAudioFrameDurationMs);  // Advance clock forward.
     if (num_audio_frames > 1)
       FeedAudioFrames(num_audio_frames - 1, true);
 
     RequestAudioFrames(num_audio_frames, true);
     num_audio_frames_requested += num_audio_frames;
 
-    frame_receiver_->GetRawVideoFrame(
+    cast_receiver_->RequestDecodedVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
 
     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());
@@ skipping 15 matching lines @@
   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);
-    frame_receiver_->GetRawVideoFrame(
+    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();
@@ skipping 12 matching lines @@
 
   // 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);
 
-  frame_receiver_->GetRawVideoFrame(
+  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) {
@@ skipping 15 matching lines @@
       test_receiver_video_callback_->AddExpectedResult(
           video_start,
           video_sender_config_.width,
           video_sender_config_.height,
           capture_time +
               base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
           i == 0);
 
       // GetRawVideoFrame will not return the frame until we are close in
       // time before we should render the frame.
-      frame_receiver_->GetRawVideoFrame(
+      cast_receiver_->RequestDecodedVideoFrame(
           base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                      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());
 }
@@ skipping 20 matching lines @@
 
     test_receiver_video_callback_->AddExpectedResult(
         frames_counter,
         video_sender_config_.width,
         video_sender_config_.height,
         capture_time + base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
         true);
 
     RunTasks(kFrameTimerMs);
 
-    frame_receiver_->GetRawVideoFrame(
+    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::kVp8, transport::kPcm16, 32000, 1);
@@ skipping 35 matching lines @@
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
         video_sender_config_.width,
         video_sender_config_.height,
         capture_time + base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
         true);
 
     SendVideoFrame(video_start, capture_time);
     RunTasks(kFrameTimerMs);
 
-    frame_receiver_->GetRawVideoFrame(
+    cast_receiver_->RequestDecodedVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
 
     video_start++;
   }
 
   // Basic tests.
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   int num_callbacks_called =
       test_receiver_video_callback_->number_times_called();
@@ skipping 260 matching lines @@
   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