mediatransporthandler_unittest.cpp

Enable keyboard shortcuts

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this file,

 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "MediaTransportHandler.h"

#include "mozilla/Preferences.h"

#include "mozilla/SpinEventLoopUntil.h"

#include "mozilla/TimeStamp.h"

#include "nsComponentManagerUtils.h"

#include "nsISocketTransportService.h"

#include "nsPISocketTransportService.h"

#include "nsServiceManagerUtils.h"

#define GTEST_HAS_RTTI 0

#include "gtest/gtest.h"

using namespace mozilla;

namespace {

class MediaTransportHandlerTest : public ::testing::Test {

 protected:

  void SetUp() override {

    // So gathering does not depend on what interfaces this machine has.

    Preferences::SetBool("media.peerconnection.ice.loopback", true);

    mSts = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID);

    ASSERT_TRUE(mSts);

  void TearDown() override {

    Preferences::ClearUser("media.peerconnection.ice.loopback");

  // Sets up an ICE context and one transport, and waits for a candidate.

  static bool GatherACandidate(MediaTransportHandler& aHandler) {

    bool gathered = false;

    MediaEventListener listener = aHandler.GetCandidateGathered().Connect(

        GetMainThreadSerialEventTarget(),

        [&gathered](const std::string&, const CandidateInfo& aInfo) {

          if (!aInfo.mCandidate.empty()) {

            gathered = true;

});

    aHandler.CreateIceCtx("MediaTransportHandlerTest");

    EXPECT_EQ(NS_OK, aHandler.SetIceConfig(nsTArray<dom::RTCIceServer>(),

                                           dom::RTCIceTransportPolicy::All));

    aHandler.EnsureProvisionalTransport("transport_0", "ufrag",

                                        "passwordpasswordpassword", 1);

    aHandler.StartIceGathering(false, false, nsTArray<NrIceStunAddr>());

    const TimeStamp deadline = TimeStamp::Now() + TimeDuration::FromSeconds(10);

    SpinEventLoopUntil("MediaTransportHandlerTest::GatherACandidate"_ns,

                       [&] { return gathered || TimeStamp::Now() > deadline; });

    listener.Disconnect();

    return gathered;

  // What going offline for a profile change does to STS: the shutdown

  // observers run, and then the STS thread is joined right away.

  void ShutDownSts() {

    nsCOMPtr<nsPISocketTransportService> sts = do_QueryInterface(mSts);

    ASSERT_EQ(NS_OK, sts->Shutdown(false));

  void RestartSts() {

    nsCOMPtr<nsPISocketTransportService> sts = do_QueryInterface(mSts);

    ASSERT_EQ(NS_OK, sts->Init());

  nsCOMPtr<nsISocketTransportService> mSts;

};

TEST_F(MediaTransportHandlerTest, SurvivesStsRestart) {

  RefPtr<MediaTransportHandler> handler = MediaTransportHandler::Create();

  ASSERT_TRUE(GatherACandidate(*handler));

  ShutDownSts();

  // STS is finished shutting down and no longer accepting runnables, so the

  // implementation is destroyed right here, off STS. That is only safe if STS

  // shutdown made it release everything it held there.

  handler = nullptr;

  RestartSts();

  // Handlers made after STS comes back must work.

  handler = MediaTransportHandler::Create();

  EXPECT_TRUE(GatherACandidate(*handler));

  handler = nullptr;

}  // namespace