mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1322095 - Part 1b: Update callbacks to support moved args and convert nsAutoPtr usage. r=jya 

In order to support the update to move args when invoking callbacks we:
 - Convert anything that was using WrapRunnable with `nsAutoPtr` to `UniquePtr`
 - Convert anything that was using a non-const ref as a param to either a
   const ref or a by-val copy

Addtionally we convert the remaining `nsAutoPtr` usage to `UniquePtr`.

Differential Revision: https://phabricator.services.mozilla.com/D59961

--HG--
extra : moz-landing-system : lando
This commit is contained in:
Eric Rahm 2020-02-21 22:43:53 +00:00
Родитель 9f7262d417
Коммит b9ba9be64d
29 изменённых файлов: 93 добавлений и 95 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
dom/media/gmp/GMPServiceParent.cpp
Просмотреть файл

@ -917,7 +917,7 @@ void GeckoMediaPluginServiceParent::RemoveOnGMPThread(
}
// May remove when Bug 1043671 is fixed
static void Dummy(RefPtr<GMPParent>& aOnDeathsDoor) {
static void Dummy(RefPtr<GMPParent> aOnDeathsDoor) {
// exists solely to do nothing and let the Runnable kill the GMPParent
// when done.
}

11
dom/network/UDPSocketParent.cpp
Просмотреть файл

@ -249,8 +249,9 @@ void UDPSocketParent::DoSendConnectResponse(
mozilla::Unused << SendCallbackConnected(aAddressInfo);
}
void UDPSocketParent::SendConnectResponse(nsIEventTarget* aThread,
const UDPAddressInfo& aAddressInfo) {
void UDPSocketParent::SendConnectResponse(
const nsCOMPtr<nsIEventTarget>& aThread,
const UDPAddressInfo& aAddressInfo) {
Unused << NS_WARN_IF(NS_FAILED(aThread->Dispatch(
WrapRunnable(RefPtr<UDPSocketParent>(this),
&UDPSocketParent::DoSendConnectResponse, aAddressInfo),
@ -258,8 +259,8 @@ void UDPSocketParent::SendConnectResponse(nsIEventTarget* aThread,
}
// Runs on STS thread
void UDPSocketParent::DoConnect(nsCOMPtr<nsIUDPSocket>& aSocket,
nsCOMPtr<nsIEventTarget>& aReturnThread,
void UDPSocketParent::DoConnect(const nsCOMPtr<nsIUDPSocket>& aSocket,
const nsCOMPtr<nsIEventTarget>& aReturnThread,
const UDPAddressInfo& aAddressInfo) {
UDPSOCKET_LOG(("%s: %s:%u", __FUNCTION__, aAddressInfo.addr().get(),
aAddressInfo.port()));
@ -553,7 +554,7 @@ void UDPSocketParent::FireInternalError(uint32_t aLineNo) {
NS_LITERAL_CSTRING(__FILE__), aLineNo);
}
void UDPSocketParent::SendInternalError(nsIEventTarget* aThread,
void UDPSocketParent::SendInternalError(const nsCOMPtr<nsIEventTarget>& aThread,
uint32_t aLineNo) {
UDPSOCKET_LOG(("SendInternalError: %u", aLineNo));
Unused << NS_WARN_IF(NS_FAILED(aThread->Dispatch(

9
dom/network/UDPSocketParent.h
Просмотреть файл

@ -38,10 +38,10 @@ class UDPSocketParent : public mozilla::net::PUDPSocketParent,
const uint32_t& sendBufferSize);
mozilla::ipc::IPCResult RecvConnect(const UDPAddressInfo& aAddressInfo);
void DoSendConnectResponse(const UDPAddressInfo& aAddressInfo);
void SendConnectResponse(nsIEventTarget* aThread,
void SendConnectResponse(const nsCOMPtr<nsIEventTarget>& aThread,
const UDPAddressInfo& aAddressInfo);
void DoConnect(nsCOMPtr<nsIUDPSocket>& aSocket,
nsCOMPtr<nsIEventTarget>& aReturnThread,
void DoConnect(const nsCOMPtr<nsIUDPSocket>& aSocket,
const nsCOMPtr<nsIEventTarget>& aReturnThread,
const UDPAddressInfo& aAddressInfo);
mozilla::ipc::IPCResult RecvOutgoingData(const UDPData& aData,
@ -66,7 +66,8 @@ class UDPSocketParent : public mozilla::net::PUDPSocketParent,
const uint32_t& sendBufferSize);
nsresult ConnectInternal(const nsCString& aHost, const uint16_t& aPort);
void FireInternalError(uint32_t aLineNo);
void SendInternalError(nsIEventTarget* aThread, uint32_t aLineNo);
void SendInternalError(const nsCOMPtr<nsIEventTarget>& aThread,
uint32_t aLineNo);
PBackgroundParent* mBackgroundManager;

19
media/mtransport/nr_socket_prsock.cpp
Просмотреть файл

@ -1142,9 +1142,9 @@ NS_IMETHODIMP NrUdpSocketIpc::CallListenerReceivedData(
}
}
nsAutoPtr<MediaPacket> buf(new MediaPacket);
auto buf = MakeUnique<MediaPacket>();
buf->Copy(data.Elements(), data.Length());
RefPtr<nr_udp_message> msg(new nr_udp_message(addr, buf));
RefPtr<nr_udp_message> msg(new nr_udp_message(addr, std::move(buf)));
RUN_ON_THREAD(sts_thread_,
mozilla::WrapRunnable(RefPtr<NrUdpSocketIpc>(this),
@ -1323,13 +1323,14 @@ int NrUdpSocketIpc::sendto(const void* msg, size_t len, int flags,
return R_WOULDBLOCK;
}
nsAutoPtr<MediaPacket> buf(new MediaPacket);
UniquePtr<MediaPacket> buf(new MediaPacket);
buf->Copy(static_cast<const uint8_t*>(msg), len);
RUN_ON_THREAD(io_thread_,
mozilla::WrapRunnable(RefPtr<NrUdpSocketIpc>(this),
&NrUdpSocketIpc::sendto_i, addr, buf),
NS_DISPATCH_NORMAL);
RUN_ON_THREAD(
io_thread_,
mozilla::WrapRunnable(RefPtr<NrUdpSocketIpc>(this),
&NrUdpSocketIpc::sendto_i, addr, std::move(buf)),
NS_DISPATCH_NORMAL);
return 0;
}
@ -1532,7 +1533,7 @@ void NrUdpSocketIpc::connect_i(const nsACString& host, const uint16_t port) {
}
void NrUdpSocketIpc::sendto_i(const net::NetAddr& addr,
nsAutoPtr<MediaPacket> buf) {
UniquePtr<MediaPacket> buf) {
ASSERT_ON_THREAD(io_thread_);
ReentrantMonitorAutoEnter mon(monitor_);
@ -1564,7 +1565,7 @@ static void ReleaseIOThread_s() { sThread->ReleaseUse(); }
// close(), but transfer the socket_child_ reference to die as well
// static
void NrUdpSocketIpc::destroy_i(dom::UDPSocketChild* aChild,
nsCOMPtr<nsIEventTarget>& aStsThread) {
const nsCOMPtr<nsIEventTarget>& aStsThread) {
RefPtr<dom::UDPSocketChild> socket_child_ref =
already_AddRefed<dom::UDPSocketChild>(aChild);
if (socket_child_ref) {

11
media/mtransport/nr_socket_prsock.h
Просмотреть файл

@ -51,7 +51,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "nspr.h"
#include "prio.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsASocketHandler.h"
#include "nsXPCOM.h"
@ -196,13 +195,13 @@ class NrSocket : public NrSocketBase, public nsASocketHandler {
};
struct nr_udp_message {
nr_udp_message(const PRNetAddr& from, nsAutoPtr<MediaPacket>& data)
: from(from), data(data) {}
nr_udp_message(const PRNetAddr& from, UniquePtr<MediaPacket>&& data)
: from(from), data(std::move(data)) {}
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nr_udp_message);
PRNetAddr from;
nsAutoPtr<MediaPacket> data;
UniquePtr<MediaPacket> data;
private:
~nr_udp_message() {}
@ -272,11 +271,11 @@ class NrUdpSocketIpc : public NrSocketIpc {
// Main or private thread executors of the NrSocketBase APIs
void create_i(const nsACString& host, const uint16_t port);
void connect_i(const nsACString& host, const uint16_t port);
void sendto_i(const net::NetAddr& addr, nsAutoPtr<MediaPacket> buf);
void sendto_i(const net::NetAddr& addr, UniquePtr<MediaPacket> buf);
void close_i();
#if defined(MOZILLA_INTERNAL_API) && !defined(MOZILLA_XPCOMRT_API)
static void destroy_i(dom::UDPSocketChild* aChild,
nsCOMPtr<nsIEventTarget>& aStsThread);
const nsCOMPtr<nsIEventTarget>& aStsThread);
#endif
// STS thread executor
void recv_callback_s(RefPtr<nr_udp_message> msg);

4
media/mtransport/nr_timer.cpp
Просмотреть файл

@ -51,7 +51,6 @@
#include <string>
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsComponentManagerUtils.h"
#include "nsServiceManagerUtils.h"
@ -61,6 +60,7 @@
#include "nsNetCID.h"
#include "runnable_utils.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/UniquePtr.h"
extern "C" {
#include "nr_api.h"
@ -177,7 +177,7 @@ static int nr_async_timer_set_zero(NR_async_cb cb, void* arg, char* func, int l,
new nrappkitScheduledCallback(cb, arg, func, l));
nsresult rv = GetSTSThread()->Dispatch(
WrapRunnable(nsAutoPtr<nrappkitScheduledCallback>(callback),
WrapRunnable(UniquePtr<nrappkitScheduledCallback>(callback),
&nrappkitScheduledCallback::Run),
NS_DISPATCH_NORMAL);
if (NS_FAILED(rv)) return R_FAILED;

1
media/mtransport/nricectx.h
Просмотреть файл

@ -61,7 +61,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "mozilla/RefPtr.h"
#include "mozilla/UniquePtr.h"
#include "nsAutoPtr.h"
#include "nsIEventTarget.h"
#include "nsTArray.h"

8
media/mtransport/test/sctp_unittest.cpp
Просмотреть файл

@ -198,14 +198,14 @@ class TransportTestPeer : public sigslot::has_slots<> {
int received() const { return received_; }
bool connected() const { return connected_; }
static TransportResult SendPacket_s(nsAutoPtr<MediaPacket> packet,
static TransportResult SendPacket_s(UniquePtr<MediaPacket> packet,
const RefPtr<TransportFlow>& flow,
TransportLayer* layer) {
return layer->SendPacket(*packet);
}
TransportResult SendPacket(const unsigned char* data, size_t len) {
nsAutoPtr<MediaPacket> packet(new MediaPacket);
UniquePtr<MediaPacket> packet(new MediaPacket);
packet->Copy(data, len);
// Uses DISPATCH_NORMAL to avoid possible deadlocks when we're called
@ -215,8 +215,8 @@ class TransportTestPeer : public sigslot::has_slots<> {
// a refptr to flow_ to avoid any async deletion issues (since we can't
// make 'this' into a refptr as it isn't refcounted)
RUN_ON_THREAD(test_utils_->sts_target(),
WrapRunnableNM(&TransportTestPeer::SendPacket_s, packet,
flow_, loopback_),
WrapRunnableNM(&TransportTestPeer::SendPacket_s,
std::move(packet), flow_, loopback_),
NS_DISPATCH_NORMAL);
return 0;

1
media/mtransport/test/test_nr_socket_unittest.cpp
Просмотреть файл

@ -23,7 +23,6 @@ extern "C" {
#include "nsCOMPtr.h"
#include "nsNetCID.h"
#include "nsServiceManagerUtils.h"
#include "nsAutoPtr.h"
#include "runnable_utils.h"
#include <vector>

8
media/mtransport/test/transport_unittests.cpp
Просмотреть файл

@ -228,7 +228,7 @@ class DtlsRecordParser {
buffer_.Copy(data, len);
}
bool NextRecord(uint8_t* ct, nsAutoPtr<MediaPacket>* buffer) {
bool NextRecord(uint8_t* ct, UniquePtr<MediaPacket>* buffer) {
if (!remaining()) return false;
CHECK_LENGTH(13U);
@ -240,12 +240,12 @@ class DtlsRecordParser {
consume(2);
CHECK_LENGTH(length);
MediaPacket* db = new MediaPacket;
auto db = MakeUnique<MediaPacket>();
db->Copy(ptr(), length);
consume(length);
*ct = *ctp;
*buffer = db;
*buffer = std::move(db);
return true;
}
@ -268,7 +268,7 @@ class DtlsRecordInspector : public Inspector {
DtlsRecordParser parser(data, len);
uint8_t ct;
nsAutoPtr<MediaPacket> buf;
UniquePtr<MediaPacket> buf;
while (parser.NextRecord(&ct, &buf)) {
OnRecord(layer, ct, buf->data(), buf->len());
}

7
media/mtransport/transportflow.cpp
Просмотреть файл

@ -25,19 +25,18 @@ TransportFlow::~TransportFlow() {
// is still some possibility that someone is accessing this
// object simultaneously, but as long as smart pointer discipline
// is maintained, it shouldn't be possible to access and
// destroy it simultaneously. The conversion to an nsAutoPtr
// destroy it simultaneously. The conversion to a UniquePtr
// ensures automatic destruction of the queue at exit of
// DestroyFinal.
MOZ_RELEASE_ASSERT(target_);
nsAutoPtr<std::deque<TransportLayer*>> layers_tmp(layers_.release());
DebugOnly<nsresult> rv = target_->Dispatch(
WrapRunnableNM(&TransportFlow::DestroyFinal, layers_tmp),
WrapRunnableNM(&TransportFlow::DestroyFinal, std::move(layers_)),
NS_DISPATCH_NORMAL);
MOZ_ASSERT(NS_SUCCEEDED(rv));
}
void TransportFlow::DestroyFinal(
nsAutoPtr<std::deque<TransportLayer*>> layers) {
UniquePtr<std::deque<TransportLayer*>> layers) {
ClearLayers(layers.get());
}

3
media/mtransport/transportflow.h
Просмотреть файл

@ -17,7 +17,6 @@
#include "mozilla/UniquePtr.h"
#include "transportlayer.h"
#include "m_cpp_utils.h"
#include "nsAutoPtr.h"
// A stack of transport layers acts as a flow.
// Generally, one reads and writes to the top layer.
@ -92,7 +91,7 @@ class TransportFlow final : public nsISupports {
void EnsureSameThread(TransportLayer* layer);
static void DestroyFinal(nsAutoPtr<std::deque<TransportLayer*>> layers);
static void DestroyFinal(UniquePtr<std::deque<TransportLayer*>> layers);
// Overload needed because we use deque internally and queue externally.
static void ClearLayers(std::deque<TransportLayer*>* layers);

1
media/mtransport/transportlayerloopback.h
Просмотреть файл

@ -16,7 +16,6 @@
#include <memory>
#include <queue>
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsINamed.h"
#include "nsITimer.h"

1
media/mtransport/transportlayersrtp.cpp
Просмотреть файл

@ -14,7 +14,6 @@
#include "mozilla/Assertions.h"
#include "transportlayerdtls.h"
#include "srtp.h"
#include "nsAutoPtr.h"
namespace mozilla {

7
media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
Просмотреть файл

@ -13,6 +13,7 @@
#include "mozilla/TemplateLib.h"
#include "mozilla/media/MediaUtils.h"
#include "mozilla/StaticPrefs_media.h"
#include "mozilla/UniquePtr.h"
#include "nsComponentManagerUtils.h"
#include "nsIPrefBranch.h"
#include "nsIGfxInfo.h"
@ -451,7 +452,7 @@ RefPtr<VideoSessionConduit> VideoSessionConduit::Create(
return nullptr;
}
nsAutoPtr<WebrtcVideoConduit> obj(new WebrtcVideoConduit(aCall, aStsThread));
auto obj = MakeRefPtr<WebrtcVideoConduit>(aCall, aStsThread);
if (obj->Init() != kMediaConduitNoError) {
CSFLogError(LOGTAG, "%s VideoConduit Init Failed ", __FUNCTION__);
return nullptr;
@ -941,7 +942,7 @@ MediaConduitErrorCode WebrtcVideoConduit::ConfigureSendMediaCodec(
codecConfig->RtcpFbNackIsSet("") ? 1000 : 0;
// Copy the applied config for future reference.
mCurSendCodecConfig = new VideoCodecConfig(*codecConfig);
mCurSendCodecConfig = MakeUnique<VideoCodecConfig>(*codecConfig);
mSendStreamConfig.rtp.rids.clear();
bool has_rid = false;
@ -1797,7 +1798,7 @@ void WebrtcVideoConduit::SelectSendResolution(unsigned short width,
}
unsigned int framerate = SelectSendFrameRate(
mCurSendCodecConfig, mSendingFramerate, width, height);
mCurSendCodecConfig.get(), mSendingFramerate, width, height);
if (mSendingFramerate != framerate) {
CSFLogDebug(LOGTAG, "%s: framerate changing to %u (from %u)", __FUNCTION__,
framerate, mSendingFramerate);

4
media/webrtc/signaling/src/media-conduit/VideoConduit.h
Просмотреть файл

@ -9,7 +9,7 @@
#include "mozilla/Attributes.h"
#include "mozilla/ReentrantMonitor.h"
#include "mozilla/SharedThreadPool.h"
#include "nsAutoPtr.h"
#include "mozilla/UniquePtr.h"
#include "nsITimer.h"
#include "MediaConduitInterface.h"
@ -523,7 +523,7 @@ class WebrtcVideoConduit
nsTArray<UniquePtr<VideoCodecConfig>> mRecvCodecList;
// Written only on main thread. Guarded by mMutex, except for reads on main.
nsAutoPtr<VideoCodecConfig> mCurSendCodecConfig;
UniquePtr<VideoCodecConfig> mCurSendCodecConfig;
bool mUpdateResolution = false;
int mSinkWantsPixelCount = std::numeric_limits<int>::max();

27
media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.cpp
Просмотреть файл

@ -322,7 +322,8 @@ void WebrtcGmpVideoEncoder::RegetEncoderForResolutionChange(
}
void WebrtcGmpVideoEncoder::Encode_g(
RefPtr<WebrtcGmpVideoEncoder>& aEncoder, webrtc::VideoFrame aInputImage,
const RefPtr<WebrtcGmpVideoEncoder>& aEncoder,
webrtc::VideoFrame aInputImage,
std::vector<webrtc::FrameType> aFrameTypes) {
if (!aEncoder->mGMP) {
// destroyed via Terminate(), failed to init, or just not initted yet
@ -420,7 +421,7 @@ int32_t WebrtcGmpVideoEncoder::RegisterEncodeCompleteCallback(
/* static */
void WebrtcGmpVideoEncoder::ReleaseGmp_g(
RefPtr<WebrtcGmpVideoEncoder>& aEncoder) {
const RefPtr<WebrtcGmpVideoEncoder>& aEncoder) {
aEncoder->Close_g();
}
@ -743,8 +744,7 @@ int32_t WebrtcGmpVideoDecoder::GmpInitDone(GMPVideoDecoderProxy* aGMP,
nsTArray<UniquePtr<GMPDecodeData>> temp;
temp.SwapElements(mQueuedFrames);
for (auto& queued : temp) {
Decode_g(RefPtr<WebrtcGmpVideoDecoder>(this),
nsAutoPtr<GMPDecodeData>(queued.release()));
Decode_g(RefPtr<WebrtcGmpVideoDecoder>(this), std::move(queued));
}
}
@ -792,13 +792,13 @@ int32_t WebrtcGmpVideoDecoder::Decode(
// know to request a PLI and the video stream will remain frozen unless an IDR
// happens to arrive for other reasons. Bug 1492852 tracks implementing a
// proper solution.
nsAutoPtr<GMPDecodeData> decodeData(
new GMPDecodeData(aInputImage, aMissingFrames, aRenderTimeMs));
auto decodeData =
MakeUnique<GMPDecodeData>(aInputImage, aMissingFrames, aRenderTimeMs);
mGMPThread->Dispatch(
WrapRunnableNM(&WebrtcGmpVideoDecoder::Decode_g,
RefPtr<WebrtcGmpVideoDecoder>(this), decodeData),
NS_DISPATCH_NORMAL);
mGMPThread->Dispatch(WrapRunnableNM(&WebrtcGmpVideoDecoder::Decode_g,
RefPtr<WebrtcGmpVideoDecoder>(this),
std::move(decodeData)),
NS_DISPATCH_NORMAL);
if (mDecoderStatus != GMPNoErr) {
GMP_LOG_ERROR("%s: Decoder status is bad (%u)!", __PRETTY_FUNCTION__,
@ -810,13 +810,12 @@ int32_t WebrtcGmpVideoDecoder::Decode(
}
/* static */
// Using nsAutoPtr because WrapRunnable doesn't support move semantics
void WebrtcGmpVideoDecoder::Decode_g(const RefPtr<WebrtcGmpVideoDecoder>& aThis,
nsAutoPtr<GMPDecodeData> aDecodeData) {
UniquePtr<GMPDecodeData>&& aDecodeData) {
if (!aThis->mGMP) {
if (aThis->mInitting) {
// InitDone hasn't been called yet (race)
aThis->mQueuedFrames.AppendElement(aDecodeData.forget());
aThis->mQueuedFrames.AppendElement(std::move(aDecodeData));
return;
}
// destroyed via Terminate(), failed to init, or just not initted yet
@ -909,7 +908,7 @@ int32_t WebrtcGmpVideoDecoder::RegisterDecodeCompleteCallback(
/* static */
void WebrtcGmpVideoDecoder::ReleaseGmp_g(
RefPtr<WebrtcGmpVideoDecoder>& aDecoder) {
const RefPtr<WebrtcGmpVideoDecoder>& aDecoder) {
aDecoder->Close_g();
}

8
media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.h
Просмотреть файл

@ -217,7 +217,7 @@ class WebrtcGmpVideoEncoder : public GMPVideoEncoderCallbackProxy,
std::string* aErrorOut);
int32_t InitEncoderForSize(unsigned short aWidth, unsigned short aHeight,
std::string* aErrorOut);
static void ReleaseGmp_g(RefPtr<WebrtcGmpVideoEncoder>& aEncoder);
static void ReleaseGmp_g(const RefPtr<WebrtcGmpVideoEncoder>& aEncoder);
void Close_g();
class InitDoneCallback : public GetGMPVideoEncoderCallback {
@ -247,7 +247,7 @@ class WebrtcGmpVideoEncoder : public GMPVideoEncoderCallbackProxy,
uint32_t mMaxPayloadSize;
};
static void Encode_g(RefPtr<WebrtcGmpVideoEncoder>& aEncoder,
static void Encode_g(const RefPtr<WebrtcGmpVideoEncoder>& aEncoder,
webrtc::VideoFrame aInputImage,
std::vector<webrtc::FrameType> aFrameTypes);
void RegetEncoderForResolutionChange(
@ -405,7 +405,7 @@ class WebrtcGmpVideoDecoder : public GMPVideoDecoderCallbackProxy {
const RefPtr<GmpInitDoneRunnable>& aInitDone);
int32_t GmpInitDone(GMPVideoDecoderProxy* aGMP, GMPVideoHost* aHost,
std::string* aErrorOut);
static void ReleaseGmp_g(RefPtr<WebrtcGmpVideoDecoder>& aDecoder);
static void ReleaseGmp_g(const RefPtr<WebrtcGmpVideoDecoder>& aDecoder);
void Close_g();
class InitDoneCallback : public GetGMPVideoDecoderCallback {
@ -428,7 +428,7 @@ class WebrtcGmpVideoDecoder : public GMPVideoDecoderCallbackProxy {
};
static void Decode_g(const RefPtr<WebrtcGmpVideoDecoder>& aThis,
nsAutoPtr<GMPDecodeData> aDecodeData);
UniquePtr<GMPDecodeData>&& aDecodeData);
nsCOMPtr<mozIGeckoMediaPluginService> mMPS;
nsCOMPtr<nsIThread> mGMPThread;

2
media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.cpp
Просмотреть файл

@ -170,7 +170,7 @@ static java::sdk::MediaCodec::LocalRef CreateEncoder(const char* aMimeType) {
return codec;
}
static void ShutdownThread(nsCOMPtr<nsIThread>& aThread) {
static void ShutdownThread(const nsCOMPtr<nsIThread>& aThread) {
aThread->Shutdown();
}

1
media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.h
Просмотреть файл

@ -9,7 +9,6 @@
#include "mozilla/Mutex.h"
#include "nsThreadUtils.h"
#include "nsAutoPtr.h"
#include "MediaConduitInterface.h"
#include "AudioConduit.h"

8
media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp
Просмотреть файл

@ -485,7 +485,7 @@ void MediaPipeline::IncrementRtcpPacketsReceived() {
}
}
void MediaPipeline::RtpPacketReceived(MediaPacket& packet) {
void MediaPipeline::RtpPacketReceived(const MediaPacket& packet) {
if (mDirection == DirectionType::TRANSMIT) {
return;
}
@ -572,7 +572,7 @@ void MediaPipeline::RtpPacketReceived(MediaPacket& packet) {
header.ssrc); // Ignore error codes
}
void MediaPipeline::RtcpPacketReceived(MediaPacket& packet) {
void MediaPipeline::RtcpPacketReceived(const MediaPacket& packet) {
if (!mTransport->Pipeline()) {
MOZ_LOG(gMediaPipelineLog, LogLevel::Debug,
("Discarding incoming packet; transport disconnected"));
@ -620,7 +620,7 @@ void MediaPipeline::RtcpPacketReceived(MediaPacket& packet) {
}
void MediaPipeline::PacketReceived(const std::string& aTransportId,
MediaPacket& packet) {
const MediaPacket& packet) {
if (mTransportId != aTransportId) {
return;
}
@ -650,7 +650,7 @@ void MediaPipeline::AlpnNegotiated(const std::string& aAlpn,
}
void MediaPipeline::EncryptedPacketSending(const std::string& aTransportId,
MediaPacket& aPacket) {
const MediaPacket& aPacket) {
if (mTransportId == aTransportId) {
dom::mozPacketDumpType type;
if (aPacket.type() == MediaPacket::SRTP) {

9
media/webrtc/signaling/src/mediapipeline/MediaPipeline.h
Просмотреть файл

@ -207,14 +207,15 @@ class MediaPipeline : public sigslot::has_slots<> {
void RtpStateChange(const std::string& aTransportId, TransportLayer::State);
void RtcpStateChange(const std::string& aTransportId, TransportLayer::State);
virtual void CheckTransportStates();
void PacketReceived(const std::string& aTransportId, MediaPacket& packet);
void PacketReceived(const std::string& aTransportId,
const MediaPacket& packet);
void AlpnNegotiated(const std::string& aAlpn, bool aPrivacyRequested);
void RtpPacketReceived(MediaPacket& packet);
void RtcpPacketReceived(MediaPacket& packet);
void RtpPacketReceived(const MediaPacket& packet);
void RtcpPacketReceived(const MediaPacket& packet);
void EncryptedPacketSending(const std::string& aTransportId,
MediaPacket& aPacket);
const MediaPacket& aPacket);
void SetDescription_s(const std::string& description);

14
media/webrtc/signaling/src/peerconnection/MediaTransportHandler.cpp
Просмотреть файл

@ -869,12 +869,12 @@ void MediaTransportHandler::OnConnectionStateChange(
}
void MediaTransportHandler::OnPacketReceived(const std::string& aTransportId,
MediaPacket& aPacket) {
const MediaPacket& aPacket) {
if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) {
mCallbackThread->Dispatch(
WrapRunnable(RefPtr<MediaTransportHandler>(this),
&MediaTransportHandler::OnPacketReceived, aTransportId,
aPacket),
const_cast<MediaPacket&>(aPacket)),
NS_DISPATCH_NORMAL);
return;
}
@ -883,12 +883,12 @@ void MediaTransportHandler::OnPacketReceived(const std::string& aTransportId,
}
void MediaTransportHandler::OnEncryptedSending(const std::string& aTransportId,
MediaPacket& aPacket) {
const MediaPacket& aPacket) {
if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) {
mCallbackThread->Dispatch(
WrapRunnable(RefPtr<MediaTransportHandler>(this),
&MediaTransportHandler::OnEncryptedSending, aTransportId,
aPacket),
const_cast<MediaPacket&>(aPacket)),
NS_DISPATCH_NORMAL);
return;
}
@ -958,12 +958,12 @@ MediaTransportHandlerSTS::GetIceLog(const nsCString& aPattern) {
mStsThread, __func__, [=, self = RefPtr<MediaTransportHandlerSTS>(this)] {
dom::Sequence<nsString> converted;
RLogConnector* logs = RLogConnector::GetInstance();
nsAutoPtr<std::deque<std::string>> result(new std::deque<std::string>);
std::deque<std::string> result;
// Might not exist yet.
if (logs) {
logs->Filter(aPattern.get(), 0, result);
logs->Filter(aPattern.get(), 0, &result);
}
for (auto& line : *result) {
for (auto& line : result) {
converted.AppendElement(NS_ConvertUTF8toUTF16(line.c_str()),
fallible);
}

10
media/webrtc/signaling/src/peerconnection/MediaTransportHandler.h
Просмотреть файл

@ -123,8 +123,9 @@ class MediaTransportHandler {
sigslot::signal1<dom::RTCIceGatheringState> SignalGatheringStateChange;
sigslot::signal1<dom::RTCIceConnectionState> SignalConnectionStateChange;
sigslot::signal2<const std::string&, MediaPacket&> SignalPacketReceived;
sigslot::signal2<const std::string&, MediaPacket&> SignalEncryptedSending;
sigslot::signal2<const std::string&, const MediaPacket&> SignalPacketReceived;
sigslot::signal2<const std::string&, const MediaPacket&>
SignalEncryptedSending;
sigslot::signal2<const std::string&, TransportLayer::State> SignalStateChange;
sigslot::signal2<const std::string&, TransportLayer::State>
SignalRtcpStateChange;
@ -139,9 +140,10 @@ class MediaTransportHandler {
void OnAlpnNegotiated(const std::string& aAlpn);
void OnGatheringStateChange(dom::RTCIceGatheringState aState);
void OnConnectionStateChange(dom::RTCIceConnectionState aState);
void OnPacketReceived(const std::string& aTransportId, MediaPacket& aPacket);
void OnPacketReceived(const std::string& aTransportId,
const MediaPacket& aPacket);
void OnEncryptedSending(const std::string& aTransportId,
MediaPacket& aPacket);
const MediaPacket& aPacket);
void OnStateChange(const std::string& aTransportId,
TransportLayer::State aState);
void OnRtcpStateChange(const std::string& aTransportId,

5
media/webrtc/signaling/src/peerconnection/MediaTransportParent.cpp
Просмотреть файл

@ -61,12 +61,13 @@ class MediaTransportParent::Impl : public sigslot::has_slots<> {
mParent->SendOnConnectionStateChange(static_cast<int>(aState)));
}
void OnPacketReceived(const std::string& aTransportId, MediaPacket& aPacket) {
void OnPacketReceived(const std::string& aTransportId,
const MediaPacket& aPacket) {
NS_ENSURE_TRUE_VOID(mParent->SendOnPacketReceived(aTransportId, aPacket));
}
void OnEncryptedSending(const std::string& aTransportId,
MediaPacket& aPacket) {
const MediaPacket& aPacket) {
NS_ENSURE_TRUE_VOID(mParent->SendOnEncryptedSending(aTransportId, aPacket));
}

1
media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
Просмотреть файл

@ -12,7 +12,6 @@
#include "prlock.h"
#include "mozilla/RefPtr.h"
#include "nsAutoPtr.h"
#include "nsComponentManagerUtils.h"
#include "nsPIDOMWindow.h"
#include "nsIUUIDGenerator.h"

1
media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp
Просмотреть файл

@ -19,7 +19,6 @@
#include "mozilla/dom/WebrtcGlobalInformationBinding.h"
#include "mozilla/dom/ContentChild.h"
#include "nsAutoPtr.h"
#include "nsNetCID.h" // NS_SOCKETTRANSPORTSERVICE_CONTRACTID
#include "nsServiceManagerUtils.h" // do_GetService
#include "mozilla/ErrorResult.h"

2
netwerk/sctp/datachannel/DataChannel.cpp
Просмотреть файл

@ -844,7 +844,7 @@ void DataChannelConnection::ProcessQueuedOpens() {
}
void DataChannelConnection::SctpDtlsInput(const std::string& aTransportId,
MediaPacket& packet) {
const MediaPacket& packet) {
if ((packet.type() != MediaPacket::SCTP) || (mTransportId != aTransportId)) {
return;
}

3
netwerk/sctp/datachannel/DataChannel.h
Просмотреть файл

@ -243,7 +243,8 @@ class DataChannelConnection final : public net::NeckoTargetHolder
#ifdef SCTP_DTLS_SUPPORTED
static void DTLSConnectThread(void* data);
void SendPacket(std::unique_ptr<MediaPacket>&& packet);
void SctpDtlsInput(const std::string& aTransportId, MediaPacket& packet);
void SctpDtlsInput(const std::string& aTransportId,
const MediaPacket& packet);
static int SctpDtlsOutput(void* addr, void* buffer, size_t length,
uint8_t tos, uint8_t set_df);
#endif