Refactor Call-based tests.

Greatly reduces duplication of constants and setup code for tests based
on the new webrtc::Call APIs. It also makes it significantly easier to
convert sender-only to end-to-end tests as they share more code.

BUG=3035
R=kjellander@webrtc.org, stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/17789004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6551 4adac7df-926f-26a2-2b94-8c16560cd09d

tools/valgrind-webrtc/gtest_exclude/video_engine_tests.gtest-drmemory_win32.txt

@@ -1,6 +1,6 @@
 # Never completes on Dr Memory Full.
 # https://code.google.com/p/webrtc/issues/detail?id=3159
-CallTest.SendsAndReceivesMultipleStreams
+EndToEndTest.SendsAndReceivesMultipleStreams
-CallTest.ReceivesAndRetransmitsNack
+EndToEndTest.ReceivesAndRetransmitsNack
 # https://code.google.com/p/webrtc/issues/detail?id=3471
 VideoSendStreamTest.RetransmitsNackOverRtxWithPacing

tools/valgrind-webrtc/gtest_exclude/video_engine_tests.gtest-tsan.txt

@@ -1,2 +0,0 @@
-# https://code.google.com/p/webrtc/issues/detail?id=2908
-CallTest.ReceivesAndRetransmitsNack

webrtc/test/call_test.cc

