diff options
Diffstat (limited to 'third_party/libwebrtc/test/peer_scenario/peer_scenario.h')
| -rw-r--r-- | third_party/libwebrtc/test/peer_scenario/peer_scenario.h | 122 |
1 files changed, 122 insertions, 0 deletions
diff --git a/third_party/libwebrtc/test/peer_scenario/peer_scenario.h b/third_party/libwebrtc/test/peer_scenario/peer_scenario.h new file mode 100644 index 0000000000..a177eeaac6 --- /dev/null +++ b/third_party/libwebrtc/test/peer_scenario/peer_scenario.h @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2019 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 TEST_PEER_SCENARIO_PEER_SCENARIO_H_ +#define TEST_PEER_SCENARIO_PEER_SCENARIO_H_ + +// The peer connection scenario test framework enables writing end to end unit +// tests on the peer connection level. It's similar to the Scenario test but +// uses the full stack, including SDP and ICE negotiation. This ensures that +// features work end to end. It's also diffferent from the other tests on peer +// connection level in that it does not rely on any mocks or fakes other than +// for media input and networking. Additionally it provides direct access to the +// underlying peer connection class. + +#include <list> +#include <vector> + +#include "api/test/time_controller.h" +#include "test/gtest.h" +#include "test/logging/log_writer.h" +#include "test/network/network_emulation_manager.h" +#include "test/peer_scenario/peer_scenario_client.h" +#include "test/peer_scenario/signaling_route.h" +#include "test/scenario/stats_collection.h" +#include "test/scenario/video_frame_matcher.h" + +namespace webrtc { +namespace test { +// The PeerScenario class represents a PeerConnection simulation scenario. The +// main purpose is to maintain ownership and ensure safe destruction order of +// clients and network emulation. Additionally it reduces the amount of boiler +// plate requited for some actions. For example usage see the existing tests +// using this class. Note that it should be used from a single calling thread. +// This thread will also be assigned as the signaling thread for all peer +// connections that are created. This means that the process methods must be +// used when waiting to ensure that messages are processed on the signaling +// thread. +class PeerScenario { + public: + // The name is used for log output when those are enabled by the --peer_logs + // command line flag. Optionally, the TestInfo struct available in gtest can + // be used to automatically generate a path based on the test name. + explicit PeerScenario(const testing::TestInfo& test_info, + TimeMode mode = TimeMode::kSimulated); + explicit PeerScenario(std::string file_name, + TimeMode mode = TimeMode::kSimulated); + explicit PeerScenario( + std::unique_ptr<LogWriterFactoryInterface> log_writer_manager, + TimeMode mode = TimeMode::kSimulated); + + NetworkEmulationManagerImpl* net() { return &net_; } + + // Creates a client wrapping a peer connection conforming to the given config. + // The client will share the signaling thread with the scenario. To maintain + // control of destruction order, ownership is kept within the scenario. + PeerScenarioClient* CreateClient(PeerScenarioClient::Config config); + PeerScenarioClient* CreateClient(std::string name, + PeerScenarioClient::Config config); + + // Sets up a signaling route that can be used for SDP and ICE. + SignalingRoute ConnectSignaling(PeerScenarioClient* caller, + PeerScenarioClient* callee, + std::vector<EmulatedNetworkNode*> send_link, + std::vector<EmulatedNetworkNode*> ret_link); + + // Connects two clients over given links. This will also start ICE signaling + // and SDP negotiation with default behavior. For customized behavior, + // ConnectSignaling should be used to allow more detailed control, for + // instance to allow different signaling and media routes. + void SimpleConnection(PeerScenarioClient* caller, + PeerScenarioClient* callee, + std::vector<EmulatedNetworkNode*> send_link, + std::vector<EmulatedNetworkNode*> ret_link); + + // Starts feeding the results of comparing captured frames from `send_track` + // with decoded frames on `receiver` to `analyzer`. + // TODO(srte): Provide a way to detach to allow removal of tracks. + void AttachVideoQualityAnalyzer(VideoQualityAnalyzer* analyzer, + VideoTrackInterface* send_track, + PeerScenarioClient* receiver); + + // Waits on `event` while processing messages on the signaling thread. + bool WaitAndProcess(std::atomic<bool>* event, + TimeDelta max_duration = TimeDelta::Seconds(5)); + + // Process messages on the signaling thread for the given duration. + void ProcessMessages(TimeDelta duration); + + private: + // Helper struct to maintain ownership of the matcher and taps. + struct PeerVideoQualityPair { + public: + PeerVideoQualityPair(Clock* capture_clock, VideoQualityAnalyzer* analyzer) + : matcher_({analyzer->Handler()}), + capture_tap_(capture_clock, &matcher_), + decode_tap_(capture_clock, &matcher_, 0) {} + VideoFrameMatcher matcher_; + CapturedFrameTap capture_tap_; + DecodedFrameTap decode_tap_; + }; + + Clock* clock() { return Clock::GetRealTimeClock(); } + + std::unique_ptr<LogWriterFactoryInterface> GetLogWriterFactory( + std::string name); + + const std::unique_ptr<LogWriterFactoryInterface> log_writer_manager_; + NetworkEmulationManagerImpl net_; + rtc::Thread* const signaling_thread_; + std::list<PeerVideoQualityPair> video_quality_pairs_; + std::list<PeerScenarioClient> peer_clients_; +}; + +} // namespace test +} // namespace webrtc +#endif // TEST_PEER_SCENARIO_PEER_SCENARIO_H_ |