--- a/media/mtransport/nricectx.h
+++ b/media/mtransport/nricectx.h
@@ -188,16 +188,17 @@ class NrIceProxyServer {
private:
std::string host_;
uint16_t port_;
std::string alpn_;
};
class NrIceCtx {
+ friend class NrIceCtxHandler;
public:
enum ConnectionState { ICE_CTX_INIT,
ICE_CTX_CHECKING,
ICE_CTX_OPEN,
ICE_CTX_FAILED
};
enum GatheringState { ICE_CTX_GATHER_INIT,
@@ -249,16 +250,17 @@ class NrIceCtx {
// Some might be null
size_t GetStreamCount() const
{
return streams_.size();
}
// The name of the ctx
const std::string& name() const { return name_; }
+ bool offerer() const { return offerer_; }
// Get ufrag and password.
std::string ufrag() const;
std::string pwd() const;
// Current state
ConnectionState connection_state() const {
return connection_state_;
@@ -324,19 +326,17 @@ class NrIceCtx {
sigslot::signal2<NrIceCtx*, NrIceCtx::ConnectionState>
SignalConnectionStateChange;
// The thread to direct method calls to
nsCOMPtr<nsIEventTarget> thread() { return sts_target_; }
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(NrIceCtx)
- protected:
- virtual ~NrIceCtx();
-
+private:
NrIceCtx(const std::string& name,
bool offerer,
Policy policy)
: connection_state_(ICE_CTX_INIT),
gathering_state_(ICE_CTX_GATHER_INIT),
name_(name),
offerer_(offerer),
streams_(),
@@ -345,17 +345,18 @@ class NrIceCtx {
ice_handler_vtbl_(nullptr),
ice_handler_(nullptr),
trickle_(true),
policy_(policy) {
// XXX: offerer_ will be used eventually; placate clang in the meantime.
(void)offerer_;
}
- private:
+ virtual ~NrIceCtx();
+
DISALLOW_COPY_ASSIGN(NrIceCtx);
// Callbacks for nICEr
static void gather_cb(NR_SOCKET s, int h, void *arg); // ICE gather complete
// Handler implementation
static int select_pair(void *obj,nr_ice_media_stream *stream,
int component_id, nr_ice_cand_pair **potentials,
@@ -374,17 +375,16 @@ class NrIceCtx {
RefPtr<NrIceMediaStream> FindStream(nr_ice_media_stream *stream);
// Set the state
void SetConnectionState(ConnectionState state);
// Set the state
void SetGatheringState(GatheringState state);
-protected:
ConnectionState connection_state_;
GatheringState gathering_state_;
const std::string name_;
bool offerer_;
std::vector<RefPtr<NrIceMediaStream> > streams_;
nr_ice_ctx *ctx_;
nr_ice_peer_ctx *peer_;
nr_ice_handler_vtbl* ice_handler_vtbl_; // Must be pointer--- a/media/mtransport/nricectxhandler.cpp
+++ b/media/mtransport/nricectxhandler.cpp
@@ -7,125 +7,91 @@ extern "C" {
}
// Local includes
#include "nricectxhandler.h"
#include "nricemediastream.h"
namespace mozilla {
-NrIceCtxHandler::~NrIceCtxHandler()
+NrIceCtxHandler::NrIceCtxHandler(const std::string& name,
+ bool offerer,
+ NrIceCtx::Policy policy)
+ : current_ctx(new NrIceCtx(name, offerer, policy)),
+ restart_ctx(nullptr),
+ restart_count(0)
{
}
-
RefPtr<NrIceCtxHandler>
NrIceCtxHandler::Create(const std::string& name,
bool offerer,
bool allow_loopback,
bool tcp_enabled,
bool allow_link_local,
bool hide_non_default,
- Policy policy)
+ NrIceCtx::Policy policy)
{
// InitializeCryptoAndLogging only executes once
NrIceCtx::InitializeCryptoAndLogging(allow_loopback,
tcp_enabled,
allow_link_local);
RefPtr<NrIceCtxHandler> ctx = new NrIceCtxHandler(name, offerer, policy);
- if (!NrIceCtx::Initialize(ctx,
+ if (!NrIceCtx::Initialize(ctx->current_ctx,
hide_non_default)) {
return nullptr;
}
return ctx;
}
RefPtr<NrIceMediaStream>
NrIceCtxHandler::CreateStream(const std::string& name, int components)
{
// To make tracking NrIceMediaStreams easier during ICE restart
// prepend an int to the name that increments with each ICE restart
std::ostringstream os;
os << restart_count << "-" << name;
- return NrIceMediaStream::Create(this, os.str(), components);
-}
-
-
-void
-NrIceCtxHandler::SwapContextData(NrIceCtxHandler& ctx1, NrIceCtxHandler& ctx2)
-{
- ctx1.streams_.swap(ctx2.streams_);
-
- ConnectionState tmp_connection_state = ctx1.connection_state_;
- GatheringState tmp_gathering_state = ctx1.gathering_state_;
- nr_ice_ctx *tmp_ctx = ctx1.ctx_;
- nr_ice_peer_ctx *tmp_peer_ctx = ctx1.peer_;
- nr_ice_handler_vtbl *tmp_ice_handler_vtbl = ctx1.ice_handler_vtbl_;
- nr_ice_handler *tmp_ice_handler = ctx1.ice_handler_;
- bool tmp_trickle = ctx1.trickle_;
- nsCOMPtr<nsIEventTarget> tmp_sts_target = ctx1.sts_target_;
-
- ctx1.connection_state_ = ctx2.connection_state_;
- ctx1.gathering_state_ = ctx2.gathering_state_;
- ctx1.ctx_ = ctx2.ctx_;
- ctx1.peer_ = ctx2.peer_;
- ctx1.ice_handler_vtbl_ = ctx2.ice_handler_vtbl_;
- ctx1.ice_handler_ = ctx2.ice_handler_;
- if (ctx1.ice_handler_) {
- ctx1.ice_handler_->obj = &ctx1;
- }
- ctx1.trickle_ = ctx2.trickle_;
- ctx1.sts_target_ = ctx2.sts_target_;
-
- ctx2.connection_state_ = tmp_connection_state;
- ctx2.gathering_state_ = tmp_gathering_state;
- ctx2.ctx_ = tmp_ctx;
- ctx2.peer_ = tmp_peer_ctx;
- ctx2.ice_handler_vtbl_ = tmp_ice_handler_vtbl;
- ctx2.ice_handler_ = tmp_ice_handler;
- if (ctx2.ice_handler_) {
- ctx2.ice_handler_->obj = &ctx2;
- }
- ctx2.trickle_ = tmp_trickle;
- ctx2.sts_target_ = tmp_sts_target;
+ return NrIceMediaStream::Create(this->current_ctx, os.str(), components);
}
void
NrIceCtxHandler::BeginIceRestart()
{
- std::string ufrag = GetNewUfrag();
- std::string pwd = GetNewPwd();
+ std::string ufrag = NrIceCtx::GetNewUfrag();
+ std::string pwd = NrIceCtx::GetNewPwd();
BeginIceRestart(ufrag, pwd);
}
+
void
NrIceCtxHandler::BeginIceRestart(const std::string& ufrag,
const std::string& pwd)
{
MOZ_ASSERT(!restart_ctx, "existing ice restart in progress");
- RefPtr<NrIceCtxHandler> new_ctx = new NrIceCtxHandler(name_, offerer_, policy_);
+ RefPtr<NrIceCtx> new_ctx = new NrIceCtx(this->current_ctx->name(),
+ this->current_ctx->offerer(),
+ this->current_ctx->policy());
// reconstitute the hide_non_default bool based on the flags stored in the
// original ctx flags
- bool hide_non_default = ctx_->flags & NR_ICE_CTX_FLAGS_ONLY_DEFAULT_ADDRS;
+ bool hide_non_default = current_ctx->ctx()->flags & NR_ICE_CTX_FLAGS_ONLY_DEFAULT_ADDRS;
- SwapContextData(*new_ctx, *this);
-
- NrIceCtx::Initialize(this,
+ NrIceCtx::Initialize(new_ctx,
hide_non_default,
ufrag,
pwd);
++restart_count;
- restart_ctx = new_ctx;
+ restart_ctx = current_ctx;
+ current_ctx = new_ctx;
}
void
NrIceCtxHandler::FinalizeIceRestart()
{
// no harm calling this even if we're not in the middle of restarting
restart_ctx = nullptr;
@@ -133,14 +99,14 @@ NrIceCtxHandler::FinalizeIceRestart()
void
NrIceCtxHandler::RollbackIceRestart()
{
if (restart_ctx == nullptr) {
return;
}
- SwapContextData(*restart_ctx, *this);
+ current_ctx = restart_ctx;
restart_ctx = nullptr;
}
} // close namespace--- a/media/mtransport/nricectxhandler.h
+++ b/media/mtransport/nricectxhandler.h
@@ -1,49 +1,49 @@
#ifndef nricectxhandler_h__
#define nricectxhandler_h__
#include "nricectx.h"
namespace mozilla {
-class NrIceCtxHandler : public NrIceCtx {
+class NrIceCtxHandler {
public:
// TODO(ekr@rtfm.com): Too many bools here. Bug 1193437.
static RefPtr<NrIceCtxHandler> Create(const std::string& name,
bool offerer,
bool allow_loopback = false,
bool tcp_enabled = true,
bool allow_link_local = false,
bool hide_non_default = false,
- Policy policy = ICE_POLICY_ALL);
+ NrIceCtx::Policy policy = NrIceCtx::ICE_POLICY_ALL);
- // Create a media stream
RefPtr<NrIceMediaStream> CreateStream(const std::string& name,
int components);
+ RefPtr<NrIceCtx> ctx() { return current_ctx; }
+
void BeginIceRestart(); // used in testing
void BeginIceRestart(const std::string& ufrag,
const std::string& pwd);
bool IsRestarting() { return (restart_ctx != nullptr); }
void FinalizeIceRestart();
void RollbackIceRestart();
-protected:
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(NrIceCtxHandler)
+
+private:
NrIceCtxHandler(const std::string& name,
bool offerer,
- Policy policy)
- : NrIceCtx(name, offerer, policy),
- restart_ctx(nullptr), restart_count(0) {}
-
+ NrIceCtx::Policy policy);
NrIceCtxHandler(); // disable
- virtual ~NrIceCtxHandler();
+ ~NrIceCtxHandler() {}
+ DISALLOW_COPY_ASSIGN(NrIceCtxHandler);
- void SwapContextData(NrIceCtxHandler& ctx1, NrIceCtxHandler& ctx2);
-
-private:
- RefPtr<NrIceCtxHandler> restart_ctx; // for while restart is in progress
+ RefPtr<NrIceCtx> current_ctx;
+ RefPtr<NrIceCtx> restart_ctx; // for while restart is in progress
int restart_count; // used to differentiate streams between restarted ctx
};
} // close namespace
#endif // nricectxhandler_h__--- a/media/mtransport/test/ice_unittest.cpp
+++ b/media/mtransport/test/ice_unittest.cpp
@@ -303,66 +303,66 @@ class IceTestPeer : public sigslot::has_
candidate_filter_(nullptr),
expected_local_type_(NrIceCandidate::ICE_HOST),
expected_local_transport_(kNrIceTransportUdp),
expected_remote_type_(NrIceCandidate::ICE_HOST),
trickle_mode_(TRICKLE_NONE),
trickled_(0),
simulate_ice_lite_(false),
nat_(new TestNat) {
- ice_ctx_->SignalGatheringStateChange.connect(
+ ice_ctx_->ctx()->SignalGatheringStateChange.connect(
this,
&IceTestPeer::GatheringStateChange);
- ice_ctx_->SignalConnectionStateChange.connect(
+ ice_ctx_->ctx()->SignalConnectionStateChange.connect(
this,
&IceTestPeer::ConnectionStateChange);
nr_socket_factory *fac;
int r = nat_->create_socket_factory(&fac);
MOZ_ASSERT(!r);
if (!r) {
- nr_ice_ctx_set_socket_factory(ice_ctx_->ctx(), fac);
+ nr_ice_ctx_set_socket_factory(ice_ctx_->ctx()->ctx(), fac);
}
}
~IceTestPeer() {
test_utils->sts_target()->Dispatch(WrapRunnable(this,
&IceTestPeer::Shutdown),
NS_DISPATCH_SYNC);
// Give the ICE destruction callback time to fire before
// we destroy the resolver.
PR_Sleep(1000);
}
void AddStream_s(int components) {
char name[100];
snprintf(name, sizeof(name), "%s:stream%d", name_.c_str(),
- (int)ice_ctx_->GetStreamCount());
+ (int)ice_ctx_->ctx()->GetStreamCount());
RefPtr<NrIceMediaStream> stream =
ice_ctx_->CreateStream(static_cast<char *>(name), components);
- ice_ctx_->SetStream(ice_ctx_->GetStreamCount(), stream);
+ ice_ctx_->ctx()->SetStream(ice_ctx_->ctx()->GetStreamCount(), stream);
ASSERT_TRUE(stream);
stream->SignalCandidate.connect(this, &IceTestPeer::CandidateInitialized);
stream->SignalReady.connect(this, &IceTestPeer::StreamReady);
stream->SignalFailed.connect(this, &IceTestPeer::StreamFailed);
stream->SignalPacketReceived.connect(this, &IceTestPeer::PacketReceived);
}
void AddStream(int components)
{
test_utils->sts_target()->Dispatch(
WrapRunnable(this, &IceTestPeer::AddStream_s, components),
NS_DISPATCH_SYNC);
}
void RemoveStream_s(size_t index) {
- ice_ctx_->SetStream(index, nullptr);
+ ice_ctx_->ctx()->SetStream(index, nullptr);
}
void RemoveStream(size_t index) {
test_utils->sts_target()->Dispatch(
WrapRunnable(this, &IceTestPeer::RemoveStream_s, index),
NS_DISPATCH_SYNC);
}
@@ -376,17 +376,17 @@ class IceTestPeer : public sigslot::has_
std::vector<NrIceStunServer> stun_servers;
ScopedDeletePtr<NrIceStunServer> server(NrIceStunServer::Create(
addr, port, transport));
stun_servers.push_back(*server);
SetStunServers(stun_servers);
}
void SetStunServers(const std::vector<NrIceStunServer> &servers) {
- ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->SetStunServers(servers)));
+ ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetStunServers(servers)));
}
void UseTestStunServer() {
SetStunServer(TestStunServer::GetInstance(AF_INET)->addr(),
TestStunServer::GetInstance(AF_INET)->port());
}
void SetTurnServer(const std::string addr, uint16_t port,
@@ -401,48 +401,48 @@ class IceTestPeer : public sigslot::has_
void SetTurnServer(const std::string addr, uint16_t port,
const std::string username,
const std::vector<unsigned char> password,
const char* transport) {
std::vector<NrIceTurnServer> turn_servers;
ScopedDeletePtr<NrIceTurnServer> server(NrIceTurnServer::Create(
addr, port, username, password, transport));
turn_servers.push_back(*server);
- ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->SetTurnServers(turn_servers)));
+ ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetTurnServers(turn_servers)));
}
void SetTurnServers(const std::vector<NrIceTurnServer> servers) {
- ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->SetTurnServers(servers)));
+ ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetTurnServers(servers)));
}
void SetFakeResolver(const std::string& ip = g_stun_server_address,
const std::string& fqdn = g_stun_server_hostname) {
ASSERT_TRUE(NS_SUCCEEDED(dns_resolver_->Init()));
if (!ip.empty() && !fqdn.empty()) {
PRNetAddr addr;
PRStatus status = PR_StringToNetAddr(ip.c_str(), &addr);
addr.inet.port = kDefaultStunServerPort;
ASSERT_EQ(PR_SUCCESS, status);
fake_resolver_.SetAddr(fqdn, addr);
}
- ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->SetResolver(
+ ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetResolver(
fake_resolver_.AllocateResolver())));
}
void SetDNSResolver() {
ASSERT_TRUE(NS_SUCCEEDED(dns_resolver_->Init()));
- ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->SetResolver(
+ ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetResolver(
dns_resolver_->AllocateResolver())));
}
void Gather() {
nsresult res;
test_utils->sts_target()->Dispatch(
- WrapRunnableRet(&res, ice_ctx_, &NrIceCtx::StartGathering),
+ WrapRunnableRet(&res, ice_ctx_->ctx(), &NrIceCtx::StartGathering),
NS_DISPATCH_SYNC);
ASSERT_TRUE(NS_SUCCEEDED(res));
}
void UseNat() {
nat_->enabled_ = true;
}
@@ -459,17 +459,17 @@ class IceTestPeer : public sigslot::has_
void SetBlockUdp(bool block) {
MOZ_ASSERT(!nat_->has_port_mappings());
nat_->block_udp_ = block;
}
// Get various pieces of state
std::vector<std::string> GetGlobalAttributes() {
- std::vector<std::string> attrs(ice_ctx_->GetGlobalAttributes());
+ std::vector<std::string> attrs(ice_ctx_->ctx()->GetGlobalAttributes());
if (simulate_ice_lite_) {
attrs.push_back("ice-lite");
}
return attrs;
}
std::vector<std::string> GetCandidates(size_t stream) {
std::vector<std::string> v;
@@ -486,23 +486,24 @@ class IceTestPeer : public sigslot::has_
return candidate_filter_(candidate);
}
return candidate;
}
std::vector<std::string> GetCandidates_s(size_t stream) {
std::vector<std::string> candidates;
- if (stream >= ice_ctx_->GetStreamCount() || !ice_ctx_->GetStream(stream)) {
+ if (stream >= ice_ctx_->ctx()->GetStreamCount() ||
+ !ice_ctx_->ctx()->GetStream(stream)) {
EXPECT_TRUE(false) << "No such stream " << stream;
return candidates;
}
std::vector<std::string> candidates_in =
- ice_ctx_->GetStream(stream)->GetCandidates();
+ ice_ctx_->ctx()->GetStream(stream)->GetCandidates();
for (size_t i=0; i < candidates_in.size(); i++) {
std::string candidate(FilterCandidate(candidates_in[i]));
if (!candidate.empty()) {
std::cerr << name_ << " Returning candidate: " << candidate << std::endl;
candidates.push_back(candidate);
}
}
@@ -546,21 +547,21 @@ class IceTestPeer : public sigslot::has_
}
}
return host_net;
}
bool gathering_complete() { return gathering_complete_; }
int ready_ct() { return ready_ct_; }
bool is_ready_s(size_t stream) {
- if (!ice_ctx_->GetStream(stream)) {
+ if (!ice_ctx_->ctx()->GetStream(stream)) {
EXPECT_TRUE(false) << "No such stream " << stream;
return false;
}
- return ice_ctx_->GetStream(stream)->state() == NrIceMediaStream::ICE_OPEN;
+ return ice_ctx_->ctx()->GetStream(stream)->state() == NrIceMediaStream::ICE_OPEN;
}
bool is_ready(size_t stream)
{
bool result;
test_utils->sts_target()->Dispatch(
WrapRunnableRet(&result, this, &IceTestPeer::is_ready_s, stream),
NS_DISPATCH_SYNC);
return result;
@@ -576,16 +577,25 @@ class IceTestPeer : public sigslot::has_
test_utils->sts_target()->Dispatch(
WrapRunnable(this, &IceTestPeer::RestartIce_s),
NS_DISPATCH_SYNC);
}
void RestartIce_s() {
ice_ctx_->BeginIceRestart();
+
+ // set signals for the newly restarted ctx
+ ice_ctx_->ctx()->SignalGatheringStateChange.connect(
+ this,
+ &IceTestPeer::GatheringStateChange);
+ ice_ctx_->ctx()->SignalConnectionStateChange.connect(
+ this,
+ &IceTestPeer::ConnectionStateChange);
+
// take care of some local bookkeeping
ready_ct_ = 0;
gathering_complete_ = false;
ice_complete_ = false;
ice_reached_checking_ = false;
remote_ = nullptr;
}
@@ -619,52 +629,52 @@ class IceTestPeer : public sigslot::has_
bool start = true) {
nsresult res;
remote_ = remote;
trickle_mode_ = trickle_mode;
ice_complete_ = false;
ice_reached_checking_ = false;
- res = ice_ctx_->ParseGlobalAttributes(remote->GetGlobalAttributes());
+ res = ice_ctx_->ctx()->ParseGlobalAttributes(remote->GetGlobalAttributes());
ASSERT_TRUE(NS_SUCCEEDED(res));
if (trickle_mode == TRICKLE_NONE ||
trickle_mode == TRICKLE_REAL) {
- for (size_t i=0; i<ice_ctx_->GetStreamCount(); ++i) {
- RefPtr<NrIceMediaStream> aStream = ice_ctx_->GetStream(i);
+ for (size_t i=0; i<ice_ctx_->ctx()->GetStreamCount(); ++i) {
+ RefPtr<NrIceMediaStream> aStream = ice_ctx_->ctx()->GetStream(i);
if (!aStream || aStream->HasParsedAttributes()) {
continue;
}
std::vector<std::string> candidates =
remote->GetCandidates(i);
for (size_t j=0; j<candidates.size(); ++j) {
std::cerr << name_ << " Candidate: " + candidates[j] << std::endl;
}
res = aStream->ParseAttributes(candidates);
ASSERT_TRUE(NS_SUCCEEDED(res));
}
} else {
// Parse empty attributes and then trickle them out later
- for (size_t i=0; i<ice_ctx_->GetStreamCount(); ++i) {
- RefPtr<NrIceMediaStream> aStream = ice_ctx_->GetStream(i);
+ for (size_t i=0; i<ice_ctx_->ctx()->GetStreamCount(); ++i) {
+ RefPtr<NrIceMediaStream> aStream = ice_ctx_->ctx()->GetStream(i);
if (!aStream || aStream->HasParsedAttributes()) {
continue;
}
std::vector<std::string> empty_attrs;
std::cout << "Calling ParseAttributes on stream " << i << std::endl;
res = aStream->ParseAttributes(empty_attrs);
ASSERT_TRUE(NS_SUCCEEDED(res));
}
}
if (start) {
// Now start checks
- res = ice_ctx_->StartChecks();
+ res = ice_ctx_->ctx()->StartChecks();
ASSERT_TRUE(NS_SUCCEEDED(res));
}
}
void Connect(IceTestPeer *remote, TrickleMode trickle_mode,
bool start = true) {
test_utils->sts_target()->Dispatch(
WrapRunnable(
@@ -674,18 +684,18 @@ class IceTestPeer : public sigslot::has_
void SimulateTrickle(size_t stream) {
std::cerr << name_ << " Doing trickle for stream " << stream << std::endl;
// If we are in trickle deferred mode, now trickle in the candidates
// for |stream|
// The size of streams is not going to change out from under us, so should
// be safe here.
- ASSERT_GT(remote_->ice_ctx_->GetStreamCount(), stream);
- ASSERT_TRUE(remote_->ice_ctx_->GetStream(stream).get());
+ ASSERT_GT(remote_->ice_ctx_->ctx()->GetStreamCount(), stream);
+ ASSERT_TRUE(remote_->ice_ctx_->ctx()->GetStream(stream).get());
std::vector<SchedulableTrickleCandidate*>& candidates =
ControlTrickle(stream);
for (auto i = candidates.begin(); i != candidates.end(); ++i) {
(*i)->Schedule(0);
}
}
@@ -703,21 +713,21 @@ class IceTestPeer : public sigslot::has_
controlled_trickle_candidates_[stream].push_back(
new SchedulableTrickleCandidate(this, stream, candidates[j]));
}
return controlled_trickle_candidates_[stream];
}
nsresult TrickleCandidate_s(const std::string &candidate, size_t stream) {
- if (!ice_ctx_->GetStream(stream)) {
+ if (!ice_ctx_->ctx()->GetStream(stream)) {
// stream might have gone away before the trickle timer popped
return NS_OK;
}
- return ice_ctx_->GetStream(stream)->ParseTrickleCandidate(candidate);
+ return ice_ctx_->ctx()->GetStream(stream)->ParseTrickleCandidate(candidate);
}
void DumpCandidate(std::string which, const NrIceCandidate& cand) {
std::string type;
std::string tcp_type;
std::string addr;
int port;
@@ -779,28 +789,30 @@ class IceTestPeer : public sigslot::has_
<< tcp_type
<< " codeword="
<< cand.codeword
<< std::endl;
}
void DumpAndCheckActiveCandidates_s() {
std::cerr << name_ << " Active candidates:" << std::endl;
- for (size_t i=0; i < ice_ctx_->GetStreamCount(); ++i) {
- if (!ice_ctx_->GetStream(i)) {
+ for (size_t i=0; i < ice_ctx_->ctx()->GetStreamCount(); ++i) {
+ if (!ice_ctx_->ctx()->GetStream(i)) {
continue;
}
- for (size_t j=0; j < ice_ctx_->GetStream(i)->components(); ++j) {
+ for (size_t j=0; j < ice_ctx_->ctx()->GetStream(i)->components(); ++j) {
std::cerr << name_ << " Stream " << i << " component " << j+1 << std::endl;
NrIceCandidate *local;
NrIceCandidate *remote;
- nsresult res = ice_ctx_->GetStream(i)->GetActivePair(j+1, &local, &remote);
+ nsresult res = ice_ctx_->ctx()->GetStream(i)->GetActivePair(j+1,
+ &local,
+ &remote);
if (res == NS_ERROR_NOT_AVAILABLE) {
std::cerr << "Component unpaired or disabled." << std::endl;
} else {
ASSERT_TRUE(NS_SUCCEEDED(res));
DumpCandidate("Local ", *local);
/* Depending on timing, and the whims of the network
* stack/configuration we're running on top of, prflx is always a
* possibility. */
@@ -834,17 +846,17 @@ class IceTestPeer : public sigslot::has_
void DumpAndCheckActiveCandidates() {
test_utils->sts_target()->Dispatch(
WrapRunnable(this, &IceTestPeer::DumpAndCheckActiveCandidates_s),
NS_DISPATCH_SYNC);
}
void Close() {
test_utils->sts_target()->Dispatch(
- WrapRunnable(ice_ctx_, &NrIceCtx::destroy_peer_ctx),
+ WrapRunnable(ice_ctx_->ctx(), &NrIceCtx::destroy_peer_ctx),
NS_DISPATCH_SYNC);
}
void Shutdown() {
std::cerr << name_ << " Shutdown" << std::endl;
for (auto s = controlled_trickle_candidates_.begin();
s != controlled_trickle_candidates_.end();
++s) {
@@ -866,43 +878,43 @@ class IceTestPeer : public sigslot::has_
remote_ = nullptr;
}
void StartChecks() {
nsresult res;
// Now start checks
test_utils->sts_target()->Dispatch(
- WrapRunnableRet(&res, ice_ctx_, &NrIceCtx::StartChecks),
+ WrapRunnableRet(&res, ice_ctx_->ctx(), &NrIceCtx::StartChecks),
NS_DISPATCH_SYNC);
ASSERT_TRUE(NS_SUCCEEDED(res));
}
// Handle events
void GatheringStateChange(NrIceCtx* ctx,
NrIceCtx::GatheringState state) {
(void)ctx;
if (state != NrIceCtx::ICE_CTX_GATHER_COMPLETE) {
return;
}
std::cerr << "Gathering complete for " << name_ << std::endl;
gathering_complete_ = true;
std::cerr << name_ << " CANDIDATES:" << std::endl;
- for (size_t i=0; i<ice_ctx_->GetStreamCount(); ++i) {
+ for (size_t i=0; i<ice_ctx_->ctx()->GetStreamCount(); ++i) {
std::cerr << "Stream " << name_ << std::endl;
- if (!ice_ctx_->GetStream(i)) {
+ if (!ice_ctx_->ctx()->GetStream(i)) {
std::cerr << "DISABLED" << std::endl;
continue;
}
std::vector<std::string> candidates =
- ice_ctx_->GetStream(i)->GetCandidates();
+ ice_ctx_->ctx()->GetStream(i)->GetCandidates();
for(size_t j=0; j<candidates.size(); ++j) {
std::cerr << candidates[j] << std::endl;
}
}
std::cerr << std::endl;
}
@@ -916,43 +928,45 @@ class IceTestPeer : public sigslot::has_
<< candidate << std::endl;
candidates_[stream->name()].push_back(candidate);
// If we are connected, then try to trickle to the other side.
if (remote_ && remote_->remote_ && (trickle_mode_ != TRICKLE_SIMULATE)) {
// first, find the index of the stream we've been given so
// we can get the corresponding stream on the remote side
size_t index = -1;
- for (size_t i=0; i<ice_ctx_->GetStreamCount(); ++i) {
- if (ice_ctx_->GetStream(i) == stream) {
+ for (size_t i=0; i<ice_ctx_->ctx()->GetStreamCount(); ++i) {
+ if (ice_ctx_->ctx()->GetStream(i) == stream) {
index = i;
break;
}
}
- ASSERT_NE(index, -1u);
-
- ASSERT_GT(remote_->ice_ctx_->GetStreamCount(), index);
- nsresult res = remote_->ice_ctx_->GetStream(index)->ParseTrickleCandidate(
+ ASSERT_NE(index, -1);
+
+ ASSERT_GT(remote_->ice_ctx_->ctx()->GetStreamCount(), index);
+ nsresult res =
+ remote_->ice_ctx_->ctx()->GetStream(index)->ParseTrickleCandidate(
candidate);
ASSERT_TRUE(NS_SUCCEEDED(res));
++trickled_;
}
}
nsresult GetCandidatePairs_s(size_t stream_index,
std::vector<NrIceCandidatePair>* pairs)
{
MOZ_ASSERT(pairs);
- if (stream_index >= ice_ctx_->GetStreamCount() || !ice_ctx_->GetStream(stream_index)) {
+ if (stream_index >= ice_ctx_->ctx()->GetStreamCount() ||
+ !ice_ctx_->ctx()->GetStream(stream_index)) {
// Is there a better error for "no such index"?
ADD_FAILURE() << "No such media stream index: " << stream_index;
return NS_ERROR_INVALID_ARG;
}
- return ice_ctx_->GetStream(stream_index)->GetCandidatePairs(pairs);
+ return ice_ctx_->ctx()->GetStream(stream_index)->GetCandidatePairs(pairs);
}
nsresult GetCandidatePairs(size_t stream_index,
std::vector<NrIceCandidatePair>* pairs) {
nsresult v;
test_utils->sts_target()->Dispatch(
WrapRunnableRet(&v, this,
&IceTestPeer::GetCandidatePairs_s,
@@ -984,21 +998,21 @@ class IceTestPeer : public sigslot::has_
p != pairs.end(); ++p) {
DumpCandidatePair(*p);
}
std::cerr << "]" << std::endl;
}
void DumpCandidatePairs_s() {
std::cerr << "Dumping candidate pairs for all streams [" << std::endl;
- for (size_t s = 0; s < ice_ctx_->GetStreamCount(); ++s) {
- if (!ice_ctx_->GetStream(s)) {
+ for (size_t s = 0; s < ice_ctx_->ctx()->GetStreamCount(); ++s) {
+ if (!ice_ctx_->ctx()->GetStream(s)) {
continue;
}
- DumpCandidatePairs_s(ice_ctx_->GetStream(s).get());
+ DumpCandidatePairs_s(ice_ctx_->ctx()->GetStream(s).get());
}
std::cerr << "]" << std::endl;
}
bool CandidatePairsPriorityDescending(const std::vector<NrIceCandidatePair>&
pairs) {
// Verify that priority is descending
uint64_t priority = std::numeric_limits<uint64_t>::max();
@@ -1107,54 +1121,55 @@ class IceTestPeer : public sigslot::has_
void PacketReceived(NrIceMediaStream *stream, int component, const unsigned char *data,
int len) {
std::cerr << name_ << ": received " << len << " bytes" << std::endl;
++received_;
}
void SendPacket(int stream, int component, const unsigned char *data,
int len) {
- if (!ice_ctx_->GetStream(stream)) {
+ if (!ice_ctx_->ctx()->GetStream(stream)) {
ADD_FAILURE() << "No such stream " << stream;
return;
}
- ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->GetStream(stream)->SendPacket(component, data, len)));
+ ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->GetStream(stream)->SendPacket(component, data, len)));
++sent_;
std::cerr << name_ << ": sent " << len << " bytes" << std::endl;
}
void SetCandidateFilter(CandidateFilter filter) {
candidate_filter_ = filter;
}
void ParseCandidate_s(size_t i, const std::string& candidate) {
- ASSERT_TRUE(ice_ctx_->GetStream(i).get()) << "No such stream " << i;
+ ASSERT_TRUE(ice_ctx_->ctx()->GetStream(i).get()) << "No such stream " << i;
std::vector<std::string> attributes;
attributes.push_back(candidate);
- ice_ctx_->GetStream(i)->ParseAttributes(attributes);
+ ice_ctx_->ctx()->GetStream(i)->ParseAttributes(attributes);
}
void ParseCandidate(size_t i, const std::string& candidate)
{
test_utils->sts_target()->Dispatch(
WrapRunnable(this,
&IceTestPeer::ParseCandidate_s,
i,
candidate),
NS_DISPATCH_SYNC);
}
void DisableComponent_s(size_t stream, int component_id) {
- ASSERT_LT(stream, ice_ctx_->GetStreamCount());
- ASSERT_TRUE(ice_ctx_->GetStream(stream).get()) << "No such stream " << stream;
- nsresult res = ice_ctx_->GetStream(stream)->DisableComponent(component_id);
+ ASSERT_LT(stream, ice_ctx_->ctx()->GetStreamCount());
+ ASSERT_TRUE(ice_ctx_->ctx()->GetStream(stream).get()) << "No such stream " << stream;
+ nsresult res =
+ ice_ctx_->ctx()->GetStream(stream)->DisableComponent(component_id);
ASSERT_TRUE(NS_SUCCEEDED(res));
}
void DisableComponent(size_t stream, int component_id)
{
test_utils->sts_target()->Dispatch(
WrapRunnable(this,
&IceTestPeer::DisableComponent_s,
@@ -1163,33 +1178,33 @@ class IceTestPeer : public sigslot::has_
NS_DISPATCH_SYNC);
}
int trickled() { return trickled_; }
void SetControlling(NrIceCtx::Controlling controlling) {
nsresult res;
test_utils->sts_target()->Dispatch(
- WrapRunnableRet(&res, ice_ctx_,
+ WrapRunnableRet(&res, ice_ctx_->ctx(),
&NrIceCtx::SetControlling,
controlling),
NS_DISPATCH_SYNC);
ASSERT_TRUE(NS_SUCCEEDED(res));
}
void SetTiebreaker(uint64_t tiebreaker) {
test_utils->sts_target()->Dispatch(
WrapRunnable(this,
&IceTestPeer::SetTiebreaker_s,
tiebreaker),
NS_DISPATCH_SYNC);
}
void SetTiebreaker_s(uint64_t tiebreaker) {
- ice_ctx_->peer()->tiebreaker = tiebreaker;
+ ice_ctx_->ctx()->peer()->tiebreaker = tiebreaker;
}
void SimulateIceLite() {
simulate_ice_lite_ = true;
SetControlling(NrIceCtx::ICE_CONTROLLED);
}
nsresult GetDefaultCandidate(unsigned int stream, NrIceCandidate* cand) {
@@ -1200,17 +1215,17 @@ class IceTestPeer : public sigslot::has_
&IceTestPeer::GetDefaultCandidate_s,
stream, cand),
NS_DISPATCH_SYNC);
return rv;
}
nsresult GetDefaultCandidate_s(unsigned int stream, NrIceCandidate* cand) {
- return ice_ctx_->GetStream(stream)->GetDefaultCandidate(1, cand);
+ return ice_ctx_->ctx()->GetStream(stream)->GetDefaultCandidate(1, cand);
}
private:
std::string name_;
RefPtr<NrIceCtxHandler> ice_ctx_;
std::map<std::string, std::vector<std::string> > candidates_;
// Maps from stream id to list of remote trickle candidates
std::map<size_t, std::vector<SchedulableTrickleCandidate*> >--- a/media/mtransport/test/multi_tcp_socket_unittest.cpp
+++ b/media/mtransport/test/multi_tcp_socket_unittest.cpp
@@ -95,26 +95,26 @@ class MultiTcpSocketTest : public ::test
int r;
if (!stun_server_addr.empty()) {
std::vector<NrIceStunServer> stun_servers;
ScopedDeletePtr<NrIceStunServer> server(NrIceStunServer::Create(
stun_server_addr, stun_server_port, kNrIceTransportTcp));
stun_servers.push_back(*server);
- ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->SetStunServers(stun_servers)));
+ ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetStunServers(stun_servers)));
}
r = 1;
for (int tries=10; tries && r; --tries) {
r = nr_str_port_to_transport_addr(
(char *)"127.0.0.1", EnsureEphemeral(port_s++), IPPROTO_TCP, &local);
ASSERT_EQ(0, r);
- r = nr_socket_multi_tcp_create(ice_ctx_->ctx(),
+ r = nr_socket_multi_tcp_create(ice_ctx_->ctx()->ctx(),
&local, tcp_type, 1, 2048, sock);
}
ASSERT_EQ(0, r);
printf("Creating socket on %s\n", local.as_string);
r = nr_socket_multi_tcp_set_readable_cb(*sock,
&MultiTcpSocketTest::SockReadable, this);
ASSERT_EQ(0, r);
@@ -334,17 +334,17 @@ class MultiTcpSocketTest : public ::test
bool IsReadable() const {
return readable;
}
void SetReadable(bool r) {
readable=r;
}
std::vector<nr_socket *> socks;
Atomic<bool> readable;
- RefPtr<NrIceCtx> ice_ctx_;
+ RefPtr<NrIceCtxHandler> ice_ctx_;
};
}
TEST_F(MultiTcpSocketTest, TestListen) {
socks[0] = Create(TCP_TYPE_PASSIVE);
Listen(socks[0]);
}
--- a/media/mtransport/test/transport_unittests.cpp
+++ b/media/mtransport/test/transport_unittests.cpp
@@ -455,17 +455,17 @@ class TransportTestPeer : public sigslot
gathering_complete_(false),
enabled_cipersuites_(),
disabled_cipersuites_(),
reuse_dhe_key_(false) {
std::vector<NrIceStunServer> stun_servers;
UniquePtr<NrIceStunServer> server(NrIceStunServer::Create(
std::string((char *)"stun.services.mozilla.com"), 3478));
stun_servers.push_back(*server);
- EXPECT_TRUE(NS_SUCCEEDED(ice_ctx_->SetStunServers(stun_servers)));
+ EXPECT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetStunServers(stun_servers)));
dtls_->SetIdentity(identity_);
dtls_->SetRole(name == "P2" ?
TransportLayerDtls::CLIENT :
TransportLayerDtls::SERVER);
nsresult res = identity_->ComputeFingerprint("sha-1",
fingerprint_,
@@ -598,38 +598,38 @@ class TransportTestPeer : public sigslot
peer),
NS_DISPATCH_SYNC);
}
void InitIce() {
nsresult res;
// Attach our slots
- ice_ctx_->SignalGatheringStateChange.
+ ice_ctx_->ctx()->SignalGatheringStateChange.
connect(this, &TransportTestPeer::GatheringStateChange);
char name[100];
snprintf(name, sizeof(name), "%s:stream%d", name_.c_str(),
(int)streams_.size());
// Create the media stream
RefPtr<NrIceMediaStream> stream =
ice_ctx_->CreateStream(static_cast<char *>(name), 1);
ASSERT_TRUE(stream != nullptr);
- ice_ctx_->SetStream(streams_.size(), stream);
+ ice_ctx_->ctx()->SetStream(streams_.size(), stream);
streams_.push_back(stream);
// Listen for candidates
stream->SignalCandidate.
connect(this, &TransportTestPeer::GotCandidate);
// Create the transport layer
ice_ = new TransportLayerIce(name);
- ice_->SetParameters(ice_ctx_, stream, 1);
+ ice_->SetParameters(ice_ctx_->ctx(), stream, 1);
// Assemble the stack
nsAutoPtr<std::queue<mozilla::TransportLayer *> > layers(
new std::queue<mozilla::TransportLayer *>);
layers->push(ice_);
layers->push(dtls_);
test_utils->sts_target()->Dispatch(
@@ -639,17 +639,17 @@ class TransportTestPeer : public sigslot
ASSERT_EQ((nsresult)NS_OK, res);
// Listen for media events
flow_->SignalPacketReceived.connect(this, &TransportTestPeer::PacketReceived);
flow_->SignalStateChange.connect(this, &TransportTestPeer::StateChanged);
// Start gathering
test_utils->sts_target()->Dispatch(
- WrapRunnableRet(&res, ice_ctx_, &NrIceCtx::StartGathering),
+ WrapRunnableRet(&res, ice_ctx_->ctx(), &NrIceCtx::StartGathering),
NS_DISPATCH_SYNC);
ASSERT_TRUE(NS_SUCCEEDED(res));
}
void ConnectIce(TransportTestPeer *peer) {
peer_ = peer;
// If gathering is already complete, push the candidates over
@@ -679,33 +679,33 @@ class TransportTestPeer : public sigslot
// Don't send to the other side
if (!peer_) {
gathering_complete_ = true;
return;
}
// First send attributes
test_utils->sts_target()->Dispatch(
- WrapRunnableRet(&res, peer_->ice_ctx_,
+ WrapRunnableRet(&res, peer_->ice_ctx_->ctx(),
&NrIceCtx::ParseGlobalAttributes,
- ice_ctx_->GetGlobalAttributes()),
+ ice_ctx_->ctx()->GetGlobalAttributes()),
NS_DISPATCH_SYNC);
ASSERT_TRUE(NS_SUCCEEDED(res));
for (size_t i=0; i<streams_.size(); ++i) {
test_utils->sts_target()->Dispatch(
WrapRunnableRet(&res, peer_->streams_[i], &NrIceMediaStream::ParseAttributes,
candidates_[streams_[i]->name()]), NS_DISPATCH_SYNC);
ASSERT_TRUE(NS_SUCCEEDED(res));
}
// Start checks on the other peer.
test_utils->sts_target()->Dispatch(
- WrapRunnableRet(&res, peer_->ice_ctx_, &NrIceCtx::StartChecks),
+ WrapRunnableRet(&res, peer_->ice_ctx_->ctx(), &NrIceCtx::StartChecks),
NS_DISPATCH_SYNC);
ASSERT_TRUE(NS_SUCCEEDED(res));
}
TransportResult SendPacket(const unsigned char* data, size_t len) {
TransportResult ret;
test_utils->sts_target()->Dispatch(
WrapRunnableRet(&ret, flow_, &TransportFlow::SendPacket, data, len),--- a/media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.cpp
+++ b/media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.cpp
@@ -182,18 +182,19 @@ NegotiatedDetailsToVideoCodecConfigs(con
static void
FinalizeTransportFlow_s(RefPtr<PeerConnectionMedia> aPCMedia,
RefPtr<TransportFlow> aFlow, size_t aLevel,
bool aIsRtcp,
nsAutoPtr<PtrVector<TransportLayer> > aLayerList)
{
TransportLayerIce* ice =
static_cast<TransportLayerIce*>(aLayerList->values.front());
- ice->SetParameters(
- aPCMedia->ice_ctx(), aPCMedia->ice_media_stream(aLevel), aIsRtcp ? 2 : 1);
+ ice->SetParameters(aPCMedia->ice_ctx(),
+ aPCMedia->ice_media_stream(aLevel),
+ aIsRtcp ? 2 : 1);
nsAutoPtr<std::queue<TransportLayer*> > layerQueue(
new std::queue<TransportLayer*>);
for (auto i = aLayerList->values.begin(); i != aLayerList->values.end();
++i) {
layerQueue->push(*i);
}
aLayerList->values.clear();
(void)aFlow->PushLayers(layerQueue); // TODO(bug 854518): Process errors.
@@ -219,17 +220,17 @@ MediaPipelineFactory::CreateOrGetTranspo
const JsepTransport& aTransport,
RefPtr<TransportFlow>* aFlowOutparam)
{
nsresult rv;
RefPtr<TransportFlow> flow;
flow = mPCMedia->GetTransportFlow(aLevel, aIsRtcp);
if (flow) {
- if (mPCMedia->ice_ctx()->IsRestarting()) {
+ if (mPCMedia->ice_ctx_hdlr()->IsRestarting()) {
MOZ_MTLOG(ML_INFO, "Flow[" << flow->id() << "]: "
<< "detected ICE restart - level: "
<< aLevel << " rtcp: " << aIsRtcp);
rv = mPCMedia->GetSTSThread()->Dispatch(
WrapRunnableNM(AddNewIceStreamForRestart_s,
mPCMedia, flow, aLevel, aIsRtcp),
NS_DISPATCH_NORMAL);--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
@@ -2775,17 +2775,17 @@ PeerConnectionImpl::SetSignalingState_m(
!rollback)) {
mMedia->EnsureTransports(*mJsepSession);
}
mSignalingState = aSignalingState;
bool fireNegotiationNeeded = false;
if (mSignalingState == PCImplSignalingState::SignalingStable) {
- if (rollback && mMedia->ice_ctx()->IsRestarting()) {
+ if (rollback && mMedia->ice_ctx_hdlr()->IsRestarting()) {
mMedia->RollbackIceRestart();
}
// Either negotiation is done, or we've rolled back. In either case, we
// need to re-evaluate whether further negotiation is required.
mNegotiationNeeded = false;
// If we're rolling back a local offer, we might need to remove some
// transports, but nothing further needs to be done.
@@ -3072,17 +3072,17 @@ void PeerConnectionImpl::IceConnectionSt
}
}
#endif
mIceConnectionState = domState;
if (mIceConnectionState == PCImplIceConnectionState::Connected ||
mIceConnectionState == PCImplIceConnectionState::Completed) {
- if (mMedia->ice_ctx()->IsRestarting()) {
+ if (mMedia->ice_ctx_hdlr()->IsRestarting()) {
mMedia->FinalizeIceRestart();
}
}
// Would be nice if we had a means of converting one of these dom enums
// to a string that wasn't almost as much text as this switch statement...
switch (mIceConnectionState) {
case PCImplIceConnectionState::New:--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp
@@ -198,17 +198,17 @@ PeerConnectionMedia::ProtocolProxyQueryH
}
rv = proxyinfo.GetPort(&httpsProxyPort);
if (NS_FAILED(rv)) {
CSFLogError(logTag, "%s: Failed to get proxy server port", __FUNCTION__);
return;
}
- if (pcm_->mIceCtx.get()) {
+ if (pcm_->mIceCtxHdlr.get()) {
assert(httpsProxyPort >= 0 && httpsProxyPort < (1 << 16));
// Note that this could check if PrivacyRequested() is set on the PC and
// remove "webrtc" from the ALPN list. But that would only work if the PC
// was constructed with a peerIdentity constraint, not when isolated
// streams are added. If we ever need to signal to the proxy that the
// media is isolated, then we would need to restructure this code.
pcm_->mProxyServer.reset(
new NrIceProxyServer(httpsProxyHost.get(),
@@ -222,17 +222,17 @@ PeerConnectionMedia::ProtocolProxyQueryH
NS_IMPL_ISUPPORTS(PeerConnectionMedia::ProtocolProxyQueryHandler, nsIProtocolProxyCallback)
#endif // !defined(MOZILLA_XPCOMRT_API)
PeerConnectionMedia::PeerConnectionMedia(PeerConnectionImpl *parent)
: mParent(parent),
mParentHandle(parent->GetHandle()),
mParentName(parent->GetName()),
- mIceCtx(nullptr),
+ mIceCtxHdlr(nullptr),
mDNSResolver(new NrIceResolver()),
mUuidGen(MakeUnique<PCUuidGenerator>()),
mMainThread(mParent->GetMainThread()),
mSTSThread(mParent->GetSTSThread()),
mProxyResolveCompleted(false) {
}
nsresult PeerConnectionMedia::Init(const std::vector<NrIceStunServer>& stun_servers,
@@ -319,58 +319,58 @@ nsresult PeerConnectionMedia::Init(const
#else
bool ice_tcp = false;
bool default_address_only = false;
#endif
// TODO(ekr@rtfm.com): need some way to set not offerer later
// Looks like a bug in the NrIceCtx API.
- mIceCtx = NrIceCtxHandler::Create("PC:" + mParentName,
- true, // Offerer
- mParent->GetAllowIceLoopback(),
- ice_tcp,
- mParent->GetAllowIceLinkLocal(),
- default_address_only,
- policy);
- if(!mIceCtx) {
+ mIceCtxHdlr = NrIceCtxHandler::Create("PC:" + mParentName,
+ true, // Offerer
+ mParent->GetAllowIceLoopback(),
+ ice_tcp,
+ mParent->GetAllowIceLinkLocal(),
+ default_address_only,
+ policy);
+ if(!mIceCtxHdlr) {
CSFLogError(logTag, "%s: Failed to create Ice Context", __FUNCTION__);
return NS_ERROR_FAILURE;
}
- if (NS_FAILED(rv = mIceCtx->SetStunServers(stun_servers))) {
+ if (NS_FAILED(rv = mIceCtxHdlr->ctx()->SetStunServers(stun_servers))) {
CSFLogError(logTag, "%s: Failed to set stun servers", __FUNCTION__);
return rv;
}
// Give us a way to globally turn off TURN support
#if !defined(MOZILLA_EXTERNAL_LINKAGE)
bool disabled = Preferences::GetBool("media.peerconnection.turn.disable", false);
#else
bool disabled = false;
#endif
if (!disabled) {
- if (NS_FAILED(rv = mIceCtx->SetTurnServers(turn_servers))) {
+ if (NS_FAILED(rv = mIceCtxHdlr->ctx()->SetTurnServers(turn_servers))) {
CSFLogError(logTag, "%s: Failed to set turn servers", __FUNCTION__);
return rv;
}
} else if (turn_servers.size() != 0) {
CSFLogError(logTag, "%s: Setting turn servers disabled", __FUNCTION__);
}
if (NS_FAILED(rv = mDNSResolver->Init())) {
CSFLogError(logTag, "%s: Failed to initialize dns resolver", __FUNCTION__);
return rv;
}
- if (NS_FAILED(rv = mIceCtx->SetResolver(mDNSResolver->AllocateResolver()))) {
+ if (NS_FAILED(rv = mIceCtxHdlr->ctx()->SetResolver(mDNSResolver->AllocateResolver()))) {
CSFLogError(logTag, "%s: Failed to get dns resolver", __FUNCTION__);
return rv;
}
- mIceCtx->SignalGatheringStateChange.connect(
+ mIceCtxHdlr->ctx()->SignalGatheringStateChange.connect(
this,
&PeerConnectionMedia::IceGatheringStateChange_s);
- mIceCtx->SignalConnectionStateChange.connect(
+ mIceCtxHdlr->ctx()->SignalConnectionStateChange.connect(
this,
&PeerConnectionMedia::IceConnectionStateChange_s);
return NS_OK;
}
void
PeerConnectionMedia::EnsureTransports(const JsepSession& aSession)
@@ -388,38 +388,38 @@ PeerConnectionMedia::EnsureTransports(co
}
GatherIfReady();
}
void
PeerConnectionMedia::EnsureTransport_s(size_t aLevel, size_t aComponentCount)
{
- RefPtr<NrIceMediaStream> stream(mIceCtx->GetStream(aLevel));
+ RefPtr<NrIceMediaStream> stream(mIceCtxHdlr->ctx()->GetStream(aLevel));
if (!stream) {
CSFLogDebug(logTag, "%s: Creating ICE media stream=%u components=%u",
mParentHandle.c_str(),
static_cast<unsigned>(aLevel),
static_cast<unsigned>(aComponentCount));
std::ostringstream os;
os << mParentName << " aLevel=" << aLevel;
- RefPtr<NrIceMediaStream> stream = mIceCtx->CreateStream(os.str().c_str(),
+ RefPtr<NrIceMediaStream> stream = mIceCtxHdlr->CreateStream(os.str().c_str(),
aComponentCount);
if (!stream) {
CSFLogError(logTag, "Failed to create ICE stream.");
return;
}
stream->SetLevel(aLevel);
stream->SignalReady.connect(this, &PeerConnectionMedia::IceStreamReady_s);
stream->SignalCandidate.connect(this,
&PeerConnectionMedia::OnCandidateFound_s);
- mIceCtx->SetStream(aLevel, stream);
+ mIceCtxHdlr->ctx()->SetStream(aLevel, stream);
}
}
void
PeerConnectionMedia::ActivateOrRemoveTransports(const JsepSession& aSession)
{
auto transports = aSession.GetTransports();
for (size_t i = 0; i < transports.size(); ++i) {
@@ -470,21 +470,21 @@ PeerConnectionMedia::ActivateOrRemoveTra
const std::string& aUfrag,
const std::string& aPassword,
const std::vector<std::string>& aCandidateList) {
if (!aComponentCount) {
CSFLogDebug(logTag, "%s: Removing ICE media stream=%u",
mParentHandle.c_str(),
static_cast<unsigned>(aMLine));
- mIceCtx->SetStream(aMLine, nullptr);
+ mIceCtxHdlr->ctx()->SetStream(aMLine, nullptr);
return;
}
- RefPtr<NrIceMediaStream> stream(mIceCtx->GetStream(aMLine));
+ RefPtr<NrIceMediaStream> stream(mIceCtxHdlr->ctx()->GetStream(aMLine));
if (!stream) {
MOZ_ASSERT(false);
return;
}
if (!stream->HasParsedAttributes()) {
CSFLogDebug(logTag, "%s: Activating ICE media stream=%u components=%u",
mParentHandle.c_str(),
@@ -509,18 +509,18 @@ PeerConnectionMedia::ActivateOrRemoveTra
stream->DisableComponent(c + 1);
}
}
}
void
PeerConnectionMedia::RemoveTransportsAtOrAfter_s(size_t aMLine)
{
- for (size_t i = aMLine; i < mIceCtx->GetStreamCount(); ++i) {
- mIceCtx->SetStream(i, nullptr);
+ for (size_t i = aMLine; i < mIceCtxHdlr->ctx()->GetStreamCount(); ++i) {
+ mIceCtxHdlr->ctx()->SetStream(i, nullptr);
}
}
nsresult PeerConnectionMedia::UpdateMediaPipelines(
const JsepSession& session) {
auto trackPairs = session.GetNegotiatedTrackPairs();
MediaPipelineFactory factory(this);
nsresult rv;
@@ -580,26 +580,26 @@ PeerConnectionMedia::StartIceChecks_s(
if (!aIceOptionsList.empty()) {
attributes.push_back("ice-options:");
for (auto i = aIceOptionsList.begin(); i != aIceOptionsList.end(); ++i) {
attributes.back() += *i + ' ';
}
}
- nsresult rv = mIceCtx->ParseGlobalAttributes(attributes);
+ nsresult rv = mIceCtxHdlr->ctx()->ParseGlobalAttributes(attributes);
if (NS_FAILED(rv)) {
CSFLogError(logTag, "%s: couldn't parse global parameters", __FUNCTION__ );
}
- mIceCtx->SetControlling(aIsControlling ?
+ mIceCtxHdlr->ctx()->SetControlling(aIsControlling ?
NrIceCtx::ICE_CONTROLLING :
NrIceCtx::ICE_CONTROLLED);
- mIceCtx->StartChecks();
+ mIceCtxHdlr->ctx()->StartChecks();
}
void
PeerConnectionMedia::BeginIceRestart(const std::string& ufrag,
const std::string& pwd)
{
ASSERT_ON_THREAD(mMainThread);
@@ -613,17 +613,25 @@ PeerConnectionMedia::BeginIceRestart(con
}
void
PeerConnectionMedia::BeginIceRestart_s(const std::string& ufrag,
const std::string& pwd)
{
ASSERT_ON_THREAD(mSTSThread);
- ice_ctx()->BeginIceRestart(ufrag, pwd);
+ mIceCtxHdlr->BeginIceRestart(ufrag, pwd);
+ if (mIceCtxHdlr->IsRestarting()) {
+ mIceCtxHdlr->ctx()->SignalGatheringStateChange.connect(
+ this,
+ &PeerConnectionMedia::IceGatheringStateChange_s);
+ mIceCtxHdlr->ctx()->SignalConnectionStateChange.connect(
+ this,
+ &PeerConnectionMedia::IceConnectionStateChange_s);
+ }
}
void
PeerConnectionMedia::FinalizeIceRestart()
{
ASSERT_ON_THREAD(mMainThread);
RUN_ON_THREAD(GetSTSThread(),
@@ -633,17 +641,17 @@ PeerConnectionMedia::FinalizeIceRestart(
NS_DISPATCH_NORMAL);
}
void
PeerConnectionMedia::FinalizeIceRestart_s()
{
ASSERT_ON_THREAD(mSTSThread);
- ice_ctx()->FinalizeIceRestart();
+ mIceCtxHdlr->FinalizeIceRestart();
}
void
PeerConnectionMedia::RollbackIceRestart()
{
ASSERT_ON_THREAD(mMainThread);
RUN_ON_THREAD(GetSTSThread(),
@@ -653,17 +661,17 @@ PeerConnectionMedia::RollbackIceRestart(
NS_DISPATCH_NORMAL);
}
void
PeerConnectionMedia::RollbackIceRestart_s()
{
ASSERT_ON_THREAD(mSTSThread);
- ice_ctx()->RollbackIceRestart();
+ mIceCtxHdlr->RollbackIceRestart();
}
void
PeerConnectionMedia::AddIceCandidate(const std::string& candidate,
const std::string& mid,
uint32_t aMLine) {
RUN_ON_THREAD(GetSTSThread(),
WrapRunnable(
@@ -673,17 +681,17 @@ PeerConnectionMedia::AddIceCandidate(con
std::string(mid),
aMLine),
NS_DISPATCH_NORMAL);
}
void
PeerConnectionMedia::AddIceCandidate_s(const std::string& aCandidate,
const std::string& aMid,
uint32_t aMLine) {
- RefPtr<NrIceMediaStream> stream(mIceCtx->GetStream(aMLine));
+ RefPtr<NrIceMediaStream> stream(mIceCtxHdlr->ctx()->GetStream(aMLine));
if (!stream) {
CSFLogError(logTag, "No ICE stream for candidate at level %u: %s",
static_cast<unsigned>(aMLine), aCandidate.c_str());
return;
}
nsresult rv = stream->ParseTrickleCandidate(aCandidate);
if (NS_FAILED(rv)) {
@@ -729,31 +737,32 @@ PeerConnectionMedia::GatherIfReady() {
&PeerConnectionMedia::EnsureIceGathering_s));
PerformOrEnqueueIceCtxOperation(runnable);
}
void
PeerConnectionMedia::EnsureIceGathering_s() {
if (mProxyServer) {
- mIceCtx->SetProxyServer(*mProxyServer);
+ mIceCtxHdlr->ctx()->SetProxyServer(*mProxyServer);
}
// Start gathering, but only if there are streams
- for (size_t i = 0; i < mIceCtx->GetStreamCount(); ++i) {
- if (mIceCtx->GetStream(i)) {
- mIceCtx->StartGathering();
+ for (size_t i = 0; i < mIceCtxHdlr->ctx()->GetStreamCount(); ++i) {
+ if (mIceCtxHdlr->ctx()->GetStream(i)) {
+ mIceCtxHdlr->ctx()->StartGathering();
return;
}
}
// If there are no streams, we're probably in a situation where we've rolled
// back while still waiting for our proxy configuration to come back. Make
// sure content knows that the rollback has stuck wrt gathering.
- IceGatheringStateChange_s(mIceCtx.get(), NrIceCtx::ICE_CTX_GATHER_COMPLETE);
+ IceGatheringStateChange_s(mIceCtxHdlr->ctx().get(),
+ NrIceCtx::ICE_CTX_GATHER_COMPLETE);
}
nsresult
PeerConnectionMedia::AddTrack(DOMMediaStream* aMediaStream,
const std::string& streamId,
const std::string& trackId)
{
ASSERT_ON_THREAD(mMainThread);
@@ -897,17 +906,17 @@ PeerConnectionMedia::ShutdownMediaTransp
}
for (uint32_t i=0; i < mRemoteSourceStreams.Length(); ++i) {
mRemoteSourceStreams[i]->DetachTransport_s();
}
disconnect_all();
mTransportFlows.clear();
- mIceCtx = nullptr;
+ mIceCtxHdlr = nullptr;
mMainThread->Dispatch(WrapRunnable(this, &PeerConnectionMedia::SelfDestruct_m),
NS_DISPATCH_NORMAL);
}
LocalSourceStreamInfo*
PeerConnectionMedia::GetLocalStreamByIndex(int aIndex)
{--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h
@@ -228,24 +228,25 @@ class PeerConnectionMedia : public sigsl
PeerConnectionImpl* GetPC() { return mParent; }
nsresult Init(const std::vector<NrIceStunServer>& stun_servers,
const std::vector<NrIceTurnServer>& turn_servers,
NrIceCtx::Policy policy);
// WARNING: This destroys the object!
void SelfDestruct();
- RefPtr<NrIceCtxHandler> ice_ctx() const { return mIceCtx; }
+ RefPtr<NrIceCtxHandler> ice_ctx_hdlr() const { return mIceCtxHdlr; }
+ RefPtr<NrIceCtx> ice_ctx() const { return mIceCtxHdlr->ctx(); }
RefPtr<NrIceMediaStream> ice_media_stream(size_t i) const {
- return mIceCtx->GetStream(i);
+ return mIceCtxHdlr->ctx()->GetStream(i);
}
size_t num_ice_media_streams() const {
- return mIceCtx->GetStreamCount();
+ return mIceCtxHdlr->ctx()->GetStreamCount();
}
// Ensure ICE transports exist that we might need when offer/answer concludes
void EnsureTransports(const JsepSession& aSession);
// Activate or remove ICE transports at the conclusion of offer/answer,
// or when rollback occurs.
void ActivateOrRemoveTransports(const JsepSession& aSession);
@@ -508,17 +509,17 @@ class PeerConnectionMedia : public sigsl
// A list of streams provided by the other side
// This is only accessed on the main thread (with one special exception)
nsTArray<RefPtr<RemoteSourceStreamInfo> > mRemoteSourceStreams;
std::map<size_t, std::pair<bool, RefPtr<MediaSessionConduit>>> mConduits;
// ICE objects
- RefPtr<NrIceCtxHandler> mIceCtx;
+ RefPtr<NrIceCtxHandler> mIceCtxHdlr;
// DNS
RefPtr<NrIceResolver> mDNSResolver;
// Transport flows: even is RTP, odd is RTCP
std::map<int, RefPtr<TransportFlow> > mTransportFlows;
// UUID Generator