peer_scenario.h - mozsearch

/*

 *  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_