Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-12 12:55:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge mozilla-central to mozilla-inbound. a=merge CLOSED TREE

Browse Source
This commit is contained in:
Ciure Andrei 2018-09-28 11:58:15 +03:00
commit a8953550a3
11 changed files with 456 additions and 473 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build/moz.configure/tup.configure
View File

@ -13,7 +13,7 @@ tup = check_prog('TUP', ['tup'])
@checking('for tup version')
@imports('re')
def tup_version(tup):
tup_min_version = '0.7.7'
tup_min_version = '0.7.8'
out = check_cmd_output(tup, '--version',
onerror=lambda: die('Failed to get tup version'))
m = re.search(r'tup v?([0-9]+\.[0-9]+\.[0-9]+)', out)

6
layout/base/nsCSSFrameConstructor.cpp
View File

@ -1795,6 +1795,12 @@ nsCSSFrameConstructor::CreateGeneratedContentItem(nsFrameConstructorState& aStat
aPseudoElement == CSSPseudoElementType::after,
"unexpected aPseudoElement");
if (aParentFrame && aParentFrame->IsHTMLVideoFrame()) {
// Video frames may not be leafs when backed by an UA widget, but we still don't want to expose generated content.
MOZ_ASSERT(aOriginatingElement.GetShadowRoot()->IsUAWidget());
return;
}
ServoStyleSet* styleSet = mPresShell->StyleSet();
// Probe for the existence of the pseudo-element

6
layout/generic/crashtests/1493741.html Normal file
View File

@ -0,0 +1,6 @@
<style>
video::after {
content: "";
}
</style>
<video></video>

1
layout/generic/crashtests/crashtests.list
View File

@ -713,4 +713,5 @@ load 1490032.html
load 1490685.html
load 1493708.html
load 1493710.html
load 1493741.html
load 1494380.html

378
media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
View File