@@ -0,0 +1,216 @@
+/*
+ *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+#include "webrtc/test/call_test.h"
+
+#include "webrtc/test/encoder_settings.h"
+
+namespace webrtc {
+namespace test {
+
+CallTest::CallTest()
+    : send_stream_(NULL),
+      receive_stream_(NULL),
+      fake_encoder_(Clock::GetRealTimeClock()) {
+}
+CallTest::~CallTest() {
+}
+
+void CallTest::RunBaseTest(BaseTest* test) {
+  CreateSenderCall(test->GetSenderCallConfig());
+  if (test->ShouldCreateReceivers())
+    CreateReceiverCall(test->GetReceiverCallConfig());
+  test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
+
+  if (test->ShouldCreateReceivers()) {
+    test->SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
+  } else {
+    // Sender-only call delivers to itself.
+    test->SetReceivers(sender_call_->Receiver(), NULL);
+  }
+
+  CreateSendConfig(test->GetNumStreams());
+  if (test->ShouldCreateReceivers()) {
+    CreateMatchingReceiveConfigs();
+  }
+  test->ModifyConfigs(&send_config_, &receive_config_, &video_streams_);
+  CreateStreams();
+  test->OnStreamsCreated(send_stream_, receive_stream_);
+
+  CreateFrameGeneratorCapturer();
+  test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get());
+
+  Start();
+  test->PerformTest();
+  test->StopSending();
+  Stop();
+
+  DestroyStreams();
+}
+
+void CallTest::Start() {
+  send_stream_->Start();
+  if (receive_stream_ != NULL)
+    receive_stream_->Start();
+  frame_generator_capturer_->Start();
+}
+
+void CallTest::Stop() {
+  frame_generator_capturer_->Stop();
+  if (receive_stream_ != NULL)
+    receive_stream_->Stop();
+  send_stream_->Stop();
+}
+
+void CallTest::CreateCalls(const Call::Config& sender_config,
+                           const Call::Config& receiver_config) {
+  CreateSenderCall(sender_config);
+  CreateReceiverCall(receiver_config);
+}
+
+void CallTest::CreateSenderCall(const Call::Config& config) {
+  sender_call_.reset(Call::Create(config));
+}
+
+void CallTest::CreateReceiverCall(const Call::Config& config) {
+  receiver_call_.reset(Call::Create(config));
+}
+
+void CallTest::CreateSendConfig(size_t num_streams) {
+  assert(num_streams <= kNumSsrcs);
+  send_config_ = sender_call_->GetDefaultSendConfig();
+  send_config_.encoder_settings.encoder = &fake_encoder_;
+  send_config_.encoder_settings.payload_name = "FAKE";
+  send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
+  video_streams_ = test::CreateVideoStreams(num_streams);
+  for (size_t i = 0; i < num_streams; ++i)
+    send_config_.rtp.ssrcs.push_back(kSendSsrcs[i]);
+}
+
+// TODO(pbos): Make receive configs into a vector.
+void CallTest::CreateMatchingReceiveConfigs() {
+  assert(send_config_.rtp.ssrcs.size() == 1);
+  receive_config_ = receiver_call_->GetDefaultReceiveConfig();
+  VideoCodec codec =
+      test::CreateDecoderVideoCodec(send_config_.encoder_settings);
+  receive_config_.codecs.push_back(codec);
+  if (send_config_.encoder_settings.encoder == &fake_encoder_) {
+    ExternalVideoDecoder decoder;
+    decoder.decoder = &fake_decoder_;
+    decoder.payload_type = send_config_.encoder_settings.payload_type;
+    receive_config_.external_decoders.push_back(decoder);
+  }
+  receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
+  receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;
+}
+
+void CallTest::CreateFrameGeneratorCapturer() {
+  VideoStream stream = video_streams_.back();
+  frame_generator_capturer_.reset(
+      test::FrameGeneratorCapturer::Create(send_stream_->Input(),
+                                           stream.width,
+                                           stream.height,
+                                           stream.max_framerate,
+                                           Clock::GetRealTimeClock()));
+}
+void CallTest::CreateStreams() {
+  assert(send_stream_ == NULL);
+  assert(receive_stream_ == NULL);
+
+  send_stream_ =
+      sender_call_->CreateVideoSendStream(send_config_, video_streams_, NULL);
+
+  if (receiver_call_.get() != NULL)
+    receive_stream_ = receiver_call_->CreateVideoReceiveStream(receive_config_);
+}
+
+void CallTest::DestroyStreams() {
+  if (send_stream_ != NULL)
+    sender_call_->DestroyVideoSendStream(send_stream_);
+  if (receive_stream_ != NULL)
+    receiver_call_->DestroyVideoReceiveStream(receive_stream_);
+  send_stream_ = NULL;
+  receive_stream_ = NULL;
+}
+
+const unsigned int CallTest::kDefaultTimeoutMs = 30 * 1000;
+const unsigned int CallTest::kLongTimeoutMs = 120 * 1000;
+const uint8_t CallTest::kSendPayloadType = 100;
+const uint8_t CallTest::kFakeSendPayloadType = 125;
+const uint8_t CallTest::kSendRtxPayloadType = 98;
+const uint32_t CallTest::kSendRtxSsrc = 0xBADCAFE;
+const uint32_t CallTest::kSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE, 0xC0FFEF};
+const uint32_t CallTest::kReceiverLocalSsrc = 0x123456;
+const int CallTest::kNackRtpHistoryMs = 1000;
+
+BaseTest::BaseTest(unsigned int timeout_ms) : RtpRtcpObserver(timeout_ms) {
+}
+
+BaseTest::BaseTest(unsigned int timeout_ms,
+                   const FakeNetworkPipe::Config& config)
+    : RtpRtcpObserver(timeout_ms, config) {
+}
+
+BaseTest::~BaseTest() {
+}
+
+Call::Config BaseTest::GetSenderCallConfig() {
+  return Call::Config(SendTransport());
+}
+
+Call::Config BaseTest::GetReceiverCallConfig() {
+  return Call::Config(ReceiveTransport());
+}
+
+void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {
+}
+
+size_t BaseTest::GetNumStreams() const {
+  return 1;
+}
+
+void BaseTest::ModifyConfigs(VideoSendStream::Config* send_config,
+                             VideoReceiveStream::Config* receive_config,
+                             std::vector<VideoStream>* video_streams) {
+}
+
+void BaseTest::OnStreamsCreated(VideoSendStream* send_stream,
+                                VideoReceiveStream* receive_stream) {
+}
+
+void BaseTest::OnFrameGeneratorCapturerCreated(
+    FrameGeneratorCapturer* frame_generator_capturer) {
+}
+
+SendTest::SendTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
+}
+
+SendTest::SendTest(unsigned int timeout_ms,
+                   const FakeNetworkPipe::Config& config)
+    : BaseTest(timeout_ms, config) {
+}
+
+bool SendTest::ShouldCreateReceivers() const {
+  return false;
+}
+
+EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
+}
+
+EndToEndTest::EndToEndTest(unsigned int timeout_ms,
+                           const FakeNetworkPipe::Config& config)
+    : BaseTest(timeout_ms, config) {
+}
+
+bool EndToEndTest::ShouldCreateReceivers() const {
+  return true;
+}
+
+}  // namespace test
+}  // namespace webrtc

webrtc/test/call_test.h

@@ -0,0 +1,119 @@
+/*
+ *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+#ifndef WEBRTC_TEST_COMMON_CALL_TEST_H_
+#define WEBRTC_TEST_COMMON_CALL_TEST_H_
+
+#include <vector>
+
+#include "webrtc/call.h"
+#include "webrtc/test/fake_decoder.h"
+#include "webrtc/test/fake_encoder.h"
+#include "webrtc/test/frame_generator_capturer.h"
+#include "webrtc/test/rtp_rtcp_observer.h"
+
+namespace webrtc {
+namespace test {
+
+class BaseTest;
+
+class CallTest : public ::testing::Test {
+ public:
+  CallTest();
+  ~CallTest();
+
+  static const size_t kNumSsrcs = 3;
+
+  static const unsigned int kDefaultTimeoutMs;
+  static const unsigned int kLongTimeoutMs;
+  static const uint8_t kSendPayloadType;
+  static const uint8_t kSendRtxPayloadType;
+  static const uint8_t kFakeSendPayloadType;
+  static const uint32_t kSendRtxSsrc;
+  static const uint32_t kSendSsrcs[kNumSsrcs];
+  static const uint32_t kReceiverLocalSsrc;
+  static const int kNackRtpHistoryMs;
+
+ protected:
+  void RunBaseTest(BaseTest* test);
+
+  void CreateCalls(const Call::Config& sender_config,
+                   const Call::Config& receiver_config);
+  void CreateSenderCall(const Call::Config& config);
+  void CreateReceiverCall(const Call::Config& config);
+
+  void CreateSendConfig(size_t num_streams);
+  void CreateMatchingReceiveConfigs();
+
+  void CreateFrameGeneratorCapturer();
+
+  void CreateStreams();
+  void Start();
+  void Stop();
+  void DestroyStreams();
+
+  scoped_ptr<Call> sender_call_;
+  VideoSendStream::Config send_config_;
+  std::vector<VideoStream> video_streams_;
+  VideoSendStream* send_stream_;
+
+  scoped_ptr<Call> receiver_call_;
+  VideoReceiveStream::Config receive_config_;
+  VideoReceiveStream* receive_stream_;
+
+  scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
+  test::FakeEncoder fake_encoder_;
+  test::FakeDecoder fake_decoder_;
+};
+
+class BaseTest : public RtpRtcpObserver {
+ public:
+  explicit BaseTest(unsigned int timeout_ms);
+  BaseTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
+  virtual ~BaseTest();
+
+  virtual void PerformTest() = 0;
+  virtual bool ShouldCreateReceivers() const = 0;
+
+  virtual size_t GetNumStreams() const;
+
+  virtual Call::Config GetSenderCallConfig();
+  virtual Call::Config GetReceiverCallConfig();
+  virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
+
+  virtual void ModifyConfigs(VideoSendStream::Config* send_config,
+                             VideoReceiveStream::Config* receive_config,
+                             std::vector<VideoStream>* video_streams);
+  virtual void OnStreamsCreated(VideoSendStream* send_stream,
+                                VideoReceiveStream* receive_stream);
+
+  virtual void OnFrameGeneratorCapturerCreated(
+      FrameGeneratorCapturer* frame_generator_capturer);
+};
+
+class SendTest : public BaseTest {
+ public:
+  explicit SendTest(unsigned int timeout_ms);
+  SendTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
+
+  virtual bool ShouldCreateReceivers() const OVERRIDE;
+};
+
+class EndToEndTest : public BaseTest {
+ public:
+  explicit EndToEndTest(unsigned int timeout_ms);
+  EndToEndTest(unsigned int timeout_ms, const FakeNetworkPipe::Config& config);
+
+  virtual bool ShouldCreateReceivers() const OVERRIDE;
+};
+
+}  // namespace test
+}  // namespace webrtc
+
+#endif  // WEBRTC_TEST_COMMON_CALL_TEST_H_

webrtc/test/rtp_rtcp_observer.h

@@ -16,6 +16,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/test/direct_transport.h"
 #include "webrtc/typedefs.h"
 #include "webrtc/video_send_stream.h"
 

webrtc/test/webrtc_test_common.gyp

@@ -14,6 +14,8 @@
       'target_name': 'webrtc_test_common',
       'type': 'static_library',
       'sources': [
+        'call_test.cc',
+        'call_test.h',
         'configurable_frame_size_encoder.cc',
         'configurable_frame_size_encoder.h',
         'direct_transport.cc',
@@ -54,10 +56,11 @@
       'dependencies': [
         '<(DEPTH)/testing/gtest.gyp:gtest',
         '<(DEPTH)/third_party/gflags/gflags.gyp:gflags',
-        '<(webrtc_root)/modules/modules.gyp:video_capture_module',
         '<(webrtc_root)/modules/modules.gyp:media_file',
+        '<(webrtc_root)/modules/modules.gyp:video_capture_module',
         '<(webrtc_root)/test/test.gyp:frame_generator',
         '<(webrtc_root)/test/test.gyp:test_support',
+        '<(webrtc_root)/webrtc.gyp:webrtc',
       ],
     },
     {

webrtc/video/bitrate_estimator_tests.cc

@@ -19,6 +19,7 @@
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
 #include "webrtc/system_wrappers/interface/thread_annotations.h"
 #include "webrtc/system_wrappers/interface/trace.h"
+#include "webrtc/test/call_test.h"
 #include "webrtc/test/direct_transport.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_decoder.h"
@@ -30,12 +31,7 @@ namespace webrtc {
 static const int kTOFExtensionId = 4;
 static const int kASTExtensionId = 5;
 
-static unsigned int kDefaultTimeoutMs = 30 * 1000;
+class BitrateEstimatorTest : public test::CallTest {
-static const uint32_t kSendSsrc = 0x654321;
-static const uint32_t kReceiverLocalSsrc = 0x123456;
-static const uint8_t kSendPayloadType = 125;
-
-class BitrateEstimatorTest : public ::testing::Test {
  public:
   BitrateEstimatorTest()
       : receiver_trace_(),
@@ -43,7 +39,6 @@ class BitrateEstimatorTest : public ::testing::Test {
         receive_transport_(),
         sender_call_(),
         receiver_call_(),
-        send_config_(),
         receive_config_(),
         streams_() {
   }
@@ -68,11 +63,11 @@ class BitrateEstimatorTest : public ::testing::Test {
     receive_transport_.SetReceiver(sender_call_->Receiver());
 
     send_config_ = sender_call_->GetDefaultSendConfig();
-    send_config_.rtp.ssrcs.push_back(kSendSsrc);
+    send_config_.rtp.ssrcs.push_back(kSendSsrcs[0]);
     // Encoders will be set separately per stream.
     send_config_.encoder_settings.encoder = NULL;
     send_config_.encoder_settings.payload_name = "FAKE";
-    send_config_.encoder_settings.payload_type = kSendPayloadType;
+    send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
     video_streams_ = test::CreateVideoStreams(1);
 
     receive_config_ = receiver_call_->GetDefaultReceiveConfig();
@@ -228,8 +223,6 @@ class BitrateEstimatorTest : public ::testing::Test {
   test::DirectTransport receive_transport_;
   scoped_ptr<Call> sender_call_;
   scoped_ptr<Call> receiver_call_;
-  VideoSendStream::Config send_config_;
-  std::vector<VideoStream> video_streams_;
   VideoReceiveStream::Config receive_config_;
   std::vector<Stream*> streams_;
 };

webrtc/video/call_perf_tests.cc

@@ -23,6 +23,7 @@
 #include "webrtc/system_wrappers/interface/rtp_to_ntp.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
 #include "webrtc/system_wrappers/interface/thread_annotations.h"
+#include "webrtc/test/call_test.h"
 #include "webrtc/test/direct_transport.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_audio_device.h"
@@ -42,61 +43,20 @@
 
 namespace webrtc {
 
-static unsigned int kLongTimeoutMs = 120 * 1000;
+class CallPerfTest : public test::CallTest {
-static const uint32_t kSendSsrc = 0x654321;
-static const uint32_t kReceiverLocalSsrc = 0x123456;
-static const uint8_t kSendPayloadType = 125;
-
-class CallPerfTest : public ::testing::Test {
- public:
-  CallPerfTest()
-      : send_stream_(NULL), fake_encoder_(Clock::GetRealTimeClock()) {}
-
  protected:
-  void CreateTestConfig(Call* call) {
-    send_config_ = call->GetDefaultSendConfig();
-    send_config_.rtp.ssrcs.push_back(kSendSsrc);
-    send_config_.encoder_settings.encoder = &fake_encoder_;
-    send_config_.encoder_settings.payload_type = kSendPayloadType;
-    send_config_.encoder_settings.payload_name = "FAKE";
-    video_streams_ = test::CreateVideoStreams(1);
-  }
-
-  void RunVideoSendTest(Call* call,
-                        const VideoSendStream::Config& config,
-                        test::RtpRtcpObserver* observer) {
-    send_stream_ = call->CreateVideoSendStream(config, video_streams_, NULL);
-    scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
-        test::FrameGeneratorCapturer::Create(
-            send_stream_->Input(), 320, 240, 30, Clock::GetRealTimeClock()));
-    send_stream_->Start();
-    frame_generator_capturer->Start();
-
-    EXPECT_EQ(kEventSignaled, observer->Wait());
-
-    observer->StopSending();
-    frame_generator_capturer->Stop();
-    send_stream_->Stop();
-    call->DestroyVideoSendStream(send_stream_);
-  }
-
   void TestMinTransmitBitrate(bool pad_to_min_bitrate);
 
   void TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
                           int threshold_ms,
                           int start_time_ms,
                           int run_time_ms);
-
-  VideoSendStream::Config send_config_;
-  std::vector<VideoStream> video_streams_;
-  VideoSendStream* send_stream_;
-  test::FakeEncoder fake_encoder_;
 };
 
 class SyncRtcpObserver : public test::RtpRtcpObserver {
  public:
   explicit SyncRtcpObserver(const FakeNetworkPipe::Config& config)
-      : test::RtpRtcpObserver(kLongTimeoutMs, config),
+      : test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs, config),
         crit_(CriticalSectionWrapper::CreateCriticalSection()) {}
 
   virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
@@ -226,6 +186,31 @@ class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer {
 };
 
 TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
+  class AudioPacketReceiver : public PacketReceiver {
+   public:
+    AudioPacketReceiver(int channel, VoENetwork* voe_network)
+        : channel_(channel),
+          voe_network_(voe_network),
+          parser_(RtpHeaderParser::Create()) {}
+    virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
+                                         size_t length) OVERRIDE {
+      int ret;
+      if (parser_->IsRtcp(packet, static_cast<int>(length))) {
+        ret = voe_network_->ReceivedRTCPPacket(
+            channel_, packet, static_cast<unsigned int>(length));
+      } else {
+        ret = voe_network_->ReceivedRTPPacket(
+            channel_, packet, static_cast<unsigned int>(length), PacketTime());
+      }
+      return ret == 0 ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
+    }
+
+   private:
+    int channel_;
+    VoENetwork* voe_network_;
+    scoped_ptr<RtpHeaderParser> parser_;
+  };
+
   VoiceEngine* voice_engine = VoiceEngine::Create();
   VoEBase* voe_base = VoEBase::GetInterface(voice_engine);
   VoECodec* voe_codec = VoECodec::GetInterface(voice_engine);
@@ -249,37 +234,12 @@ TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
 
   Call::Config receiver_config(observer.ReceiveTransport());
   receiver_config.voice_engine = voice_engine;
-  scoped_ptr<Call> sender_call(
+  CreateCalls(Call::Config(observer.SendTransport()), receiver_config);
-      Call::Create(Call::Config(observer.SendTransport())));
+
-  scoped_ptr<Call> receiver_call(Call::Create(receiver_config));
   CodecInst isac = {103, "ISAC", 16000, 480, 1, 32000};
   EXPECT_EQ(0, voe_codec->SetSendCodec(channel, isac));
 
-  class VoicePacketReceiver : public PacketReceiver {
+  AudioPacketReceiver voe_packet_receiver(channel, voe_network);
-   public:
-    VoicePacketReceiver(int channel, VoENetwork* voe_network)
-        : channel_(channel),
-          voe_network_(voe_network),
-          parser_(RtpHeaderParser::Create()) {}
-    virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
-                                         size_t length) OVERRIDE {
-      int ret;
-      if (parser_->IsRtcp(packet, static_cast<int>(length))) {
-        ret = voe_network_->ReceivedRTCPPacket(
-            channel_, packet, static_cast<unsigned int>(length));
-      } else {
-        ret = voe_network_->ReceivedRTPPacket(
-            channel_, packet, static_cast<unsigned int>(length), PacketTime());
-      }
-      return ret == 0 ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
-    }
-
-   private:
-    int channel_;
-    VoENetwork* voe_network_;
-    scoped_ptr<RtpHeaderParser> parser_;
-  } voe_packet_receiver(channel, voe_network);
-
   audio_observer.SetReceivers(&voe_packet_receiver, &voe_packet_receiver);
 
   internal::TransportAdapter transport_adapter(audio_observer.SendTransport());
@@ -287,41 +247,21 @@ TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
   EXPECT_EQ(0,
             voe_network->RegisterExternalTransport(channel, transport_adapter));
 
-  observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
+  observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
 
   test::FakeDecoder fake_decoder;
 
-  CreateTestConfig(sender_call.get());
+  CreateSendConfig(1);
+  CreateMatchingReceiveConfigs();
 
-  VideoReceiveStream::Config receive_config =
+  receive_config_.renderer = &observer;
-      receiver_call->GetDefaultReceiveConfig();
+  receive_config_.audio_channel_id = channel;
-  assert(receive_config.codecs.empty());
-  VideoCodec codec =
-      test::CreateDecoderVideoCodec(send_config_.encoder_settings);
-  receive_config.codecs.push_back(codec);
-  assert(receive_config.external_decoders.empty());
-  ExternalVideoDecoder decoder;
-  decoder.decoder = &fake_decoder;
-  decoder.payload_type = send_config_.encoder_settings.payload_type;
-  receive_config.external_decoders.push_back(decoder);
-  receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
-  receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
-  receive_config.renderer = &observer;
-  receive_config.audio_channel_id = channel;
 
-  VideoSendStream* send_stream =
+  CreateStreams();
-      sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
+
-  VideoReceiveStream* receive_stream =
+  CreateFrameGeneratorCapturer();
-      receiver_call->CreateVideoReceiveStream(receive_config);
+
-  scoped_ptr<test::FrameGeneratorCapturer> capturer(
+  Start();
-      test::FrameGeneratorCapturer::Create(send_stream->Input(),
-                                           video_streams_[0].width,
-                                           video_streams_[0].height,
-                                           30,
-                                           Clock::GetRealTimeClock()));
-  receive_stream->Start();
-  send_stream->Start();
-  capturer->Start();
 
   fake_audio_device.Start();
   EXPECT_EQ(0, voe_base->StartPlayout(channel));
@@ -336,9 +276,7 @@ TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
   EXPECT_EQ(0, voe_base->StopPlayout(channel));
   fake_audio_device.Stop();
 
-  capturer->Stop();
+  Stop();
-  send_stream->Stop();
-  receive_stream->Stop();
   observer.StopSending();
   audio_observer.StopSending();
 
@@ -347,21 +285,25 @@ TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
   voe_codec->Release();
   voe_network->Release();
   voe_sync->Release();
-  sender_call->DestroyVideoSendStream(send_stream);
+
-  receiver_call->DestroyVideoReceiveStream(receive_stream);
+  DestroyStreams();
+
   VoiceEngine::Delete(voice_engine);
 }
 
-class CaptureNtpTimeObserver : public test::RtpRtcpObserver,
+void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
+                                      int threshold_ms,
+                                      int start_time_ms,
+                                      int run_time_ms) {
+  class CaptureNtpTimeObserver : public test::EndToEndTest,
                                  public VideoRenderer {
    public:
-  CaptureNtpTimeObserver(Clock* clock,
+    CaptureNtpTimeObserver(const FakeNetworkPipe::Config& config,
-                         const FakeNetworkPipe::Config& config,
                            int threshold_ms,
                            int start_time_ms,
                            int run_time_ms)
-      : RtpRtcpObserver(kLongTimeoutMs, config),
+        : EndToEndTest(kLongTimeoutMs, config),
-        clock_(clock),
+          clock_(Clock::GetRealTimeClock()),
           threshold_ms_(threshold_ms),
           start_time_ms_(start_time_ms),
           run_time_ms_(run_time_ms),
@@ -370,10 +312,12 @@ class CaptureNtpTimeObserver : public test::RtpRtcpObserver,
           rtp_start_timestamp_set_(false),
           rtp_start_timestamp_(0) {}
 
+   private:
     virtual void RenderFrame(const I420VideoFrame& video_frame,
                              int time_to_render_ms) OVERRIDE {
       if (video_frame.ntp_time_ms() <= 0) {
-      // Haven't got enough RTCP SR in order to calculate the capture ntp time.
+        // Haven't got enough RTCP SR in order to calculate the capture ntp
+        // time.
         return;
       }
 
@@ -403,12 +347,8 @@ class CaptureNtpTimeObserver : public test::RtpRtcpObserver,
       std::stringstream ss;
       ss << time_offset_ms;
 
-    webrtc::test::PrintResult("capture_ntp_time",
+      webrtc::test::PrintResult(
-                              "",
+          "capture_ntp_time", "", "real - estimated", ss.str(), "ms", true);
-                              "real - estimated",
-                              ss.str(),
-                              "ms",
-                              true);
       EXPECT_TRUE(std::abs(time_offset_ms) < threshold_ms_);
     }
 
@@ -426,17 +366,32 @@ class CaptureNtpTimeObserver : public test::RtpRtcpObserver,
       }
 
       uint32_t capture_timestamp = header.timestamp - rtp_start_timestamp_;
-    capture_time_list_.insert(capture_time_list_.end(),
+      capture_time_list_.insert(
-                              std::make_pair(header.timestamp,
+          capture_time_list_.end(),
-                                             capture_timestamp));
+          std::make_pair(header.timestamp, capture_timestamp));
       return SEND_PACKET;
     }
 
-  void SetCapturer(test::FrameGeneratorCapturer* capturer) {
+    virtual void OnFrameGeneratorCapturerCreated(
-    capturer_ = capturer;
+        test::FrameGeneratorCapturer* frame_generator_capturer) OVERRIDE {
+      capturer_ = frame_generator_capturer;
+    }
+
+    virtual void ModifyConfigs(
+        VideoSendStream::Config* send_config,
+        VideoReceiveStream::Config* receive_config,
+        std::vector<VideoStream>* video_streams) OVERRIDE {
+      receive_config->renderer = this;
+      // Enable the receiver side rtt calculation.
+      receive_config->rtp.rtcp_xr.receiver_reference_time_report = true;
+    }
+
+    virtual void PerformTest() OVERRIDE {
+      EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for "
+                                           "estimated capture NTP time to be "
+                                           "within bounds.";
     }
 
- private:
     Clock* clock_;
     int threshold_ms_;
     int start_time_ms_;
@@ -447,74 +402,9 @@ class CaptureNtpTimeObserver : public test::RtpRtcpObserver,
     uint32_t rtp_start_timestamp_;
     typedef std::map<uint32_t, uint32_t> FrameCaptureTimeList;
     FrameCaptureTimeList capture_time_list_;
-};
+  } test(net_config, threshold_ms, start_time_ms, run_time_ms);
 
-void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
+  RunBaseTest(&test);
-                                      int threshold_ms,
-                                      int start_time_ms,
-                                      int run_time_ms) {
-  CaptureNtpTimeObserver observer(Clock::GetRealTimeClock(),
-                                  net_config,
-                                  threshold_ms,
-                                  start_time_ms,
-                                  run_time_ms);
-
-  // Sender/receiver call.
-  Call::Config receiver_config(observer.ReceiveTransport());
-  scoped_ptr<Call> receiver_call(Call::Create(receiver_config));
-  scoped_ptr<Call> sender_call(
-      Call::Create(Call::Config(observer.SendTransport())));
-  observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
-
-  // Configure send stream.
-  CreateTestConfig(sender_call.get());
-  VideoSendStream* send_stream =
-      sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
-  scoped_ptr<test::FrameGeneratorCapturer> capturer(
-      test::FrameGeneratorCapturer::Create(send_stream->Input(),
-                                           video_streams_[0].width,
-                                           video_streams_[0].height,
-                                           30,
-                                           Clock::GetRealTimeClock()));
-  observer.SetCapturer(capturer.get());
-
-  // Configure receive stream.
-  VideoReceiveStream::Config receive_config =
-      receiver_call->GetDefaultReceiveConfig();
-  assert(receive_config.codecs.empty());
-  VideoCodec codec =
-      test::CreateDecoderVideoCodec(send_config_.encoder_settings);
-  receive_config.codecs.push_back(codec);
-  assert(receive_config.external_decoders.empty());
-  ExternalVideoDecoder decoder;
-  test::FakeDecoder fake_decoder;
-  decoder.decoder = &fake_decoder;
-  decoder.payload_type = send_config_.encoder_settings.payload_type;
-  receive_config.external_decoders.push_back(decoder);
-  receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
-  receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
-  receive_config.renderer = &observer;
-  // Enable the receiver side rtt calculation.
-  receive_config.rtp.rtcp_xr.receiver_reference_time_report = true;
-  VideoReceiveStream* receive_stream =
-      receiver_call->CreateVideoReceiveStream(receive_config);
-
-  // Start the test
-  receive_stream->Start();
-  send_stream->Start();
-  capturer->Start();
-
-  EXPECT_EQ(kEventSignaled, observer.Wait())
-      << "Timed out while waiting for estimated capture ntp time to be "
-      << "within bounds.";
-
-  capturer->Stop();
-  send_stream->Stop();
-  receive_stream->Stop();
-  observer.StopSending();
-
-  sender_call->DestroyVideoSendStream(send_stream);
-  receiver_call->DestroyVideoReceiveStream(receive_stream);
 }
 
 TEST_F(CallPerfTest, CaptureNtpTimeWithNetworkDelay) {
@@ -542,26 +432,32 @@ TEST_F(CallPerfTest, CaptureNtpTimeWithNetworkJitter) {
 
 TEST_F(CallPerfTest, RegisterCpuOveruseObserver) {
   // Verifies that either a normal or overuse callback is triggered.
-  class OveruseCallbackObserver : public test::RtpRtcpObserver,
+  class OveruseCallbackObserver : public test::SendTest,
                                   public webrtc::OveruseCallback {
    public:
-    OveruseCallbackObserver() : RtpRtcpObserver(kLongTimeoutMs) {}
+    OveruseCallbackObserver() : SendTest(kLongTimeoutMs) {}
 
     virtual void OnOveruse() OVERRIDE {
       observation_complete_->Set();
     }
+
     virtual void OnNormalUse() OVERRIDE {
       observation_complete_->Set();
     }
-  };
 
-  OveruseCallbackObserver observer;
+    virtual Call::Config GetSenderCallConfig() OVERRIDE {
-  Call::Config call_config(observer.SendTransport());
+      Call::Config config(SendTransport());
-  call_config.overuse_callback = &observer;
+      config.overuse_callback = this;
-  scoped_ptr<Call> call(Call::Create(call_config));
+      return config;
+    }
 
-  CreateTestConfig(call.get());
+    virtual void PerformTest() OVERRIDE {
-  RunVideoSendTest(call.get(), send_config_, &observer);
+      EXPECT_EQ(kEventSignaled, Wait())
+          << "Timed out before receiving an overuse callback.";
+    }
+  } test;
+
+  RunBaseTest(&test);
 }
 
 void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
@@ -570,15 +466,16 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
   static const int kMinAcceptableTransmitBitrate = 130;
   static const int kMaxAcceptableTransmitBitrate = 170;
   static const int kNumBitrateObservationsInRange = 100;
-  class BitrateObserver : public test::RtpRtcpObserver, public PacketReceiver {
+  class BitrateObserver : public test::EndToEndTest, public PacketReceiver {
    public:
     explicit BitrateObserver(bool using_min_transmit_bitrate)
-        : test::RtpRtcpObserver(kLongTimeoutMs),
+        : EndToEndTest(kLongTimeoutMs),
           send_stream_(NULL),
           send_transport_receiver_(NULL),
-          using_min_transmit_bitrate_(using_min_transmit_bitrate),
+          pad_to_min_bitrate_(using_min_transmit_bitrate),
           num_bitrate_observations_in_range_(0) {}
 
+   private:
     virtual void SetReceivers(PacketReceiver* send_transport_receiver,
                               PacketReceiver* receive_transport_receiver)
         OVERRIDE {
@@ -586,11 +483,6 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
       test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
     }
 
-    void SetSendStream(VideoSendStream* send_stream) {
-      send_stream_ = send_stream;
-    }
-
-   private:
     virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
                                          size_t length) OVERRIDE {
       VideoSendStream::Stats stats = send_stream_->GetStats();
@@ -600,13 +492,13 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
         if (bitrate_kbps > 0) {
           test::PrintResult(
               "bitrate_stats_",
-              (using_min_transmit_bitrate_ ? "min_transmit_bitrate"
+              (pad_to_min_bitrate_ ? "min_transmit_bitrate"
                                    : "without_min_transmit_bitrate"),
               "bitrate_kbps",
               static_cast<size_t>(bitrate_kbps),
               "kbps",
               false);
-          if (using_min_transmit_bitrate_) {
+          if (pad_to_min_bitrate_) {
             if (bitrate_kbps > kMinAcceptableTransmitBitrate &&
                 bitrate_kbps < kMaxAcceptableTransmitBitrate) {
               ++num_bitrate_observations_in_range_;
@@ -626,66 +518,35 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
       return send_transport_receiver_->DeliverPacket(packet, length);
     }
 
-    VideoSendStream* send_stream_;
+    virtual void OnStreamsCreated(VideoSendStream* send_stream,
-    PacketReceiver* send_transport_receiver_;
+                                  VideoReceiveStream* receive_stream) {
-    const bool using_min_transmit_bitrate_;
+      send_stream_ = send_stream;
-    int num_bitrate_observations_in_range_;
-  } observer(pad_to_min_bitrate);
-
-  scoped_ptr<Call> sender_call(
-      Call::Create(Call::Config(observer.SendTransport())));
-  scoped_ptr<Call> receiver_call(
-      Call::Create(Call::Config(observer.ReceiveTransport())));
-
-  CreateTestConfig(sender_call.get());
-  fake_encoder_.SetMaxBitrate(kMaxEncodeBitrateKbps);
-
-  observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
-
-  if (pad_to_min_bitrate) {
-    send_config_.rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
-  } else {
-    assert(send_config_.rtp.min_transmit_bitrate_bps == 0);
     }
 
-  VideoReceiveStream::Config receive_config =
+    virtual void ModifyConfigs(
-      receiver_call->GetDefaultReceiveConfig();
+        VideoSendStream::Config* send_config,
-  receive_config.codecs.clear();
+        VideoReceiveStream::Config* receive_config,
-  VideoCodec codec =
+        std::vector<VideoStream>* video_streams) OVERRIDE {
-      test::CreateDecoderVideoCodec(send_config_.encoder_settings);
+      if (pad_to_min_bitrate_) {
-  receive_config.codecs.push_back(codec);
+        send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
-  test::FakeDecoder fake_decoder;
+      } else {
-  ExternalVideoDecoder decoder;
+        assert(send_config->rtp.min_transmit_bitrate_bps == 0);
-  decoder.decoder = &fake_decoder;
+      }
-  decoder.payload_type = send_config_.encoder_settings.payload_type;
+    }
-  receive_config.external_decoders.push_back(decoder);
-  receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
-  receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
 
-  VideoSendStream* send_stream =
+    virtual void PerformTest() OVERRIDE {
-      sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
+      EXPECT_EQ(kEventSignaled, Wait())
-  VideoReceiveStream* receive_stream =
-      receiver_call->CreateVideoReceiveStream(receive_config);
-  scoped_ptr<test::FrameGeneratorCapturer> capturer(
-      test::FrameGeneratorCapturer::Create(send_stream->Input(),
-                                           video_streams_[0].width,
-                                           video_streams_[0].height,
-                                           30,
-                                           Clock::GetRealTimeClock()));
-  observer.SetSendStream(send_stream);
-  receive_stream->Start();
-  send_stream->Start();
-  capturer->Start();
-
-  EXPECT_EQ(kEventSignaled, observer.Wait())
           << "Timeout while waiting for send-bitrate stats.";
+    }
 
-  send_stream->Stop();
+    VideoSendStream* send_stream_;
-  receive_stream->Stop();
+    PacketReceiver* send_transport_receiver_;
-  observer.StopSending();
+    const bool pad_to_min_bitrate_;
-  capturer->Stop();
+    int num_bitrate_observations_in_range_;
-  sender_call->DestroyVideoSendStream(send_stream);
+  } test(pad_to_min_bitrate);
-  receiver_call->DestroyVideoReceiveStream(receive_stream);
+
+  fake_encoder_.SetMaxBitrate(kMaxEncodeBitrateKbps);
+  RunBaseTest(&test);
 }
 
 TEST_F(CallPerfTest, PadsToMinTransmitBitrate) { TestMinTransmitBitrate(true); }

webrtc/video/full_stack.cc

@@ -24,6 +24,7 @@
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
 #include "webrtc/system_wrappers/interface/sleep.h"
 #include "webrtc/system_wrappers/interface/thread_annotations.h"
+#include "webrtc/test/call_test.h"
 #include "webrtc/test/direct_transport.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_encoder.h"
@@ -34,7 +35,6 @@
 
 namespace webrtc {
 
-static const uint32_t kSendSsrc = 0x654321;
 static const int kFullStackTestDurationSecs = 10;
 
 struct FullStackTestParams {
@@ -49,20 +49,9 @@ struct FullStackTestParams {
   double avg_ssim_threshold;
 };
 
-FullStackTestParams paris_qcif = {
+class FullStackTest : public test::CallTest {
-    "net_delay_0_0_plr_0", {"paris_qcif", 176, 144, 30}, 300, 36.0, 0.96};
-
-// TODO(pbos): Decide on psnr/ssim thresholds for foreman_cif.
-FullStackTestParams foreman_cif = {
-    "foreman_cif_net_delay_0_0_plr_0",
-    {"foreman_cif", 352, 288, 30},
-    700,
-    0.0,
-    0.0};
-
-class FullStackTest : public ::testing::TestWithParam<FullStackTestParams> {
  protected:
-  std::map<uint32_t, bool> reserved_ssrcs_;
+  void TestWithoutPacketLoss(const FullStackTestParams& params);
 };
 
 class VideoAnalyzer : public PacketReceiver,
@@ -200,7 +189,9 @@ class VideoAnalyzer : public PacketReceiver,
     last_rendered_frame_.CopyFrame(video_frame);
   }
 
-  void Wait() { done_->Wait(120 * 1000); }
+  void Wait() {
+    EXPECT_EQ(kEventSignaled, done_->Wait(FullStackTest::kLongTimeoutMs));
+  }
 
   VideoSendStreamInput* input_;
   Transport* transport_;
@@ -376,10 +367,7 @@ class VideoAnalyzer : public PacketReceiver,
   const scoped_ptr<EventWrapper> done_;
 };
 
-TEST_P(FullStackTest, NoPacketLoss) {
+void FullStackTest::TestWithoutPacketLoss(const FullStackTestParams& params) {
-  static const uint32_t kReceiverLocalSsrc = 0x123456;
-  FullStackTestParams params = GetParam();
-
   test::DirectTransport transport;
   VideoAnalyzer analyzer(NULL,
                          &transport,
@@ -388,32 +376,32 @@ TEST_P(FullStackTest, NoPacketLoss) {
                          params.avg_ssim_threshold,
                          kFullStackTestDurationSecs * params.clip.fps);
 
-  Call::Config call_config(&analyzer);
+  CreateCalls(Call::Config(&analyzer), Call::Config(&analyzer));
 
-  scoped_ptr<Call> call(Call::Create(call_config));
+  analyzer.SetReceiver(receiver_call_->Receiver());
-  analyzer.SetReceiver(call->Receiver());
   transport.SetReceiver(&analyzer);
 
-  VideoSendStream::Config send_config = call->GetDefaultSendConfig();
+  CreateSendConfig(1);
-  send_config.rtp.ssrcs.push_back(kSendSsrc);
 
   scoped_ptr<VP8Encoder> encoder(VP8Encoder::Create());
-  send_config.encoder_settings.encoder = encoder.get();
+  send_config_.encoder_settings.encoder = encoder.get();
-  send_config.encoder_settings.payload_name = "VP8";
+  send_config_.encoder_settings.payload_name = "VP8";
-  send_config.encoder_settings.payload_type = 124;
+  send_config_.encoder_settings.payload_type = 124;
-  std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
+
-  VideoStream* stream = &video_streams[0];
+  VideoStream* stream = &video_streams_[0];
   stream->width = params.clip.width;
   stream->height = params.clip.height;
   stream->min_bitrate_bps = stream->target_bitrate_bps =
       stream->max_bitrate_bps = params.bitrate * 1000;
   stream->max_framerate = params.clip.fps;
 
-  VideoSendStream* send_stream =
+  CreateMatchingReceiveConfigs();
-      call->CreateVideoSendStream(send_config, video_streams, NULL);
+  receive_config_.renderer = &analyzer;
-  analyzer.input_ = send_stream->Input();
 
-  scoped_ptr<test::FrameGeneratorCapturer> file_capturer(
+  CreateStreams();
+  analyzer.input_ = send_stream_->Input();
+
+  frame_generator_capturer_.reset(
       test::FrameGeneratorCapturer::CreateFromYuvFile(
           &analyzer,
           test::ResourcePath(params.clip.name, "yuv").c_str(),
@@ -421,39 +409,41 @@ TEST_P(FullStackTest, NoPacketLoss) {
           params.clip.height,
           params.clip.fps,
           Clock::GetRealTimeClock()));
-  ASSERT_TRUE(file_capturer.get() != NULL)
+
+  ASSERT_TRUE(frame_generator_capturer_.get() != NULL)
       << "Could not create capturer for " << params.clip.name
       << ".yuv. Is this resource file present?";
 
-  VideoReceiveStream::Config receive_config = call->GetDefaultReceiveConfig();
+  Start();
-  VideoCodec codec =
-      test::CreateDecoderVideoCodec(send_config.encoder_settings);
-  receive_config.codecs.push_back(codec);
-  receive_config.rtp.remote_ssrc = send_config.rtp.ssrcs[0];
-  receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
-  receive_config.renderer = &analyzer;
-
-  VideoReceiveStream* receive_stream =
-      call->CreateVideoReceiveStream(receive_config);
-
-  receive_stream->Start();
-  send_stream->Start();
-  file_capturer->Start();
 
   analyzer.Wait();
 
-  file_capturer->Stop();
-  send_stream->Stop();
-  receive_stream->Stop();
-
-  call->DestroyVideoReceiveStream(receive_stream);
-  call->DestroyVideoSendStream(send_stream);
-
   transport.StopSending();
+
+  Stop();
+
+  DestroyStreams();
 }
 
-INSTANTIATE_TEST_CASE_P(FullStack,
+FullStackTestParams paris_qcif = {"net_delay_0_0_plr_0",
-                        FullStackTest,
+                                  {"paris_qcif", 176, 144, 30},
-                        ::testing::Values(paris_qcif, foreman_cif));
+                                  300,
+                                  36.0,
+                                  0.96};
+
+// TODO(pbos): Decide on psnr/ssim thresholds for foreman_cif.
+FullStackTestParams foreman_cif = {"foreman_cif_net_delay_0_0_plr_0",
+                                   {"foreman_cif", 352, 288, 30},
+                                   700,
+                                   0.0,
+                                   0.0};
+
+TEST_F(FullStackTest, ParisQcifWithoutPacketLoss) {
+  TestWithoutPacketLoss(paris_qcif);
+}
+
+TEST_F(FullStackTest, ForemanCifWithoutPacketLoss) {
+  TestWithoutPacketLoss(foreman_cif);
+}
 
 }  // namespace webrtc

webrtc/video/rampup_tests.cc

@@ -27,6 +27,7 @@
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/event_wrapper.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
+#include "webrtc/test/call_test.h"
 #include "webrtc/test/direct_transport.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_decoder.h"
@@ -388,7 +389,9 @@ class LowRateStreamObserver : public test::DirectTransport,
     }
   }
 
-  EventTypeWrapper Wait() { return test_done_->Wait(120 * 1000); }
+  EventTypeWrapper Wait() {
+    return test_done_->Wait(test::CallTest::kLongTimeoutMs);
+  }
 
  private:
   static const unsigned int kHighBandwidthLimitBps = 80000;
@@ -420,10 +423,7 @@ class LowRateStreamObserver : public test::DirectTransport,
 };
 }  // namespace
 
-class RampUpTest : public ::testing::Test {
+class RampUpTest : public test::CallTest {
- public:
-  virtual void SetUp() { reserved_ssrcs_.clear(); }
-
  protected:
   void RunRampUpTest(bool rtx,
                      size_t num_streams,
@@ -445,33 +445,26 @@ class RampUpTest : public ::testing::Test {
       call_config.start_bitrate_bps = start_bitrate_bps;
       stream_observer.set_start_bitrate_bps(start_bitrate_bps);
     }
-    scoped_ptr<Call> call(Call::Create(call_config));
-    VideoSendStream::Config send_config = call->GetDefaultSendConfig();
 
-    receiver_transport.SetReceiver(call->Receiver());
+    CreateSenderCall(call_config);
+    CreateSendConfig(num_streams);
 
-    test::FakeEncoder encoder(Clock::GetRealTimeClock());
+    receiver_transport.SetReceiver(sender_call_->Receiver());
-    send_config.encoder_settings.encoder = &encoder;
-    send_config.encoder_settings.payload_type = 125;
-    send_config.encoder_settings.payload_name = "FAKE";
-    std::vector<VideoStream> video_streams =
-        test::CreateVideoStreams(num_streams);
 
     if (num_streams == 1) {
-      video_streams[0].target_bitrate_bps = 2000000;
+      video_streams_[0].target_bitrate_bps = 2000000;
-      video_streams[0].max_bitrate_bps = 2000000;
+      video_streams_[0].max_bitrate_bps = 2000000;
     }
 
-    send_config.rtp.nack.rtp_history_ms = 1000;
+    send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
-    send_config.rtp.ssrcs = ssrcs;
+    send_config_.rtp.ssrcs = ssrcs;
     if (rtx) {
-      send_config.rtp.rtx.payload_type = 96;
+      send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
-      send_config.rtp.rtx.ssrcs = rtx_ssrcs;
+      send_config_.rtp.rtx.ssrcs = rtx_ssrcs;
-      send_config.rtp.rtx.pad_with_redundant_payloads = true;
+      send_config_.rtp.rtx.pad_with_redundant_payloads = true;
     }
-    send_config.rtp.extensions.push_back(
+    send_config_.rtp.extensions.push_back(RtpExtension(
-        RtpExtension(RtpExtension::kTOffset,
+        RtpExtension::kTOffset, kTransmissionTimeOffsetExtensionId));
-                     kTransmissionTimeOffsetExtensionId));
 
     if (num_streams == 1) {
       // For single stream rampup until 1mbps
@@ -480,32 +473,22 @@ class RampUpTest : public ::testing::Test {
       // For multi stream rampup until all streams are being sent. That means
       // enough birate to send all the target streams plus the min bitrate of
       // the last one.
-      int expected_bitrate_bps = video_streams.back().min_bitrate_bps;
+      int expected_bitrate_bps = video_streams_.back().min_bitrate_bps;
-      for (size_t i = 0; i < video_streams.size() - 1; ++i) {
+      for (size_t i = 0; i < video_streams_.size() - 1; ++i) {
-        expected_bitrate_bps += video_streams[i].target_bitrate_bps;
+        expected_bitrate_bps += video_streams_[i].target_bitrate_bps;
       }
       stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
     }
 
-    VideoSendStream* send_stream =
+    CreateStreams();
-        call->CreateVideoSendStream(send_config, video_streams, NULL);
+    CreateFrameGeneratorCapturer();
 
-    scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
+    Start();
-        test::FrameGeneratorCapturer::Create(send_stream->Input(),
-                                             video_streams.back().width,
-                                             video_streams.back().height,
-                                             video_streams.back().max_framerate,
-                                             Clock::GetRealTimeClock()));
-
-    send_stream->Start();
-    frame_generator_capturer->Start();
 
     EXPECT_EQ(kEventSignaled, stream_observer.Wait());
 
-    frame_generator_capturer->Stop();
+    Stop();
-    send_stream->Stop();
+    DestroyStreams();
-
-    call->DestroyVideoSendStream(send_stream);
   }
 
   void RunRampUpDownUpTest(size_t number_of_streams, bool rtx) {
@@ -520,59 +503,27 @@ class RampUpTest : public ::testing::Test {
     webrtc::Config webrtc_config;
     call_config.webrtc_config = &webrtc_config;
     webrtc_config.Set<PaddingStrategy>(new PaddingStrategy(rtx));
-    scoped_ptr<Call> call(Call::Create(call_config));
+    CreateSenderCall(call_config);
-    VideoSendStream::Config send_config = call->GetDefaultSendConfig();
+    receiver_transport.SetReceiver(sender_call_->Receiver());
 
-    receiver_transport.SetReceiver(call->Receiver());
+    CreateSendConfig(number_of_streams);
 
-    test::FakeEncoder encoder(Clock::GetRealTimeClock());
+    send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
-    send_config.encoder_settings.encoder = &encoder;
+    send_config_.rtp.extensions.push_back(RtpExtension(
-    send_config.encoder_settings.payload_type = 125;
+        RtpExtension::kTOffset, kTransmissionTimeOffsetExtensionId));
-    send_config.encoder_settings.payload_name = "FAKE";
+    send_config_.suspend_below_min_bitrate = true;
-    std::vector<VideoStream> video_streams =
-        test::CreateVideoStreams(number_of_streams);
 
-    send_config.rtp.nack.rtp_history_ms = 1000;
+    CreateStreams();
-    send_config.rtp.ssrcs.insert(
+    stream_observer.SetSendStream(send_stream_);
-        send_config.rtp.ssrcs.begin(), ssrcs.begin(), ssrcs.end());
-    send_config.rtp.extensions.push_back(
-        RtpExtension(RtpExtension::kTOffset,
-                     kTransmissionTimeOffsetExtensionId));
-    send_config.suspend_below_min_bitrate = true;
 
-    VideoSendStream* send_stream =
+    CreateFrameGeneratorCapturer();
-        call->CreateVideoSendStream(send_config, video_streams, NULL);
-    stream_observer.SetSendStream(send_stream);
 
-    size_t width = 0;
+    Start();
-    size_t height = 0;
-    for (size_t i = 0; i < video_streams.size(); ++i) {
-      size_t stream_width = video_streams[i].width;
-      size_t stream_height = video_streams[i].height;
-      if (stream_width > width)
-        width = stream_width;
-      if (stream_height > height)
-        height = stream_height;
-    }
-
-    scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
-        test::FrameGeneratorCapturer::Create(send_stream->Input(),
-                                             width,
-                                             height,
-                                             30,
-                                             Clock::GetRealTimeClock()));
-
-    send_stream->Start();
-    frame_generator_capturer->Start();
 
     EXPECT_EQ(kEventSignaled, stream_observer.Wait());
 
-    stream_observer.StopSending();
+    Stop();
-    receiver_transport.StopSending();
+    DestroyStreams();
-    frame_generator_capturer->Stop();
-    send_stream->Stop();
-
-    call->DestroyVideoSendStream(send_stream);
   }
 
  private:
@@ -583,8 +534,6 @@ class RampUpTest : public ::testing::Test {
       ssrcs.push_back(static_cast<uint32_t>(ssrc_offset + i));
     return ssrcs;
   }
-
-  std::map<uint32_t, bool> reserved_ssrcs_;
 };
 
 TEST_F(RampUpTest, SingleStream) {

webrtc/webrtc_tests.gypi

@@ -46,7 +46,7 @@
       'type': '<(gtest_target_type)',
       'sources': [
         'video/bitrate_estimator_tests.cc',
-        'video/call_tests.cc',
+        'video/end_to_end_tests.cc',
         'video/send_statistics_proxy_unittest.cc',
         'video/video_send_stream_tests.cc',
         'test/common_unittest.cc',