@ -82,7 +82,6 @@
#include "js/GCAnnotations.h"
#include "mozilla/PeerIdentity.h"
#include "mozilla/dom/RTCCertificate.h"
#include "mozilla/dom/RTCConfigurationBinding.h"
#include "mozilla/dom/RTCDTMFSenderBinding.h"
#include "mozilla/dom/RTCDTMFToneChangeEvent.h"
#include "mozilla/dom/RTCRtpReceiverBinding.h"
@ -413,162 +412,10 @@ PeerConnectionImpl::~PeerConnectionImpl()
// to release off a timer (and XPCOM Shutdown) to avoid churn
}
/**
* In JS, an RTCConfiguration looks like this:
*
* { "iceServers": [ { url:"stun:stun.example.org" },
* { url:"turn:turn.example.org?transport=udp",
* username: "jib", credential:"mypass"} ] }
*
* This function converts that into an internal PeerConnectionConfiguration
* object.
*/
nsresult
PeerConnectionConfiguration::Init(const RTCConfiguration& aSrc)
{
if (aSrc.mIceServers.WasPassed()) {
for (size_t i = 0; i < aSrc.mIceServers.Value().Length(); i++) {
nsresult rv = AddIceServer(aSrc.mIceServers.Value()[i]);
NS_ENSURE_SUCCESS(rv, rv);
}
}
switch (aSrc.mBundlePolicy) {
case dom::RTCBundlePolicy::Balanced:
setBundlePolicy(kBundleBalanced);
break;
case dom::RTCBundlePolicy::Max_compat:
setBundlePolicy(kBundleMaxCompat);
break;
case dom::RTCBundlePolicy::Max_bundle:
setBundlePolicy(kBundleMaxBundle);
break;
default:
MOZ_CRASH();
}
switch (aSrc.mIceTransportPolicy) {
case dom::RTCIceTransportPolicy::Relay:
setIceTransportPolicy(NrIceCtx::ICE_POLICY_RELAY);
break;
case dom::RTCIceTransportPolicy::All:
if (Preferences::GetBool("media.peerconnection.ice.no_host", false)) {
setIceTransportPolicy(NrIceCtx::ICE_POLICY_NO_HOST);
} else {
setIceTransportPolicy(NrIceCtx::ICE_POLICY_ALL);
}
break;
default:
MOZ_CRASH();
}
return NS_OK;
}
nsresult
PeerConnectionConfiguration::AddIceServer(const RTCIceServer &aServer)
{
NS_ENSURE_STATE(aServer.mUrls.WasPassed());
NS_ENSURE_STATE(aServer.mUrls.Value().IsStringSequence());
auto &urls = aServer.mUrls.Value().GetAsStringSequence();
for (size_t i = 0; i < urls.Length(); i++) {
// Without STUN/TURN handlers, NS_NewURI returns nsSimpleURI rather than
// nsStandardURL. To parse STUN/TURN URI's to spec
// http://tools.ietf.org/html/draft-nandakumar-rtcweb-stun-uri-02#section-3
// http://tools.ietf.org/html/draft-petithuguenin-behave-turn-uri-03#section-3
// we parse out the query-string, and use ParseAuthority() on the rest
RefPtr<nsIURI> url;
nsresult rv = NS_NewURI(getter_AddRefs(url), urls[i]);
NS_ENSURE_SUCCESS(rv, rv);
bool isStun = false, isStuns = false, isTurn = false, isTurns = false;
url->SchemeIs("stun", &isStun);
url->SchemeIs("stuns", &isStuns);
url->SchemeIs("turn", &isTurn);
url->SchemeIs("turns", &isTurns);
if (!(isStun || isStuns || isTurn || isTurns)) {
return NS_ERROR_FAILURE;
}
if (isStuns) {
continue; // TODO: Support STUNS (Bug 1056934)
}
nsAutoCString spec;
rv = url->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
// TODO(jib@mozilla.com): Revisit once nsURI supports STUN/TURN (Bug 833509)
int32_t port;
nsAutoCString host;
nsAutoCString transport;
{
uint32_t hostPos;
int32_t hostLen;
nsAutoCString path;
rv = url->GetPathQueryRef(path);
NS_ENSURE_SUCCESS(rv, rv);
// Tolerate query-string + parse 'transport=[udp|tcp]' by hand.
int32_t questionmark = path.FindChar('?');
if (questionmark >= 0) {
const nsCString match = NS_LITERAL_CSTRING("transport=");
for (int32_t i = questionmark, endPos; i >= 0; i = endPos) {
endPos = path.FindCharInSet("&", i + 1);
const nsDependentCSubstring fieldvaluepair = Substring(path, i + 1,
endPos);
if (StringBeginsWith(fieldvaluepair, match)) {
transport = Substring(fieldvaluepair, match.Length());
ToLowerCase(transport);
}
}
path.SetLength(questionmark);
}
rv = net_GetAuthURLParser()->ParseAuthority(path.get(), path.Length(),
nullptr, nullptr,
nullptr, nullptr,
&hostPos, &hostLen, &port);
NS_ENSURE_SUCCESS(rv, rv);
if (!hostLen) {
return NS_ERROR_FAILURE;
}
if (hostPos > 1) /* The username was removed */
return NS_ERROR_FAILURE;
path.Mid(host, hostPos, hostLen);
}
if (port == -1)
port = (isStuns || isTurns)? 5349 : 3478;
if (isStuns || isTurns) {
// Should we barf if transport is set to udp or something?
transport = kNrIceTransportTls;
}
if (transport.IsEmpty()) {
transport = kNrIceTransportUdp;
}
if (isTurn || isTurns) {
NS_ConvertUTF16toUTF8 credential(aServer.mCredential.Value());
NS_ConvertUTF16toUTF8 username(aServer.mUsername.Value());
if (!addTurnServer(host.get(), port,
username.get(),
credential.get(),
transport.get())) {
return NS_ERROR_FAILURE;
}
} else {
if (!addStunServer(host.get(), port, transport.get())) {
return NS_ERROR_FAILURE;
}
}
}
return NS_OK;
}
nsresult
PeerConnectionImpl::Initialize(PeerConnectionObserver& aObserver,
nsGlobalWindowInner* aWindow,
const PeerConnectionConfiguration& aConfiguration,
const RTCConfiguration& aConfiguration,
nsISupports* aThread)
{
nsresult res;
@ -671,9 +518,7 @@ PeerConnectionImpl::Initialize(PeerConnectionObserver& aObserver,
mMedia->SignalCandidate.connect(this, &PeerConnectionImpl::CandidateReady);
// Initialize the media object.
res = mMedia->Init(aConfiguration.getStunServers(),
aConfiguration.getTurnServers(),
aConfiguration.getIceTransportPolicy());
res = mMedia->Init(aConfiguration);
if (NS_FAILED(res)) {
CSFLogError(LOGTAG, "%s: Couldn't initialize media object", __FUNCTION__);
return res;
@ -692,7 +537,22 @@ PeerConnectionImpl::Initialize(PeerConnectionObserver& aObserver,
return res;
}
res = mJsepSession->SetBundlePolicy(aConfiguration.getBundlePolicy());
JsepBundlePolicy bundlePolicy;
switch (aConfiguration.mBundlePolicy) {
case dom::RTCBundlePolicy::Balanced:
bundlePolicy = kBundleBalanced;
break;
case dom::RTCBundlePolicy::Max_compat:
bundlePolicy = kBundleMaxCompat;
break;
case dom::RTCBundlePolicy::Max_bundle:
bundlePolicy = kBundleMaxBundle;
break;
default:
MOZ_CRASH();
}
res = mJsepSession->SetBundlePolicy(bundlePolicy);
if (NS_FAILED(res)) {
CSFLogError(LOGTAG, "%s: Couldn't set bundle policy, res=%u, error=%s",
__FUNCTION__,
@ -715,15 +575,7 @@ PeerConnectionImpl::Initialize(PeerConnectionObserver& aObserver,
MOZ_ASSERT(aThread);
mThread = do_QueryInterface(aThread);
PeerConnectionConfiguration converted;
nsresult res = converted.Init(aConfiguration);
if (NS_FAILED(res)) {
CSFLogError(LOGTAG, "%s: Invalid RTCConfiguration", __FUNCTION__);
rv.Throw(res);
return;
}
res = Initialize(aObserver, &aWindow, converted, aThread);
nsresult res = Initialize(aObserver, &aWindow, aConfiguration, aThread);
if (NS_FAILED(res)) {
rv.Throw(res);
return;
@ -2804,40 +2656,6 @@ PeerConnectionImpl::GetName()
return mName;
}
static mozilla::dom::PCImplIceConnectionState
toDomIceConnectionState(NrIceCtx::ConnectionState state) {
switch (state) {
case NrIceCtx::ICE_CTX_INIT:
return PCImplIceConnectionState::New;
case NrIceCtx::ICE_CTX_CHECKING:
return PCImplIceConnectionState::Checking;
case NrIceCtx::ICE_CTX_CONNECTED:
return PCImplIceConnectionState::Connected;
case NrIceCtx::ICE_CTX_COMPLETED:
return PCImplIceConnectionState::Completed;
case NrIceCtx::ICE_CTX_FAILED:
return PCImplIceConnectionState::Failed;
case NrIceCtx::ICE_CTX_DISCONNECTED:
return PCImplIceConnectionState::Disconnected;
case NrIceCtx::ICE_CTX_CLOSED:
return PCImplIceConnectionState::Closed;
}
MOZ_CRASH();
}
static mozilla::dom::PCImplIceGatheringState
toDomIceGatheringState(NrIceCtx::GatheringState state) {
switch (state) {
case NrIceCtx::ICE_CTX_GATHER_INIT:
return PCImplIceGatheringState::New;
case NrIceCtx::ICE_CTX_GATHER_STARTED:
return PCImplIceGatheringState::Gathering;
case NrIceCtx::ICE_CTX_GATHER_COMPLETE:
return PCImplIceGatheringState::Complete;
}
MOZ_CRASH();
}
void
PeerConnectionImpl::CandidateReady(const std::string& candidate,
const std::string& transportId) {
@ -2935,13 +2753,11 @@ static bool isFailed(PCImplIceConnectionState state) {
}
void PeerConnectionImpl::IceConnectionStateChange(
NrIceCtx* ctx,
NrIceCtx::ConnectionState state) {
dom::PCImplIceConnectionState domState) {
PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);
CSFLogDebug(LOGTAG, "%s", __FUNCTION__);
auto domState = toDomIceConnectionState(state);
if (domState == mIceConnectionState) {
// no work to be done since the states are the same.
// this can happen during ICE rollback situations.
@ -3008,15 +2824,13 @@ void PeerConnectionImpl::IceConnectionStateChange(
}
void
PeerConnectionImpl::IceGatheringStateChange(
NrIceCtx* ctx,
NrIceCtx::GatheringState state)
PeerConnectionImpl::IceGatheringStateChange(dom::PCImplIceGatheringState state)
{
PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);
CSFLogDebug(LOGTAG, "%s", __FUNCTION__);
mIceGatheringState = toDomIceGatheringState(state);
mIceGatheringState = state;
// 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...
@ -3094,8 +2908,8 @@ PeerConnectionImpl::BuildStatsQuery_m(
// a ref instead of making multiple calls. NrIceCtx uses threadsafe refcounting.
// NOTE: Do this after all other failure tests, to ensure we don't
// accidentally release the Ctx on Mainthread.
query->iceCtx = mMedia->ice_ctx();
if (!query->iceCtx) {
query->media = mMedia;
if (!query->media) {
CSFLogError(LOGTAG, "Could not build stats query, no ice_ctx");
return NS_ERROR_UNEXPECTED;
}
@ -3151,117 +2965,10 @@ PeerConnectionImpl::BuildStatsQuery_m(
return rv;
}
static void ToRTCIceCandidateStats(
const std::vector<NrIceCandidate>& candidates,
RTCStatsType candidateType,
const nsString& componentId,
DOMHighResTimeStamp now,
RTCStatsReportInternal* report) {
MOZ_ASSERT(report);
for (const auto& candidate : candidates) {
RTCIceCandidateStats cand;
cand.mType.Construct(candidateType);
NS_ConvertASCIItoUTF16 codeword(candidate.codeword.c_str());
cand.mComponentId.Construct(componentId);
cand.mId.Construct(codeword);
cand.mTimestamp.Construct(now);
cand.mCandidateType.Construct(
RTCStatsIceCandidateType(candidate.type));
cand.mIpAddress.Construct(
NS_ConvertASCIItoUTF16(candidate.cand_addr.host.c_str()));
cand.mPortNumber.Construct(candidate.cand_addr.port);
cand.mTransport.Construct(
NS_ConvertASCIItoUTF16(candidate.cand_addr.transport.c_str()));
if (candidateType == RTCStatsType::Local_candidate) {
cand.mMozLocalTransport.Construct(
NS_ConvertASCIItoUTF16(candidate.local_addr.transport.c_str()));
}
report->mIceCandidateStats.Value().AppendElement(cand, fallible);
if (candidate.trickled) {
report->mTrickledIceCandidateStats.Value().AppendElement(cand, fallible);
}
}
}
static void RecordIceStats_s(
const NrIceMediaStream& mediaStream,
bool internalStats,
DOMHighResTimeStamp now,
RTCStatsReportInternal* report) {
NS_ConvertASCIItoUTF16 transportId(mediaStream.GetId().c_str());
std::vector<NrIceCandidatePair> candPairs;
nsresult res = mediaStream.GetCandidatePairs(&candPairs);
if (NS_FAILED(res)) {
CSFLogError(LOGTAG,
"%s: Error getting candidate pairs for transport id \"%s\"",
__FUNCTION__, mediaStream.GetId().c_str());
return;
}
for (auto& candPair : candPairs) {
NS_ConvertASCIItoUTF16 codeword(candPair.codeword.c_str());
NS_ConvertASCIItoUTF16 localCodeword(candPair.local.codeword.c_str());
NS_ConvertASCIItoUTF16 remoteCodeword(candPair.remote.codeword.c_str());
// Only expose candidate-pair statistics to chrome, until we've thought
// through the implications of exposing it to content.
RTCIceCandidatePairStats s;
s.mId.Construct(codeword);
s.mTransportId.Construct(transportId);
s.mTimestamp.Construct(now);
s.mType.Construct(RTCStatsType::Candidate_pair);
s.mLocalCandidateId.Construct(localCodeword);
s.mRemoteCandidateId.Construct(remoteCodeword);
s.mNominated.Construct(candPair.nominated);
s.mWritable.Construct(candPair.writable);
s.mReadable.Construct(candPair.readable);
s.mPriority.Construct(candPair.priority);
s.mSelected.Construct(candPair.selected);
s.mBytesSent.Construct(candPair.bytes_sent);
s.mBytesReceived.Construct(candPair.bytes_recvd);
s.mLastPacketSentTimestamp.Construct(candPair.ms_since_last_send);
s.mLastPacketReceivedTimestamp.Construct(candPair.ms_since_last_recv);
s.mState.Construct(RTCStatsIceCandidatePairState(candPair.state));
s.mComponentId.Construct(candPair.component_id);
report->mIceCandidatePairStats.Value().AppendElement(s, fallible);
}
std::vector<NrIceCandidate> candidates;
if (NS_SUCCEEDED(mediaStream.GetLocalCandidates(&candidates))) {
ToRTCIceCandidateStats(candidates,
RTCStatsType::Local_candidate,
transportId,
now,
report);
// add the local candidates unparsed string to a sequence
for (const auto& candidate : candidates) {
report->mRawLocalCandidates.Value().AppendElement(
NS_ConvertASCIItoUTF16(candidate.label.c_str()), fallible);
}
}
candidates.clear();
if (NS_SUCCEEDED(mediaStream.GetRemoteCandidates(&candidates))) {
ToRTCIceCandidateStats(candidates,
RTCStatsType::Remote_candidate,
transportId,
now,
report);
// add the remote candidates unparsed string to a sequence
for (const auto& candidate : candidates) {
report->mRawRemoteCandidates.Value().AppendElement(
NS_ConvertASCIItoUTF16(candidate.label.c_str()), fallible);
}
}
}
nsresult
PeerConnectionImpl::ExecuteStatsQuery_s(RTCStatsQuery *query) {
ASSERT_ON_THREAD(query->iceCtx->thread());
ASSERT_ON_THREAD(query->media->GetSTSThread());
// Gather stats from pipelines provided (can't touch mMedia + stream on STS)
@ -3485,22 +3192,16 @@ PeerConnectionImpl::ExecuteStatsQuery_s(RTCStatsQuery *query) {
}
if (query->grabAllLevels) {
for (const auto& stream : query->iceCtx->GetStreams()) {
RecordIceStats_s(*stream,
query->internalStats,
query->now,
query->report);
}
} else if (query->iceCtx->GetStream(query->transportId)) {
RecordIceStats_s(*query->iceCtx->GetStream(query->transportId),
query->internalStats,
query->now,
query->report);
query->media->GetAllIceStats_s(query->internalStats,
query->now,
query->report);
} else {
query->media->GetIceStats_s(query->transportId,
query->internalStats,
query->now,
query->report);
}
// NrIceCtx must be destroyed on STS, so it is not safe
// to dispatch it back to main.
query->iceCtx = nullptr;
return NS_OK;
}
@ -3509,8 +3210,8 @@ void PeerConnectionImpl::GetStatsForPCObserver_s(
nsAutoPtr<RTCStatsQuery> query) {
MOZ_ASSERT(query);
MOZ_ASSERT(query->iceCtx);
ASSERT_ON_THREAD(query->iceCtx->thread());
MOZ_ASSERT(query->media);
ASSERT_ON_THREAD(query->media->GetSTSThread());
nsresult rv = PeerConnectionImpl::ExecuteStatsQuery_s(query.get());
@ -3571,15 +3272,6 @@ PeerConnectionImpl::RecordIceRestartStatistics(JsepSdpType type)
}
}
void
PeerConnectionImpl::IceStreamReady(NrIceMediaStream *aStream)
{
PC_AUTO_ENTER_API_CALL_NO_CHECK();
MOZ_ASSERT(aStream);
CSFLogDebug(LOGTAG, "%s: %s", __FUNCTION__, aStream->name().c_str());
}
//Telemetry for when calls start
void
PeerConnectionImpl::startCallTelem() {

78
media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
View File

@ -18,8 +18,6 @@
#include "nsIWeakReferenceUtils.h" // for the definition of nsWeakPtr
#include "IPeerConnection.h"
#include "sigslot.h"
#include "nricectx.h"
#include "nricemediastream.h"
#include "nsComponentManagerUtils.h"
#include "nsPIDOMWindow.h"
#include "nsIUUIDGenerator.h"
@ -39,6 +37,7 @@
#include "mozilla/dom/PeerConnectionImplEnumsBinding.h"
#include "mozilla/dom/RTCPeerConnectionBinding.h" // mozPacketDumpType, maybe move?
#include "mozilla/dom/RTCRtpTransceiverBinding.h"
#include "mozilla/dom/RTCConfigurationBinding.h"
#include "PrincipalChangeObserver.h"
#include "StreamTracks.h"
@ -61,10 +60,6 @@ class nsDOMDataChannel;
namespace mozilla {
class DataChannel;
class DtlsIdentity;
class NrIceCtx;
class NrIceMediaStream;
class NrIceStunServer;
class NrIceTurnServer;
class MediaPipeline;
class TransceiverImpl;
@ -114,12 +109,8 @@ using mozilla::dom::PeerConnectionObserver;
using mozilla::dom::RTCConfiguration;
using mozilla::dom::RTCIceServer;
using mozilla::dom::RTCOfferOptions;
using mozilla::NrIceCtx;
using mozilla::NrIceMediaStream;
using mozilla::DtlsIdentity;
using mozilla::ErrorResult;
using mozilla::NrIceStunServer;
using mozilla::NrIceTurnServer;
using mozilla::PeerIdentity;
class PeerConnectionWrapper;
@ -135,59 +126,6 @@ class PCUuidGenerator : public mozilla::JsepUuidGenerator {
nsCOMPtr<nsIUUIDGenerator> mGenerator;
};
class PeerConnectionConfiguration
{
public:
PeerConnectionConfiguration()
: mBundlePolicy(kBundleBalanced),
mIceTransportPolicy(NrIceCtx::ICE_POLICY_ALL) {}
bool addStunServer(const std::string& addr, uint16_t port,
const char* transport)
{
UniquePtr<NrIceStunServer> server(NrIceStunServer::Create(addr, port, transport));
if (!server) {
return false;
}
addStunServer(*server);
return true;
}
bool addTurnServer(const std::string& addr, uint16_t port,
const std::string& username,
const std::string& pwd,
const char* transport)
{
// TODO(ekr@rtfm.com): Need support for SASLprep for
// username and password. Bug # ???
std::vector<unsigned char> password(pwd.begin(), pwd.end());
UniquePtr<NrIceTurnServer> server(NrIceTurnServer::Create(addr, port, username, password,
transport));
if (!server) {
return false;
}
addTurnServer(*server);
return true;
}
void addStunServer(const NrIceStunServer& server) { mStunServers.push_back (server); }
void addTurnServer(const NrIceTurnServer& server) { mTurnServers.push_back (server); }
const std::vector<NrIceStunServer>& getStunServers() const { return mStunServers; }
const std::vector<NrIceTurnServer>& getTurnServers() const { return mTurnServers; }
void setBundlePolicy(JsepBundlePolicy policy) { mBundlePolicy = policy;}
JsepBundlePolicy getBundlePolicy() const { return mBundlePolicy; }
void setIceTransportPolicy(NrIceCtx::Policy policy) { mIceTransportPolicy = policy;}
NrIceCtx::Policy getIceTransportPolicy() const { return mIceTransportPolicy; }
nsresult Init(const RTCConfiguration& aSrc);
nsresult AddIceServer(const RTCIceServer& aServer);
private:
std::vector<NrIceStunServer> mStunServers;
std::vector<NrIceTurnServer> mTurnServers;
JsepBundlePolicy mBundlePolicy;
NrIceCtx::Policy mIceTransportPolicy;
};
// Not an inner class so we can forward declare.
class RTCStatsQuery {
public:
@ -207,7 +145,7 @@ class RTCStatsQuery {
bool internalStats;
nsTArray<RefPtr<mozilla::MediaPipeline>> pipelines;
std::string transportId;
RefPtr<NrIceCtx> iceCtx;
RefPtr<PeerConnectionMedia> media;
bool grabAllLevels;
DOMHighResTimeStamp now;
};
@ -288,17 +226,14 @@ public:
virtual const std::string& GetName();
// ICE events
void IceConnectionStateChange(NrIceCtx* ctx,
NrIceCtx::ConnectionState state);
void IceGatheringStateChange(NrIceCtx* ctx,
NrIceCtx::GatheringState state);
void IceConnectionStateChange(dom::PCImplIceConnectionState state);
void IceGatheringStateChange(dom::PCImplIceGatheringState state);
void UpdateDefaultCandidate(const std::string& defaultAddr,
uint16_t defaultPort,
const std::string& defaultRtcpAddr,
uint16_t defaultRtcpPort,
const std::string& transportId);
void EndOfLocalCandidates(const std::string& transportId);
void IceStreamReady(NrIceMediaStream *aStream);
static void ListenThread(void *aData);
static void ConnectThread(void *aData);
@ -320,12 +255,9 @@ public:
return mWindow;
}
// Initialize PeerConnection from a PeerConnectionConfiguration object
// (used directly by unit-tests, and indirectly by the JS entry point)
// This is necessary because RTCConfiguration can't be used by unit-tests
nsresult Initialize(PeerConnectionObserver& aObserver,
nsGlobalWindowInner* aWindow,
const PeerConnectionConfiguration& aConfiguration,
const RTCConfiguration& aConfiguration,
nsISupports* aThread);
// Initialize PeerConnection from an RTCConfiguration object (JS entrypoint)

346
media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp
View File

@ -131,8 +131,7 @@ PeerConnectionMedia::StunAddrsHandler::OnStunAddrsAvailable(
// If parent process returns 0 STUN addresses, change ICE connection
// state to failed.
if (!pcm_->mStunAddrs.Length()) {
pcm_->SignalIceConnectionStateChange(pcm_->mIceCtx.get(),
NrIceCtx::ICE_CTX_FAILED);
pcm_->SignalIceConnectionStateChange(dom::PCImplIceConnectionState::Failed);
}
pcm_ = nullptr;
@ -240,9 +239,129 @@ PeerConnectionMedia::InitProxy()
return NS_OK;
}
nsresult PeerConnectionMedia::Init(const std::vector<NrIceStunServer>& stun_servers,
const std::vector<NrIceTurnServer>& turn_servers,
NrIceCtx::Policy policy)
static nsresult addNrIceServer(const nsString& aIceUrl,
const dom::RTCIceServer& aIceServer,
std::vector<NrIceStunServer>* aStunServersOut,
std::vector<NrIceTurnServer>* aTurnServersOut)
{
// Without STUN/TURN handlers, NS_NewURI returns nsSimpleURI rather than
// nsStandardURL. To parse STUN/TURN URI's to spec
// http://tools.ietf.org/html/draft-nandakumar-rtcweb-stun-uri-02#section-3
// http://tools.ietf.org/html/draft-petithuguenin-behave-turn-uri-03#section-3
// we parse out the query-string, and use ParseAuthority() on the rest
RefPtr<nsIURI> url;
nsresult rv = NS_NewURI(getter_AddRefs(url), aIceUrl);
NS_ENSURE_SUCCESS(rv, rv);
bool isStun = false, isStuns = false, isTurn = false, isTurns = false;
url->SchemeIs("stun", &isStun);
url->SchemeIs("stuns", &isStuns);
url->SchemeIs("turn", &isTurn);
url->SchemeIs("turns", &isTurns);
if (!(isStun || isStuns || isTurn || isTurns)) {
return NS_ERROR_FAILURE;
}
if (isStuns) {
return NS_OK; // TODO: Support STUNS (Bug 1056934)
}
nsAutoCString spec;
rv = url->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
// TODO(jib@mozilla.com): Revisit once nsURI supports STUN/TURN (Bug 833509)
int32_t port;
nsAutoCString host;
nsAutoCString transport;
{
uint32_t hostPos;
int32_t hostLen;
nsAutoCString path;
rv = url->GetPathQueryRef(path);
NS_ENSURE_SUCCESS(rv, rv);
// Tolerate query-string + parse 'transport=[udp|tcp]' by hand.
int32_t questionmark = path.FindChar('?');
if (questionmark >= 0) {
const nsCString match = NS_LITERAL_CSTRING("transport=");
for (int32_t i = questionmark, endPos; i >= 0; i = endPos) {
endPos = path.FindCharInSet("&", i + 1);
const nsDependentCSubstring fieldvaluepair = Substring(path, i + 1,
endPos);
if (StringBeginsWith(fieldvaluepair, match)) {
transport = Substring(fieldvaluepair, match.Length());
ToLowerCase(transport);
}
}
path.SetLength(questionmark);
}
rv = net_GetAuthURLParser()->ParseAuthority(path.get(), path.Length(),
nullptr, nullptr,
nullptr, nullptr,
&hostPos, &hostLen, &port);
NS_ENSURE_SUCCESS(rv, rv);
if (!hostLen) {
return NS_ERROR_FAILURE;
}
if (hostPos > 1) {
/* The username was removed */
return NS_ERROR_FAILURE;
}
path.Mid(host, hostPos, hostLen);
}
if (port == -1) {
port = (isStuns || isTurns)? 5349 : 3478;
}
if (isStuns || isTurns) {
// Should we barf if transport is set to udp or something?
transport = kNrIceTransportTls;
}
if (transport.IsEmpty()) {
transport = kNrIceTransportUdp;
}
if (isTurn || isTurns) {
std::string pwd(NS_ConvertUTF16toUTF8(aIceServer.mCredential.Value()).get());
std::string username(NS_ConvertUTF16toUTF8(aIceServer.mUsername.Value()).get());
std::vector<unsigned char> password(pwd.begin(), pwd.end());
UniquePtr<NrIceTurnServer> server(NrIceTurnServer::Create(host.get(), port, username, password, transport.get()));
if (!server) {
return NS_ERROR_FAILURE;
}
aTurnServersOut->emplace_back(std::move(*server));
} else {
UniquePtr<NrIceStunServer> server(NrIceStunServer::Create(host.get(), port, transport.get()));
if (!server) {
return NS_ERROR_FAILURE;
}
aStunServersOut->emplace_back(std::move(*server));
}
return NS_OK;
}
static NrIceCtx::Policy toNrIcePolicy(dom::RTCIceTransportPolicy aPolicy)
{
switch (aPolicy) {
case dom::RTCIceTransportPolicy::Relay:
return NrIceCtx::ICE_POLICY_RELAY;
case dom::RTCIceTransportPolicy::All:
if (Preferences::GetBool("media.peerconnection.ice.no_host", false)) {
return NrIceCtx::ICE_POLICY_NO_HOST;
} else {
return NrIceCtx::ICE_POLICY_ALL;
}
default:
MOZ_CRASH();
}
return NrIceCtx::ICE_POLICY_ALL;
}
nsresult PeerConnectionMedia::Init(const dom::RTCConfiguration& aConfiguration)
{
nsresult rv = InitProxy();
NS_ENSURE_SUCCESS(rv, rv);
@ -253,29 +372,48 @@ nsresult PeerConnectionMedia::Init(const std::vector<NrIceStunServer>& stun_serv
InitLocalAddrs();
NrIceCtx::InitializeGlobals(mParent->GetAllowIceLoopback(),
ice_tcp,
mParent->GetAllowIceLinkLocal());
ice_tcp,
mParent->GetAllowIceLinkLocal());
// TODO(ekr@rtfm.com): need some way to set not offerer later
// Looks like a bug in the NrIceCtx API.
mIceCtx = NrIceCtx::Create("PC:" + mParentName, policy);
mIceCtx = NrIceCtx::Create("PC:" + mParentName,
toNrIcePolicy(aConfiguration.mIceTransportPolicy));
if(!mIceCtx) {
CSFLogError(LOGTAG, "%s: Failed to create Ice Context", __FUNCTION__);
return NS_ERROR_FAILURE;
}
if (NS_FAILED(rv = mIceCtx->SetStunServers(stun_servers))) {
std::vector<NrIceStunServer> stunServers;
std::vector<NrIceTurnServer> turnServers;
if (aConfiguration.mIceServers.WasPassed()) {
for (const auto& iceServer : aConfiguration.mIceServers.Value()) {
NS_ENSURE_STATE(iceServer.mUrls.WasPassed());
NS_ENSURE_STATE(iceServer.mUrls.Value().IsStringSequence());
for (const auto& iceUrl : iceServer.mUrls.Value().GetAsStringSequence()) {
rv = addNrIceServer(iceUrl, iceServer, &stunServers, &turnServers);
if (NS_FAILED(rv)) {
CSFLogError(LOGTAG, "%s: invalid STUN/TURN server: %s",
__FUNCTION__, NS_ConvertUTF16toUTF8(iceUrl).get());
return rv;
}
}
}
}
if (NS_FAILED(rv = mIceCtx->SetStunServers(stunServers))) {
CSFLogError(LOGTAG, "%s: Failed to set stun servers", __FUNCTION__);
return rv;
}
// Give us a way to globally turn off TURN support
bool disabled = Preferences::GetBool("media.peerconnection.turn.disable", false);
if (!disabled) {
if (NS_FAILED(rv = mIceCtx->SetTurnServers(turn_servers))) {
if (NS_FAILED(rv = mIceCtx->SetTurnServers(turnServers))) {
CSFLogError(LOGTAG, "%s: Failed to set turn servers", __FUNCTION__);
return rv;
}
} else if (!turn_servers.empty()) {
} else if (!turnServers.empty()) {
CSFLogError(LOGTAG, "%s: Setting turn servers disabled", __FUNCTION__);
}
if (NS_FAILED(rv = mDNSResolver->Init())) {
@ -283,12 +421,11 @@ nsresult PeerConnectionMedia::Init(const std::vector<NrIceStunServer>& stun_serv
return rv;
}
if (NS_FAILED(rv =
mIceCtx->SetResolver(mDNSResolver->AllocateResolver()))) {
mIceCtx->SetResolver(mDNSResolver->AllocateResolver()))) {
CSFLogError(LOGTAG, "%s: Failed to get dns resolver", __FUNCTION__);
return rv;
}
ConnectSignals(mIceCtx.get());
return NS_OK;
}
@ -517,7 +654,7 @@ PeerConnectionMedia::UpdateTransportFlows(const JsepTransceiver& aTransceiver)
// have enqueued this function unless it was still active and
// the ICE data is destroyed on the STS.
static void
FinalizeTransportFlow_s(RefPtr<PeerConnectionMedia> aPCMedia,
FinalizeTransportFlow_s(const RefPtr<NrIceCtx>& aIceCtx,
nsAutoPtr<PacketDumper> aPacketDumper,
const RefPtr<TransportFlow>& aFlow,
const std::string& aId,
@ -529,8 +666,7 @@ FinalizeTransportFlow_s(RefPtr<PeerConnectionMedia> aPCMedia,
TransportLayerPacketDumper* srtpDumper(new TransportLayerPacketDumper(
std::move(aPacketDumper), dom::mozPacketDumpType::Srtp));
aIceLayer->SetParameters(aPCMedia->ice_media_stream(aId),
aIsRtcp ? 2 : 1);
aIceLayer->SetParameters(aIceCtx->GetStream(aId), aIsRtcp ? 2 : 1);
// TODO(bug 854518): Process errors.
(void)aIceLayer->Init();
(void)aDtlsLayer->Init();
@ -632,9 +768,8 @@ PeerConnectionMedia::UpdateTransportFlow(bool aIsRtcp,
nsAutoPtr<PacketDumper> packetDumper(new PacketDumper(mParent));
RefPtr<PeerConnectionMedia> pcMedia(this);
rv = GetSTSThread()->Dispatch(
WrapRunnableNM(FinalizeTransportFlow_s, pcMedia, packetDumper, flow,
WrapRunnableNM(FinalizeTransportFlow_s, mIceCtx, packetDumper, flow,
aTransport.mTransportId, aIsRtcp,
ice.release(), dtls.release(), srtp.release()),
NS_DISPATCH_NORMAL);
@ -967,6 +1102,143 @@ PeerConnectionMedia::ShutdownMediaTransport_s()
NS_DISPATCH_NORMAL);
}
void
PeerConnectionMedia::GetIceStats_s(
const std::string& aTransportId,
bool internalStats,
DOMHighResTimeStamp now,
RTCStatsReportInternal* report) const
{
if (mIceCtx) {
auto stream = mIceCtx->GetStream(aTransportId);
if (stream) {
GetIceStats_s(*stream, internalStats, now, report);
}
}
}
void
PeerConnectionMedia::GetAllIceStats_s(
bool internalStats,
DOMHighResTimeStamp now,
RTCStatsReportInternal* report) const
{
if (mIceCtx) {
for (const auto& stream : mIceCtx->GetStreams()) {
GetIceStats_s(*stream, internalStats, now, report);
}
}
}
static void ToRTCIceCandidateStats(
const std::vector<NrIceCandidate>& candidates,
RTCStatsType candidateType,
const nsString& componentId,
DOMHighResTimeStamp now,
RTCStatsReportInternal* report) {
MOZ_ASSERT(report);
for (const auto& candidate : candidates) {
RTCIceCandidateStats cand;
cand.mType.Construct(candidateType);
NS_ConvertASCIItoUTF16 codeword(candidate.codeword.c_str());
cand.mComponentId.Construct(componentId);
cand.mId.Construct(codeword);
cand.mTimestamp.Construct(now);
cand.mCandidateType.Construct(
RTCStatsIceCandidateType(candidate.type));
cand.mIpAddress.Construct(
NS_ConvertASCIItoUTF16(candidate.cand_addr.host.c_str()));
cand.mPortNumber.Construct(candidate.cand_addr.port);
cand.mTransport.Construct(
NS_ConvertASCIItoUTF16(candidate.cand_addr.transport.c_str()));
if (candidateType == RTCStatsType::Local_candidate) {
cand.mMozLocalTransport.Construct(
NS_ConvertASCIItoUTF16(candidate.local_addr.transport.c_str()));
}
report->mIceCandidateStats.Value().AppendElement(cand, fallible);
if (candidate.trickled) {
report->mTrickledIceCandidateStats.Value().AppendElement(cand, fallible);
}
}
}
void
PeerConnectionMedia::GetIceStats_s(
const NrIceMediaStream& aStream,
bool internalStats,
DOMHighResTimeStamp now,
RTCStatsReportInternal* report) const
{
NS_ConvertASCIItoUTF16 transportId(aStream.GetId().c_str());
std::vector<NrIceCandidatePair> candPairs;
nsresult res = aStream.GetCandidatePairs(&candPairs);
if (NS_FAILED(res)) {
CSFLogError(LOGTAG,
"%s: Error getting candidate pairs for transport id \"%s\"",
__FUNCTION__, aStream.GetId().c_str());
return;
}
for (auto& candPair : candPairs) {
NS_ConvertASCIItoUTF16 codeword(candPair.codeword.c_str());
NS_ConvertASCIItoUTF16 localCodeword(candPair.local.codeword.c_str());
NS_ConvertASCIItoUTF16 remoteCodeword(candPair.remote.codeword.c_str());
// Only expose candidate-pair statistics to chrome, until we've thought
// through the implications of exposing it to content.
RTCIceCandidatePairStats s;
s.mId.Construct(codeword);
s.mTransportId.Construct(transportId);
s.mTimestamp.Construct(now);
s.mType.Construct(RTCStatsType::Candidate_pair);
s.mLocalCandidateId.Construct(localCodeword);
s.mRemoteCandidateId.Construct(remoteCodeword);
s.mNominated.Construct(candPair.nominated);
s.mWritable.Construct(candPair.writable);
s.mReadable.Construct(candPair.readable);
s.mPriority.Construct(candPair.priority);
s.mSelected.Construct(candPair.selected);
s.mBytesSent.Construct(candPair.bytes_sent);
s.mBytesReceived.Construct(candPair.bytes_recvd);
s.mLastPacketSentTimestamp.Construct(candPair.ms_since_last_send);
s.mLastPacketReceivedTimestamp.Construct(candPair.ms_since_last_recv);
s.mState.Construct(RTCStatsIceCandidatePairState(candPair.state));
s.mComponentId.Construct(candPair.component_id);
report->mIceCandidatePairStats.Value().AppendElement(s, fallible);
}
std::vector<NrIceCandidate> candidates;
if (NS_SUCCEEDED(aStream.GetLocalCandidates(&candidates))) {
ToRTCIceCandidateStats(candidates,
RTCStatsType::Local_candidate,
transportId,
now,
report);
// add the local candidates unparsed string to a sequence
for (const auto& candidate : candidates) {
report->mRawLocalCandidates.Value().AppendElement(
NS_ConvertASCIItoUTF16(candidate.label.c_str()), fallible);
}
}
candidates.clear();
if (NS_SUCCEEDED(aStream.GetRemoteCandidates(&candidates))) {
ToRTCIceCandidateStats(candidates,
RTCStatsType::Remote_candidate,
transportId,
now,
report);
// add the remote candidates unparsed string to a sequence
for (const auto& candidate : candidates) {
report->mRawRemoteCandidates.Value().AppendElement(
NS_ConvertASCIItoUTF16(candidate.label.c_str()), fallible);
}
}
}
nsresult
PeerConnectionMedia::AddTransceiver(
JsepTransceiver* aJsepTransceiver,
@ -1197,12 +1469,46 @@ PeerConnectionMedia::GetDefaultCandidates(const NrIceMediaStream& aStream,
}
}
static mozilla::dom::PCImplIceConnectionState
toDomIceConnectionState(NrIceCtx::ConnectionState state) {
switch (state) {
case NrIceCtx::ICE_CTX_INIT:
return PCImplIceConnectionState::New;
case NrIceCtx::ICE_CTX_CHECKING:
return PCImplIceConnectionState::Checking;
case NrIceCtx::ICE_CTX_CONNECTED:
return PCImplIceConnectionState::Connected;
case NrIceCtx::ICE_CTX_COMPLETED:
return PCImplIceConnectionState::Completed;
case NrIceCtx::ICE_CTX_FAILED:
return PCImplIceConnectionState::Failed;
case NrIceCtx::ICE_CTX_DISCONNECTED:
return PCImplIceConnectionState::Disconnected;
case NrIceCtx::ICE_CTX_CLOSED:
return PCImplIceConnectionState::Closed;
}
MOZ_CRASH();
}
static mozilla::dom::PCImplIceGatheringState
toDomIceGatheringState(NrIceCtx::GatheringState state) {
switch (state) {
case NrIceCtx::ICE_CTX_GATHER_INIT:
return PCImplIceGatheringState::New;
case NrIceCtx::ICE_CTX_GATHER_STARTED:
return PCImplIceGatheringState::Gathering;
case NrIceCtx::ICE_CTX_GATHER_COMPLETE:
return PCImplIceGatheringState::Complete;
}
MOZ_CRASH();
}
void
PeerConnectionMedia::IceGatheringStateChange_m(NrIceCtx* ctx,
NrIceCtx::GatheringState state)
{
ASSERT_ON_THREAD(mMainThread);
SignalIceGatheringStateChange(ctx, state);
SignalIceGatheringStateChange(toDomIceGatheringState(state));
}
void
@ -1210,7 +1516,7 @@ PeerConnectionMedia::IceConnectionStateChange_m(NrIceCtx* ctx,
NrIceCtx::ConnectionState state)
{
ASSERT_ON_THREAD(mMainThread);
SignalIceConnectionStateChange(ctx, state);
SignalIceConnectionStateChange(toDomIceConnectionState(state));
}
void

26
media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h
View File

@ -50,18 +50,17 @@ class PeerConnectionMedia : public sigslot::has_slots<> {
explicit PeerConnectionMedia(PeerConnectionImpl *parent);
PeerConnectionImpl* GetPC() { return mParent; }
nsresult Init(const std::vector<NrIceStunServer>& stun_servers,
const std::vector<NrIceTurnServer>& turn_servers,
NrIceCtx::Policy policy);
nsresult Init(const dom::RTCConfiguration& aConfiguration);
// WARNING: This destroys the object!
void SelfDestruct();
RefPtr<NrIceCtx> ice_ctx() const { return mIceCtx; }
RefPtr<NrIceMediaStream> ice_media_stream(
const std::string& aTransportId) const {
return mIceCtx->GetStream(aTransportId);
}
void GetIceStats_s(const std::string& aTransportId,
bool internalStats,
DOMHighResTimeStamp now,
RTCStatsReportInternal* report) const;
void GetAllIceStats_s(bool internalStats,
DOMHighResTimeStamp now,
RTCStatsReportInternal* report) const;
// Ensure ICE transports exist that we might need when offer/answer concludes
void EnsureTransports(const JsepSession& aSession);
@ -161,9 +160,9 @@ class PeerConnectionMedia : public sigslot::has_slots<> {
bool aPrivacyRequested);
// ICE state signals
sigslot::signal2<NrIceCtx*, NrIceCtx::GatheringState>
sigslot::signal1<mozilla::dom::PCImplIceGatheringState>
SignalIceGatheringStateChange;
sigslot::signal2<NrIceCtx*, NrIceCtx::ConnectionState>
sigslot::signal1<mozilla::dom::PCImplIceConnectionState>
SignalIceConnectionStateChange;
// This passes a candidate:... attribute and transport id
sigslot::signal2<const std::string&, const std::string&> SignalCandidate;
@ -291,6 +290,11 @@ class PeerConnectionMedia : public sigslot::has_slots<> {
return mProxyResolveCompleted && mLocalAddrsCompleted;
}
void GetIceStats_s(const NrIceMediaStream& aStream,
bool internalStats,
DOMHighResTimeStamp now,
RTCStatsReportInternal* report) const;
// The parent PC
PeerConnectionImpl *mParent;
// and a loose handle on it for event driven stuff

34
python/mozbuild/mozbuild/backend/cargo_build_defs.py
View File

@ -95,4 +95,38 @@ cargo_extra_outputs = {
'webrender': [
'shaders.rs',
],
'cranelift-codegen': [
'binemit-arm32.rs',
'binemit-arm64.rs',
'binemit-riscv.rs',
'binemit-x86.rs',
'encoding-arm32.rs',
'encoding-arm64.rs',
'encoding-riscv.rs',
'encoding-x86.rs',
'inst_builder.rs',
'legalize-arm32.rs',
'legalize-arm64.rs',
'legalize-riscv.rs',
'legalize-x86.rs',
'legalizer.rs',
'new_types.rs',
'opcodes.rs',
'registers-arm32.rs',
'registers-arm64.rs',
'registers-riscv.rs',
'registers-x86.rs',
'settings-arm32.rs',
'settings-arm64.rs',
'settings-riscv.rs',
'settings-x86.rs',
'settings.rs',
'types.rs',
],
'target-lexicon': [
'host.rs',
],
'baldrdash': [
'bindings.rs',
],
}

48
python/mozbuild/mozbuild/backend/tup.py
View File

@ -463,6 +463,7 @@ class TupBackend(CommonBackend):
def _gen_program(self, backend_file, prog):
cc_or_cxx = 'CXX' if prog.cxx_link else 'CC'
objs, _, _, shared_libs, os_libs, static_libs = self._expand_libs(prog)
static_libs = self._lib_paths(backend_file.objdir, static_libs)
shared_libs = self._lib_paths(backend_file.objdir, shared_libs)
@ -471,6 +472,16 @@ class TupBackend(CommonBackend):
# accurate once we start building libraries in their final locations.
inputs = objs + static_libs + shared_libs + [self._shlibs]
rust_linked = [l for l in prog.linked_libraries
if isinstance(l, RustLibrary)]
extra_inputs = []
if rust_linked:
extra_inputs = [self._rust_output_group(rust_linked[0].output_category) or
self._rust_libs]
static_libs += self._lib_paths(backend_file.objdir, rust_linked)
list_file_name = '%s.list' % prog.name.replace('.', '_')
list_file = self._make_list_file(backend_file.objdir, objs, list_file_name)
@ -494,6 +505,7 @@ class TupBackend(CommonBackend):
backend_file.rule(
cmd=cmd,
inputs=inputs,
extra_inputs=extra_inputs,
outputs=outputs,
display='LINK %o'
)
@ -805,19 +817,6 @@ class TupBackend(CommonBackend):
rust_build_home = mozpath.join(self.environment.topobjdir,
'toolkit/library/rust')
def get_libloading_outdir():
for invocation in invocations:
if (invocation['package_name'] == 'libloading' and
invocation['outputs'][0].endswith('.rlib')):
return invocation['env']['OUT_DIR']
def get_lmdb_sys_outdir():
for invocation in invocations:
if (invocation['package_name'] == 'lmdb-sys' and
len(invocation['outputs']) >= 1 and
invocation['outputs'][0].endswith('.rlib')):
return invocation['env']['OUT_DIR']
def display_name(invocation):
output_str = ''
if invocation['outputs']:
@ -864,10 +863,11 @@ class TupBackend(CommonBackend):
invocation['full-deps'] = set()
if os.path.basename(invocation['program']) == 'build-script-build':
out_dir = invocation['env']['OUT_DIR']
for output in cargo_extra_outputs.get(shortname, []):
outputs.append(os.path.join(invocation['env']['OUT_DIR'], output))
outputs.append(os.path.join(out_dir, output))
script_stdout = mozpath.join(rust_build_home,
script_stdout = mozpath.join(out_dir,
'%s_%s_build_out.txt' % (shortname,
invocation['kind']))
command.extend(['>', script_stdout])
@ -891,14 +891,16 @@ class TupBackend(CommonBackend):
for t in inv['target_kind'])
def get_output_files(inv):
candidate_file = mozpath.join(rust_build_home,
'%s_%s_build_out.txt' %
(inv['package_name'],
inv['kind']))
if (candidate_file in all_dep_build_outputs and
candidate_file not in seen_dep_outputs):
dep_build_outputs.append(candidate_file)
seen_dep_outputs.add(candidate_file)
out_dir = inv['env'].get('OUT_DIR')
if out_dir:
candidate_file = mozpath.join(out_dir,
'%s_%s_build_out.txt' %
(inv['package_name'],
inv['kind']))
if (candidate_file in all_dep_build_outputs and
candidate_file not in seen_dep_outputs):
dep_build_outputs.append(candidate_file)
seen_dep_outputs.add(candidate_file)
for dep in inv['deps']:
dep_inv = invocations[dep]

4
taskcluster/scripts/misc/build-tup-linux.sh
View File

@ -3,7 +3,7 @@ set -e -v
# This script is for building tup on Linux.
TUP_REVISION=e948a999a38fefa0ac0d92f6357f82aca2f9cb17
TUP_REVISION=v0.7.8
WORKSPACE=$HOME/workspace
UPLOAD_DIR=$HOME/artifacts
@ -17,7 +17,7 @@ cd $WORKSPACE/build/src
git clone https://github.com/gittup/tup.git
cd tup
git checkout $TUP_REVISION
echo 'CONFIG_TUP_SERVER=ldpreload' > tup.config
(echo 'CONFIG_TUP_SERVER=ldpreload'; echo 'CONFIG_TUP_USE_SYSTEM_PCRE=n') > tup.config
./bootstrap-ldpreload.sh
cd ..
tar caf tup.tar.xz tup/tup tup/tup-ldpreload.so tup/tup.1