2016-05-27 21:54:31 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
2011-06-03 18:33:56 +00:00
|
|
|
|
|
|
|
#include "base/process_util.h"
|
2016-10-11 21:25:17 +00:00
|
|
|
#include "base/task.h"
|
2011-06-03 18:33:56 +00:00
|
|
|
|
2016-04-01 06:33:52 +00:00
|
|
|
#ifdef OS_POSIX
|
|
|
|
#include <errno.h>
|
|
|
|
#endif
|
|
|
|
|
2016-12-14 16:32:21 +00:00
|
|
|
#include "mozilla/IntegerPrintfMacros.h"
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
#include "mozilla/ipc/ProtocolUtils.h"
|
2016-08-05 19:00:19 +00:00
|
|
|
|
|
|
|
#include "mozilla/dom/ContentParent.h"
|
|
|
|
#include "mozilla/ipc/MessageChannel.h"
|
2011-06-03 18:33:56 +00:00
|
|
|
#include "mozilla/ipc/Transport.h"
|
2015-03-23 21:34:38 +00:00
|
|
|
#include "mozilla/StaticMutex.h"
|
2017-05-10 19:52:20 +00:00
|
|
|
#include "mozilla/SystemGroup.h"
|
2016-11-02 04:05:38 +00:00
|
|
|
#include "mozilla/Unused.h"
|
2016-08-05 19:00:19 +00:00
|
|
|
#include "nsPrintfCString.h"
|
2011-06-03 18:33:56 +00:00
|
|
|
|
2015-04-01 08:40:35 +00:00
|
|
|
#if defined(MOZ_SANDBOX) && defined(XP_WIN)
|
|
|
|
#define TARGET_SANDBOX_EXPORTS
|
|
|
|
#include "mozilla/sandboxTarget.h"
|
|
|
|
#endif
|
|
|
|
|
2016-04-19 11:08:55 +00:00
|
|
|
#if defined(MOZ_CRASHREPORTER) && defined(XP_WIN)
|
2016-04-23 11:04:59 +00:00
|
|
|
#include "aclapi.h"
|
|
|
|
#include "sddl.h"
|
2016-05-06 11:01:29 +00:00
|
|
|
|
|
|
|
#include "mozilla/TypeTraits.h"
|
2016-04-19 11:08:55 +00:00
|
|
|
#endif
|
|
|
|
|
2016-06-07 20:10:18 +00:00
|
|
|
#include "nsAutoPtr.h"
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
using namespace IPC;
|
2011-06-03 18:33:56 +00:00
|
|
|
|
2015-04-01 08:40:35 +00:00
|
|
|
using base::GetCurrentProcId;
|
2015-02-11 20:01:26 +00:00
|
|
|
using base::ProcessHandle;
|
|
|
|
using base::ProcessId;
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
namespace mozilla {
|
2016-05-06 11:01:29 +00:00
|
|
|
|
|
|
|
#if defined(MOZ_CRASHREPORTER) && defined(XP_WIN)
|
|
|
|
// Generate RAII classes for LPTSTR and PSECURITY_DESCRIPTOR.
|
|
|
|
MOZ_TYPE_SPECIFIC_SCOPED_POINTER_TEMPLATE(ScopedLPTStr, \
|
|
|
|
RemovePointer<LPTSTR>::Type, \
|
|
|
|
::LocalFree)
|
|
|
|
MOZ_TYPE_SPECIFIC_SCOPED_POINTER_TEMPLATE(ScopedPSecurityDescriptor, \
|
|
|
|
RemovePointer<PSECURITY_DESCRIPTOR>::Type, \
|
|
|
|
::LocalFree)
|
|
|
|
#endif
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
namespace ipc {
|
|
|
|
|
2016-11-15 03:26:00 +00:00
|
|
|
IPCResult
|
|
|
|
IPCResult::Fail(NotNull<IProtocol*> actor, const char* where, const char* why)
|
|
|
|
{
|
|
|
|
// Calls top-level protocol to handle the error.
|
|
|
|
nsPrintfCString errorMsg("%s::%s %s\n", actor->ProtocolName(), where, why);
|
|
|
|
actor->GetIPCChannel()->Listener()->ProcessingError(
|
|
|
|
HasResultCodes::MsgProcessingError, errorMsg.get());
|
|
|
|
return IPCResult(false);
|
|
|
|
}
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
class ChannelOpened : public IPC::Message
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
ChannelOpened(TransportDescriptor aDescriptor,
|
|
|
|
ProcessId aOtherProcess,
|
2014-12-19 01:35:48 +00:00
|
|
|
ProtocolId aProtocol,
|
2016-09-30 23:20:50 +00:00
|
|
|
NestedLevel aNestedLevel = NOT_NESTED)
|
2011-06-03 18:33:56 +00:00
|
|
|
: IPC::Message(MSG_ROUTING_CONTROL, // these only go to top-level actors
|
|
|
|
CHANNEL_OPENED_MESSAGE_TYPE,
|
2017-06-21 09:55:13 +00:00
|
|
|
0,
|
Bug 1397823 - part 3 - do a better job setting IPC::Message flags; r=kanru
The current IPC::Message constructor takes a large number of arguments,
three of which--the nesting level, the priority, and the
compression--are almost always constant by virtue of the vast majority
of Message construction being done by auto-generated IPDL code. But
then we take these constant values into the Message constructor, we
check them for various values, and then based on those values, we
perform a bunch of bitfield operations to store flags based on those
values. This is wasted work.
Furthermore, for replies to IPDL messages, we'll construct a Message
object, and then call mutating setters on the Message object that will
perform even more bitfield manipulations. Again, these operations are
performing tasks at runtime that are the same every single time, and use
information we already have at compile time.
The impact of these extra operations is not large, maybe 15-30K of extra
code, depending on platform. Nonetheless, we can easily make them go
away, and make everything cleaner to boot.
This patch adds a HeaderFlags class that encapsulates all the knowledge
about the various kinds of flags Message needs to know about. We can
construct HeaderFlags objects with strongly-typed enum arguments for the
various kinds of flags, and the compiler can take care of folding all of
those flags together into a constant when possible (and it is possible
for all the IPDL-generated code that instantiates Messages). The upshot
is that we do no unnecessary work in the Message constructor itself. We
can also remove various mutating operations on Message, as those
operations were only there to support post-constructor flag twiddling,
which is no longer necessary.
2017-09-15 12:06:11 +00:00
|
|
|
HeaderFlags(aNestedLevel))
|
2011-06-03 18:33:56 +00:00
|
|
|
{
|
|
|
|
IPC::WriteParam(this, aDescriptor);
|
|
|
|
IPC::WriteParam(this, aOtherProcess);
|
2012-09-17 08:37:20 +00:00
|
|
|
IPC::WriteParam(this, static_cast<uint32_t>(aProtocol));
|
2011-06-03 18:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool Read(const IPC::Message& aMsg,
|
|
|
|
TransportDescriptor* aDescriptor,
|
|
|
|
ProcessId* aOtherProcess,
|
|
|
|
ProtocolId* aProtocol)
|
|
|
|
{
|
2016-04-21 04:09:15 +00:00
|
|
|
PickleIterator iter(aMsg);
|
2011-06-03 18:33:56 +00:00
|
|
|
if (!IPC::ReadParam(&aMsg, &iter, aDescriptor) ||
|
|
|
|
!IPC::ReadParam(&aMsg, &iter, aOtherProcess) ||
|
2012-09-17 08:37:20 +00:00
|
|
|
!IPC::ReadParam(&aMsg, &iter, reinterpret_cast<uint32_t*>(aProtocol))) {
|
2011-06-03 18:33:56 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
aMsg.EndRead(iter);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-07-10 00:07:49 +00:00
|
|
|
nsresult
|
2011-06-03 18:33:56 +00:00
|
|
|
Bridge(const PrivateIPDLInterface&,
|
2015-04-01 08:40:35 +00:00
|
|
|
MessageChannel* aParentChannel, ProcessId aParentPid,
|
|
|
|
MessageChannel* aChildChannel, ProcessId aChildPid,
|
2013-08-20 19:46:41 +00:00
|
|
|
ProtocolId aProtocol, ProtocolId aChildProtocol)
|
2011-06-03 18:33:56 +00:00
|
|
|
{
|
2015-04-01 08:40:35 +00:00
|
|
|
if (!aParentPid || !aChildPid) {
|
2015-07-10 00:07:49 +00:00
|
|
|
return NS_ERROR_INVALID_ARG;
|
2011-06-03 18:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TransportDescriptor parentSide, childSide;
|
2015-07-10 00:07:49 +00:00
|
|
|
nsresult rv;
|
|
|
|
if (NS_FAILED(rv = CreateTransport(aParentPid, &parentSide, &childSide))) {
|
|
|
|
return rv;
|
2011-06-03 18:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!aParentChannel->Send(new ChannelOpened(parentSide,
|
2015-04-01 08:40:35 +00:00
|
|
|
aChildPid,
|
2014-12-19 01:35:48 +00:00
|
|
|
aProtocol,
|
2016-09-30 23:20:50 +00:00
|
|
|
IPC::Message::NESTED_INSIDE_CPOW))) {
|
2011-06-03 18:33:56 +00:00
|
|
|
CloseDescriptor(parentSide);
|
|
|
|
CloseDescriptor(childSide);
|
2015-07-10 00:07:49 +00:00
|
|
|
return NS_ERROR_BRIDGE_OPEN_PARENT;
|
2011-06-03 18:33:56 +00:00
|
|
|
}
|
2015-07-10 00:07:49 +00:00
|
|
|
|
|
|
|
if (!aChildChannel->Send(new ChannelOpened(childSide,
|
|
|
|
aParentPid,
|
|
|
|
aChildProtocol,
|
2016-09-30 23:20:50 +00:00
|
|
|
IPC::Message::NESTED_INSIDE_CPOW))) {
|
2015-07-10 00:07:49 +00:00
|
|
|
CloseDescriptor(parentSide);
|
|
|
|
CloseDescriptor(childSide);
|
|
|
|
return NS_ERROR_BRIDGE_OPEN_CHILD;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
2011-06-03 18:33:56 +00:00
|
|
|
}
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
bool
|
|
|
|
Open(const PrivateIPDLInterface&,
|
2015-04-01 08:40:35 +00:00
|
|
|
MessageChannel* aOpenerChannel, ProcessId aOtherProcessId,
|
2011-06-03 18:33:56 +00:00
|
|
|
Transport::Mode aOpenerMode,
|
2013-08-20 19:46:41 +00:00
|
|
|
ProtocolId aProtocol, ProtocolId aChildProtocol)
|
2011-06-03 18:33:56 +00:00
|
|
|
{
|
|
|
|
bool isParent = (Transport::MODE_SERVER == aOpenerMode);
|
2015-04-01 08:40:35 +00:00
|
|
|
ProcessId thisPid = GetCurrentProcId();
|
|
|
|
ProcessId parentId = isParent ? thisPid : aOtherProcessId;
|
|
|
|
ProcessId childId = !isParent ? thisPid : aOtherProcessId;
|
2011-06-03 18:33:56 +00:00
|
|
|
if (!parentId || !childId) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
TransportDescriptor parentSide, childSide;
|
2015-07-10 00:07:49 +00:00
|
|
|
if (NS_FAILED(CreateTransport(parentId, &parentSide, &childSide))) {
|
2011-06-03 18:33:56 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Message* parentMsg = new ChannelOpened(parentSide, childId, aProtocol);
|
2013-08-20 19:46:41 +00:00
|
|
|
Message* childMsg = new ChannelOpened(childSide, parentId, aChildProtocol);
|
2011-06-03 18:33:56 +00:00
|
|
|
nsAutoPtr<Message> messageForUs(isParent ? parentMsg : childMsg);
|
|
|
|
nsAutoPtr<Message> messageForOtherSide(!isParent ? parentMsg : childMsg);
|
|
|
|
if (!aOpenerChannel->Echo(messageForUs.forget()) ||
|
|
|
|
!aOpenerChannel->Send(messageForOtherSide.forget())) {
|
|
|
|
CloseDescriptor(parentSide);
|
|
|
|
CloseDescriptor(childSide);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
bool
|
|
|
|
UnpackChannelOpened(const PrivateIPDLInterface&,
|
2011-06-03 18:33:56 +00:00
|
|
|
const Message& aMsg,
|
2011-06-03 18:33:56 +00:00
|
|
|
TransportDescriptor* aTransport,
|
|
|
|
ProcessId* aOtherProcess,
|
|
|
|
ProtocolId* aProtocol)
|
|
|
|
{
|
|
|
|
return ChannelOpened::Read(aMsg, aTransport, aOtherProcess, aProtocol);
|
|
|
|
}
|
|
|
|
|
2015-04-01 08:40:35 +00:00
|
|
|
#if defined(XP_WIN)
|
|
|
|
bool DuplicateHandle(HANDLE aSourceHandle,
|
|
|
|
DWORD aTargetProcessId,
|
|
|
|
HANDLE* aTargetHandle,
|
|
|
|
DWORD aDesiredAccess,
|
|
|
|
DWORD aOptions) {
|
|
|
|
// If our process is the target just duplicate the handle.
|
2015-04-01 12:59:20 +00:00
|
|
|
if (aTargetProcessId == base::GetCurrentProcId()) {
|
2015-04-01 08:40:35 +00:00
|
|
|
return !!::DuplicateHandle(::GetCurrentProcess(), aSourceHandle,
|
|
|
|
::GetCurrentProcess(), aTargetHandle,
|
|
|
|
aDesiredAccess, false, aOptions);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(MOZ_SANDBOX)
|
|
|
|
// Try the broker next (will fail if not sandboxed).
|
|
|
|
if (SandboxTarget::Instance()->BrokerDuplicateHandle(aSourceHandle,
|
|
|
|
aTargetProcessId,
|
|
|
|
aTargetHandle,
|
|
|
|
aDesiredAccess,
|
|
|
|
aOptions)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Finally, see if we already have access to the process.
|
2016-05-06 11:01:29 +00:00
|
|
|
ScopedProcessHandle targetProcess(OpenProcess(PROCESS_DUP_HANDLE,
|
|
|
|
FALSE,
|
|
|
|
aTargetProcessId));
|
|
|
|
if (!targetProcess) {
|
2016-08-16 11:32:30 +00:00
|
|
|
#ifdef MOZ_CRASHREPORTER
|
2016-05-06 11:01:29 +00:00
|
|
|
CrashReporter::AnnotateCrashReport(
|
|
|
|
NS_LITERAL_CSTRING("IPCTransportFailureReason"),
|
|
|
|
NS_LITERAL_CSTRING("Failed to open target process."));
|
|
|
|
#endif
|
2015-04-01 08:40:35 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return !!::DuplicateHandle(::GetCurrentProcess(), aSourceHandle,
|
|
|
|
targetProcess, aTargetHandle,
|
|
|
|
aDesiredAccess, FALSE, aOptions);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-04-01 06:33:52 +00:00
|
|
|
#ifdef MOZ_CRASHREPORTER
|
2016-04-19 11:08:55 +00:00
|
|
|
void
|
|
|
|
AnnotateSystemError()
|
2016-04-01 06:33:52 +00:00
|
|
|
{
|
|
|
|
int64_t error = 0;
|
|
|
|
#if defined(XP_WIN)
|
|
|
|
error = ::GetLastError();
|
|
|
|
#elif defined(OS_POSIX)
|
|
|
|
error = errno;
|
|
|
|
#endif
|
|
|
|
if (error) {
|
2016-04-19 11:08:55 +00:00
|
|
|
CrashReporter::AnnotateCrashReport(
|
|
|
|
NS_LITERAL_CSTRING("IPCSystemError"),
|
2016-12-14 16:32:21 +00:00
|
|
|
nsPrintfCString("%" PRId64, error));
|
2016-04-19 11:08:55 +00:00
|
|
|
}
|
|
|
|
}
|
2016-04-01 06:33:52 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-23 05:52:04 +00:00
|
|
|
#if defined(MOZ_CRASHREPORTER) && defined(XP_MACOSX)
|
|
|
|
void
|
|
|
|
AnnotateCrashReportWithErrno(const char* tag, int error)
|
|
|
|
{
|
|
|
|
CrashReporter::AnnotateCrashReport(
|
|
|
|
nsCString(tag),
|
|
|
|
nsPrintfCString("%d", error));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-03-25 21:02:38 +00:00
|
|
|
void
|
|
|
|
LogMessageForProtocol(const char* aTopLevelProtocol, base::ProcessId aOtherPid,
|
|
|
|
const char* aContextDescription,
|
2016-10-13 06:18:45 +00:00
|
|
|
uint32_t aMessageId,
|
2016-03-25 21:02:38 +00:00
|
|
|
MessageDirection aDirection)
|
|
|
|
{
|
|
|
|
nsPrintfCString logMessage("[time: %" PRId64 "][%d%s%d] [%s] %s %s\n",
|
|
|
|
PR_Now(), base::GetCurrentProcId(),
|
|
|
|
aDirection == MessageDirection::eReceiving ? "<-" : "->",
|
|
|
|
aOtherPid, aTopLevelProtocol,
|
|
|
|
aContextDescription,
|
2016-10-13 06:18:45 +00:00
|
|
|
StringFromIPCMessageType(aMessageId));
|
2016-03-25 21:02:38 +00:00
|
|
|
#ifdef ANDROID
|
|
|
|
__android_log_write(ANDROID_LOG_INFO, "GeckoIPC", logMessage.get());
|
|
|
|
#endif
|
|
|
|
fputs(logMessage.get(), stderr);
|
|
|
|
}
|
|
|
|
|
2013-07-24 16:38:24 +00:00
|
|
|
void
|
|
|
|
ProtocolErrorBreakpoint(const char* aMsg)
|
|
|
|
{
|
|
|
|
// Bugs that generate these error messages can be tough to
|
|
|
|
// reproduce. Log always in the hope that someone finds the error
|
|
|
|
// message.
|
|
|
|
printf_stderr("IPDL protocol error: %s\n", aMsg);
|
|
|
|
}
|
|
|
|
|
2013-08-22 14:39:32 +00:00
|
|
|
void
|
2016-04-06 14:31:21 +00:00
|
|
|
FatalError(const char* aProtocolName, const char* aMsg, bool aIsParent)
|
2013-08-22 14:39:32 +00:00
|
|
|
{
|
|
|
|
ProtocolErrorBreakpoint(aMsg);
|
|
|
|
|
|
|
|
nsAutoCString formattedMessage("IPDL error [");
|
|
|
|
formattedMessage.AppendASCII(aProtocolName);
|
|
|
|
formattedMessage.AppendLiteral("]: \"");
|
|
|
|
formattedMessage.AppendASCII(aMsg);
|
|
|
|
if (aIsParent) {
|
2015-08-18 19:28:01 +00:00
|
|
|
#ifdef MOZ_CRASHREPORTER
|
|
|
|
// We're going to crash the parent process because at this time
|
|
|
|
// there's no other really nice way of getting a minidump out of
|
|
|
|
// this process if we're off the main thread.
|
|
|
|
formattedMessage.AppendLiteral("\". Intentionally crashing.");
|
2013-08-22 14:39:32 +00:00
|
|
|
NS_ERROR(formattedMessage.get());
|
2015-08-18 19:28:01 +00:00
|
|
|
CrashReporter::AnnotateCrashReport(NS_LITERAL_CSTRING("IPCFatalErrorProtocol"),
|
|
|
|
nsDependentCString(aProtocolName));
|
|
|
|
CrashReporter::AnnotateCrashReport(NS_LITERAL_CSTRING("IPCFatalErrorMsg"),
|
|
|
|
nsDependentCString(aMsg));
|
2016-04-01 06:33:52 +00:00
|
|
|
AnnotateSystemError();
|
2015-08-18 19:28:01 +00:00
|
|
|
#endif
|
|
|
|
MOZ_CRASH("IPC FatalError in the parent process!");
|
2013-08-22 14:39:32 +00:00
|
|
|
} else {
|
|
|
|
formattedMessage.AppendLiteral("\". abort()ing as a result.");
|
2017-10-25 06:38:38 +00:00
|
|
|
MOZ_CRASH_UNSAFE_OOL(formattedMessage.get());
|
2013-08-22 14:39:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-06 14:53:06 +00:00
|
|
|
void
|
|
|
|
LogicError(const char* aMsg)
|
|
|
|
{
|
2017-10-25 06:38:38 +00:00
|
|
|
MOZ_CRASH_UNSAFE_OOL(aMsg);
|
2016-04-06 14:53:06 +00:00
|
|
|
}
|
|
|
|
|
2016-05-21 08:07:56 +00:00
|
|
|
void
|
|
|
|
ActorIdReadError(const char* aActorDescription)
|
|
|
|
{
|
|
|
|
nsPrintfCString message("Error deserializing id for %s", aActorDescription);
|
|
|
|
NS_RUNTIMEABORT(message.get());
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
BadActorIdError(const char* aActorDescription)
|
|
|
|
{
|
|
|
|
nsPrintfCString message("bad id for %s", aActorDescription);
|
|
|
|
ProtocolErrorBreakpoint(message.get());
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ActorLookupError(const char* aActorDescription)
|
|
|
|
{
|
|
|
|
nsPrintfCString message("could not lookup id for %s", aActorDescription);
|
|
|
|
ProtocolErrorBreakpoint(message.get());
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MismatchedActorTypeError(const char* aActorDescription)
|
|
|
|
{
|
|
|
|
nsPrintfCString message("actor that should be of type %s has different type",
|
|
|
|
aActorDescription);
|
|
|
|
ProtocolErrorBreakpoint(message.get());
|
|
|
|
}
|
|
|
|
|
2016-05-21 08:07:56 +00:00
|
|
|
void
|
|
|
|
UnionTypeReadError(const char* aUnionName)
|
|
|
|
{
|
|
|
|
nsPrintfCString message("error deserializing type of union %s", aUnionName);
|
|
|
|
NS_RUNTIMEABORT(message.get());
|
|
|
|
}
|
|
|
|
|
2017-03-09 21:37:55 +00:00
|
|
|
void
|
|
|
|
ArrayLengthReadError(const char* aElementName)
|
2016-05-21 08:07:56 +00:00
|
|
|
{
|
|
|
|
nsPrintfCString message("error deserializing length of %s[]", aElementName);
|
|
|
|
NS_RUNTIMEABORT(message.get());
|
|
|
|
}
|
|
|
|
|
2017-03-09 21:37:55 +00:00
|
|
|
void
|
|
|
|
SentinelReadError(const char* aClassName)
|
|
|
|
{
|
|
|
|
nsPrintfCString message("incorrect sentinel when reading %s", aClassName);
|
|
|
|
NS_RUNTIMEABORT(message.get());
|
|
|
|
}
|
|
|
|
|
2016-08-30 00:41:22 +00:00
|
|
|
void
|
|
|
|
TableToArray(const nsTHashtable<nsPtrHashKey<void>>& aTable,
|
|
|
|
nsTArray<void*>& aArray)
|
|
|
|
{
|
|
|
|
uint32_t i = 0;
|
|
|
|
void** elements = aArray.AppendElements(aTable.Count());
|
|
|
|
for (auto iter = aTable.ConstIter(); !iter.Done(); iter.Next()) {
|
|
|
|
elements[i] = iter.Get()->GetKey();
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-29 04:26:21 +00:00
|
|
|
Maybe<IProtocol*>
|
|
|
|
IProtocol::ReadActor(const IPC::Message* aMessage, PickleIterator* aIter, bool aNullable,
|
|
|
|
const char* aActorDescription, int32_t aProtocolTypeId)
|
|
|
|
{
|
|
|
|
int32_t id;
|
|
|
|
if (!IPC::ReadParam(aMessage, aIter, &id)) {
|
|
|
|
ActorIdReadError(aActorDescription);
|
|
|
|
return Nothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id == 1 || (id == 0 && !aNullable)) {
|
|
|
|
BadActorIdError(aActorDescription);
|
|
|
|
return Nothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id == 0) {
|
|
|
|
return Some(static_cast<IProtocol*>(nullptr));
|
|
|
|
}
|
|
|
|
|
|
|
|
IProtocol* listener = this->Lookup(id);
|
|
|
|
if (!listener) {
|
|
|
|
ActorLookupError(aActorDescription);
|
|
|
|
return Nothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (listener->GetProtocolTypeId() != aProtocolTypeId) {
|
|
|
|
MismatchedActorTypeError(aActorDescription);
|
|
|
|
return Nothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
return Some(listener);
|
|
|
|
}
|
|
|
|
|
2016-10-31 22:08:00 +00:00
|
|
|
int32_t
|
|
|
|
IProtocol::Register(IProtocol* aRouted)
|
|
|
|
{
|
|
|
|
return Manager()->Register(aRouted);
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t
|
|
|
|
IProtocol::RegisterID(IProtocol* aRouted, int32_t aId)
|
|
|
|
{
|
|
|
|
return Manager()->RegisterID(aRouted, aId);
|
|
|
|
}
|
|
|
|
|
|
|
|
IProtocol*
|
|
|
|
IProtocol::Lookup(int32_t aId)
|
|
|
|
{
|
|
|
|
return Manager()->Lookup(aId);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
IProtocol::Unregister(int32_t aId)
|
|
|
|
{
|
2016-10-29 03:46:59 +00:00
|
|
|
if (mId == aId) {
|
|
|
|
mId = kFreedActorId;
|
|
|
|
}
|
2016-10-31 22:08:00 +00:00
|
|
|
Manager()->Unregister(aId);
|
|
|
|
}
|
|
|
|
|
|
|
|
Shmem::SharedMemory*
|
|
|
|
IProtocol::CreateSharedMemory(size_t aSize,
|
|
|
|
SharedMemory::SharedMemoryType aType,
|
|
|
|
bool aUnsafe,
|
|
|
|
int32_t* aId)
|
|
|
|
{
|
|
|
|
return Manager()->CreateSharedMemory(aSize, aType, aUnsafe, aId);
|
|
|
|
}
|
|
|
|
|
|
|
|
Shmem::SharedMemory*
|
|
|
|
IProtocol::LookupSharedMemory(int32_t aId)
|
|
|
|
{
|
|
|
|
return Manager()->LookupSharedMemory(aId);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
IProtocol::IsTrackingSharedMemory(Shmem::SharedMemory* aSegment)
|
|
|
|
{
|
|
|
|
return Manager()->IsTrackingSharedMemory(aSegment);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
IProtocol::DestroySharedMemory(Shmem& aShmem)
|
|
|
|
{
|
|
|
|
return Manager()->DestroySharedMemory(aShmem);
|
|
|
|
}
|
|
|
|
|
|
|
|
ProcessId
|
|
|
|
IProtocol::OtherPid() const
|
|
|
|
{
|
|
|
|
return Manager()->OtherPid();
|
|
|
|
}
|
|
|
|
|
2016-11-01 16:10:42 +00:00
|
|
|
void
|
|
|
|
IProtocol::FatalError(const char* const aErrorMsg) const
|
|
|
|
{
|
|
|
|
HandleFatalError(ProtocolName(), aErrorMsg);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
IProtocol::HandleFatalError(const char* aProtocolName, const char* aErrorMsg) const
|
|
|
|
{
|
|
|
|
if (IProtocol* manager = Manager()) {
|
|
|
|
manager->HandleFatalError(aProtocolName, aErrorMsg);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mozilla::ipc::FatalError(aProtocolName, aErrorMsg, mSide == ParentSide);
|
|
|
|
}
|
|
|
|
|
2016-10-31 23:00:00 +00:00
|
|
|
bool
|
|
|
|
IProtocol::AllocShmem(size_t aSize,
|
|
|
|
Shmem::SharedMemory::SharedMemoryType aType,
|
|
|
|
Shmem* aOutMem)
|
|
|
|
{
|
|
|
|
Shmem::id_t id;
|
|
|
|
Shmem::SharedMemory* rawmem(CreateSharedMemory(aSize, aType, false, &id));
|
|
|
|
if (!rawmem) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aOutMem = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem, id);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
IProtocol::AllocUnsafeShmem(size_t aSize,
|
|
|
|
Shmem::SharedMemory::SharedMemoryType aType,
|
|
|
|
Shmem* aOutMem)
|
|
|
|
{
|
|
|
|
Shmem::id_t id;
|
|
|
|
Shmem::SharedMemory* rawmem(CreateSharedMemory(aSize, aType, true, &id));
|
|
|
|
if (!rawmem) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aOutMem = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem, id);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
IProtocol::DeallocShmem(Shmem& aMem)
|
|
|
|
{
|
|
|
|
bool ok = DestroySharedMemory(aMem);
|
|
|
|
#ifdef DEBUG
|
|
|
|
if (!ok) {
|
|
|
|
if (mSide == ChildSide) {
|
|
|
|
FatalError("bad Shmem");
|
|
|
|
} else {
|
|
|
|
NS_WARNING("bad Shmem");
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif // DEBUG
|
|
|
|
aMem.forget(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
void
|
|
|
|
IProtocol::SetManager(IProtocol* aManager)
|
|
|
|
{
|
|
|
|
MOZ_RELEASE_ASSERT(!mManager || mManager == aManager);
|
|
|
|
mManager = aManager;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
IProtocol::SetEventTargetForActor(IProtocol* aActor, nsIEventTarget* aEventTarget)
|
|
|
|
{
|
|
|
|
// Make sure we have a manager for the internal method to access.
|
|
|
|
aActor->SetManager(this);
|
|
|
|
SetEventTargetForActorInternal(aActor, aEventTarget);
|
|
|
|
}
|
|
|
|
|
2017-03-21 03:57:56 +00:00
|
|
|
void
|
|
|
|
IProtocol::ReplaceEventTargetForActor(IProtocol* aActor,
|
|
|
|
nsIEventTarget* aEventTarget)
|
|
|
|
{
|
|
|
|
// Ensure the actor has been registered.
|
|
|
|
MOZ_ASSERT(aActor->Manager());
|
|
|
|
ReplaceEventTargetForActorInternal(aActor, aEventTarget);
|
|
|
|
}
|
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
void
|
|
|
|
IProtocol::SetEventTargetForActorInternal(IProtocol* aActor,
|
|
|
|
nsIEventTarget* aEventTarget)
|
|
|
|
{
|
|
|
|
Manager()->SetEventTargetForActorInternal(aActor, aEventTarget);
|
|
|
|
}
|
|
|
|
|
2017-03-21 03:57:56 +00:00
|
|
|
void
|
|
|
|
IProtocol::ReplaceEventTargetForActorInternal(IProtocol* aActor,
|
|
|
|
nsIEventTarget* aEventTarget)
|
|
|
|
{
|
|
|
|
Manager()->ReplaceEventTargetForActorInternal(aActor, aEventTarget);
|
|
|
|
}
|
|
|
|
|
2017-02-13 06:04:58 +00:00
|
|
|
nsIEventTarget*
|
|
|
|
IProtocol::GetActorEventTarget()
|
|
|
|
{
|
|
|
|
// We should only call this function when this actor has been registered and
|
|
|
|
// is not unregistered yet.
|
|
|
|
MOZ_RELEASE_ASSERT(mId != kNullActorId && mId != kFreedActorId);
|
|
|
|
RefPtr<nsIEventTarget> target = Manager()->GetActorEventTargetInternal(this);
|
|
|
|
return target;
|
|
|
|
}
|
|
|
|
|
|
|
|
already_AddRefed<nsIEventTarget>
|
|
|
|
IProtocol::GetActorEventTargetInternal(IProtocol* aActor)
|
|
|
|
{
|
|
|
|
return Manager()->GetActorEventTargetInternal(aActor);
|
|
|
|
}
|
|
|
|
|
2016-11-02 00:02:48 +00:00
|
|
|
IToplevelProtocol::IToplevelProtocol(ProtocolId aProtoId, Side aSide)
|
|
|
|
: IProtocol(aSide),
|
|
|
|
mProtocolId(aProtoId),
|
2016-11-02 03:55:23 +00:00
|
|
|
mOtherPid(mozilla::ipc::kInvalidProcessId),
|
2016-10-29 03:46:59 +00:00
|
|
|
mLastRouteId(aSide == ParentSide ? kFreedActorId : kNullActorId),
|
|
|
|
mLastShmemId(aSide == ParentSide ? kFreedActorId : kNullActorId),
|
|
|
|
mEventTargetMutex("ProtocolEventTargetMutex")
|
2016-11-02 00:02:48 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
IToplevelProtocol::~IToplevelProtocol()
|
|
|
|
{
|
|
|
|
if (mTrans) {
|
|
|
|
RefPtr<DeleteTask<Transport>> task = new DeleteTask<Transport>(mTrans.release());
|
|
|
|
XRE_GetIOMessageLoop()->PostTask(task.forget());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
base::ProcessId
|
|
|
|
IToplevelProtocol::OtherPid() const
|
|
|
|
{
|
|
|
|
return mOtherPid;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
IToplevelProtocol::SetOtherProcessId(base::ProcessId aOtherPid)
|
|
|
|
{
|
|
|
|
mOtherPid = aOtherPid;
|
|
|
|
}
|
|
|
|
|
2016-11-02 03:44:27 +00:00
|
|
|
bool
|
|
|
|
IToplevelProtocol::TakeMinidump(nsIFile** aDump, uint32_t* aSequence)
|
|
|
|
{
|
|
|
|
MOZ_RELEASE_ASSERT(GetSide() == ParentSide);
|
|
|
|
#ifdef MOZ_CRASHREPORTER
|
|
|
|
return XRE_TakeMinidumpForChild(OtherPid(), aDump, aSequence);
|
|
|
|
#else
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-11-01 23:58:33 +00:00
|
|
|
bool
|
|
|
|
IToplevelProtocol::Open(mozilla::ipc::Transport* aTransport,
|
|
|
|
base::ProcessId aOtherPid,
|
|
|
|
MessageLoop* aThread,
|
|
|
|
mozilla::ipc::Side aSide)
|
|
|
|
{
|
|
|
|
SetOtherProcessId(aOtherPid);
|
|
|
|
return GetIPCChannel()->Open(aTransport, aThread, aSide);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
IToplevelProtocol::Open(MessageChannel* aChannel,
|
|
|
|
MessageLoop* aMessageLoop,
|
|
|
|
mozilla::ipc::Side aSide)
|
|
|
|
{
|
|
|
|
SetOtherProcessId(base::GetCurrentProcId());
|
2017-08-03 09:21:44 +00:00
|
|
|
return GetIPCChannel()->Open(aChannel, aMessageLoop->SerialEventTarget(), aSide);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
IToplevelProtocol::Open(MessageChannel* aChannel,
|
|
|
|
nsIEventTarget* aEventTarget,
|
|
|
|
mozilla::ipc::Side aSide)
|
|
|
|
{
|
|
|
|
SetOtherProcessId(base::GetCurrentProcId());
|
|
|
|
return GetIPCChannel()->Open(aChannel, aEventTarget, aSide);
|
2016-11-01 23:58:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
IToplevelProtocol::Close()
|
|
|
|
{
|
|
|
|
GetIPCChannel()->Close();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
IToplevelProtocol::SetReplyTimeoutMs(int32_t aTimeoutMs)
|
|
|
|
{
|
|
|
|
GetIPCChannel()->SetReplyTimeoutMs(aTimeoutMs);
|
|
|
|
}
|
|
|
|
|
2016-11-01 23:50:07 +00:00
|
|
|
bool
|
|
|
|
IToplevelProtocol::IsOnCxxStack() const
|
|
|
|
{
|
|
|
|
return GetIPCChannel()->IsOnCxxStack();
|
|
|
|
}
|
|
|
|
|
2016-11-02 03:55:23 +00:00
|
|
|
int32_t
|
|
|
|
IToplevelProtocol::Register(IProtocol* aRouted)
|
|
|
|
{
|
2016-10-29 03:46:59 +00:00
|
|
|
if (aRouted->Id() != kNullActorId && aRouted->Id() != kFreedActorId) {
|
|
|
|
// If there's already an ID, just return that.
|
|
|
|
return aRouted->Id();
|
|
|
|
}
|
2016-11-02 04:05:38 +00:00
|
|
|
int32_t id = GetSide() == ParentSide ? ++mLastRouteId : --mLastRouteId;
|
2016-11-02 03:55:23 +00:00
|
|
|
mActorMap.AddWithID(aRouted, id);
|
2016-10-29 03:46:59 +00:00
|
|
|
aRouted->SetId(id);
|
|
|
|
|
|
|
|
// Inherit our event target from our manager.
|
|
|
|
if (IProtocol* manager = aRouted->Manager()) {
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
|
|
|
if (nsCOMPtr<nsIEventTarget> target = mEventTargetMap.Lookup(manager->Id())) {
|
|
|
|
mEventTargetMap.AddWithID(target, id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-02 03:55:23 +00:00
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t
|
|
|
|
IToplevelProtocol::RegisterID(IProtocol* aRouted,
|
|
|
|
int32_t aId)
|
|
|
|
{
|
|
|
|
mActorMap.AddWithID(aRouted, aId);
|
2016-10-29 03:46:59 +00:00
|
|
|
aRouted->SetId(aId);
|
2016-11-02 03:55:23 +00:00
|
|
|
return aId;
|
|
|
|
}
|
|
|
|
|
|
|
|
IProtocol*
|
|
|
|
IToplevelProtocol::Lookup(int32_t aId)
|
|
|
|
{
|
|
|
|
return mActorMap.Lookup(aId);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
IToplevelProtocol::Unregister(int32_t aId)
|
|
|
|
{
|
2016-10-29 03:46:59 +00:00
|
|
|
mActorMap.Remove(aId);
|
|
|
|
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
|
|
|
mEventTargetMap.RemoveIfPresent(aId);
|
2016-11-02 03:55:23 +00:00
|
|
|
}
|
|
|
|
|
2016-11-02 04:05:38 +00:00
|
|
|
Shmem::SharedMemory*
|
|
|
|
IToplevelProtocol::CreateSharedMemory(size_t aSize,
|
|
|
|
Shmem::SharedMemory::SharedMemoryType aType,
|
|
|
|
bool aUnsafe,
|
|
|
|
Shmem::id_t* aId)
|
|
|
|
{
|
|
|
|
RefPtr<Shmem::SharedMemory> segment(
|
|
|
|
Shmem::Alloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), aSize, aType, aUnsafe));
|
|
|
|
if (!segment) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
int32_t id = GetSide() == ParentSide ? ++mLastShmemId : --mLastShmemId;
|
|
|
|
Shmem shmem(
|
|
|
|
Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(),
|
|
|
|
segment.get(),
|
|
|
|
id);
|
|
|
|
Message* descriptor = shmem.ShareTo(
|
|
|
|
Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), OtherPid(), MSG_ROUTING_CONTROL);
|
|
|
|
if (!descriptor) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
Unused << GetIPCChannel()->Send(descriptor);
|
|
|
|
|
|
|
|
*aId = shmem.Id(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
|
|
|
|
Shmem::SharedMemory* rawSegment = segment.get();
|
|
|
|
mShmemMap.AddWithID(segment.forget().take(), *aId);
|
|
|
|
return rawSegment;
|
|
|
|
}
|
|
|
|
|
|
|
|
Shmem::SharedMemory*
|
|
|
|
IToplevelProtocol::LookupSharedMemory(Shmem::id_t aId)
|
|
|
|
{
|
|
|
|
return mShmemMap.Lookup(aId);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
IToplevelProtocol::IsTrackingSharedMemory(Shmem::SharedMemory* segment)
|
|
|
|
{
|
|
|
|
return mShmemMap.HasData(segment);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
IToplevelProtocol::DestroySharedMemory(Shmem& shmem)
|
|
|
|
{
|
|
|
|
Shmem::id_t aId = shmem.Id(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
|
|
|
|
Shmem::SharedMemory* segment = LookupSharedMemory(aId);
|
|
|
|
if (!segment) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Message* descriptor = shmem.UnshareFrom(
|
|
|
|
Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), OtherPid(), MSG_ROUTING_CONTROL);
|
|
|
|
|
|
|
|
mShmemMap.Remove(aId);
|
|
|
|
Shmem::Dealloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), segment);
|
|
|
|
|
|
|
|
if (!GetIPCChannel()->CanSend()) {
|
|
|
|
delete descriptor;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return descriptor && GetIPCChannel()->Send(descriptor);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
IToplevelProtocol::DeallocShmems()
|
|
|
|
{
|
2016-11-03 23:25:48 +00:00
|
|
|
for (IDMap<SharedMemory*>::const_iterator cit = mShmemMap.begin(); cit != mShmemMap.end(); ++cit) {
|
2016-11-02 04:05:38 +00:00
|
|
|
Shmem::Dealloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), cit->second);
|
|
|
|
}
|
|
|
|
mShmemMap.Clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
IToplevelProtocol::ShmemCreated(const Message& aMsg)
|
|
|
|
{
|
|
|
|
Shmem::id_t id;
|
|
|
|
RefPtr<Shmem::SharedMemory> rawmem(Shmem::OpenExisting(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), aMsg, &id, true));
|
|
|
|
if (!rawmem) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
mShmemMap.AddWithID(rawmem.forget().take(), id);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
IToplevelProtocol::ShmemDestroyed(const Message& aMsg)
|
|
|
|
{
|
|
|
|
Shmem::id_t id;
|
|
|
|
PickleIterator iter = PickleIterator(aMsg);
|
|
|
|
if (!IPC::ReadParam(&aMsg, &iter, &id)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
aMsg.EndRead(iter);
|
|
|
|
|
|
|
|
Shmem::SharedMemory* rawmem = LookupSharedMemory(id);
|
|
|
|
if (rawmem) {
|
|
|
|
mShmemMap.Remove(id);
|
|
|
|
Shmem::Dealloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
already_AddRefed<nsIEventTarget>
|
|
|
|
IToplevelProtocol::GetMessageEventTarget(const Message& aMsg)
|
|
|
|
{
|
|
|
|
int32_t route = aMsg.routing_id();
|
|
|
|
|
2017-04-05 03:21:16 +00:00
|
|
|
Maybe<MutexAutoLock> lock;
|
|
|
|
lock.emplace(mEventTargetMutex);
|
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
nsCOMPtr<nsIEventTarget> target = mEventTargetMap.Lookup(route);
|
|
|
|
|
|
|
|
if (aMsg.is_constructor()) {
|
|
|
|
ActorHandle handle;
|
|
|
|
PickleIterator iter = PickleIterator(aMsg);
|
|
|
|
if (!IPC::ReadParam(&aMsg, &iter, &handle)) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Normally a new actor inherits its event target from its manager. If the
|
|
|
|
// manager has no event target, we give the subclass a chance to make a new
|
|
|
|
// one.
|
|
|
|
if (!target) {
|
|
|
|
MutexAutoUnlock unlock(mEventTargetMutex);
|
|
|
|
target = GetConstructedEventTarget(aMsg);
|
|
|
|
}
|
|
|
|
|
|
|
|
mEventTargetMap.AddWithID(target, handle.mId);
|
2017-04-05 03:21:16 +00:00
|
|
|
} else if (!target) {
|
|
|
|
// We don't need the lock after this point.
|
|
|
|
lock.reset();
|
|
|
|
|
|
|
|
target = GetSpecificMessageEventTarget(aMsg);
|
2016-10-29 03:46:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return target.forget();
|
|
|
|
}
|
|
|
|
|
2016-11-04 18:13:52 +00:00
|
|
|
already_AddRefed<nsIEventTarget>
|
2017-02-13 06:04:58 +00:00
|
|
|
IToplevelProtocol::GetActorEventTargetInternal(IProtocol* aActor)
|
2016-11-04 18:13:52 +00:00
|
|
|
{
|
|
|
|
MOZ_RELEASE_ASSERT(aActor->Id() != kNullActorId && aActor->Id() != kFreedActorId);
|
|
|
|
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
|
|
|
nsCOMPtr<nsIEventTarget> target = mEventTargetMap.Lookup(aActor->Id());
|
|
|
|
return target.forget();
|
|
|
|
}
|
|
|
|
|
2017-02-13 06:04:58 +00:00
|
|
|
already_AddRefed<nsIEventTarget>
|
|
|
|
IToplevelProtocol::GetActorEventTarget(IProtocol* aActor)
|
|
|
|
{
|
|
|
|
return GetActorEventTargetInternal(aActor);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIEventTarget*
|
|
|
|
IToplevelProtocol::GetActorEventTarget()
|
|
|
|
{
|
|
|
|
// The EventTarget of a ToplevelProtocol shall never be set.
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
void
|
|
|
|
IToplevelProtocol::SetEventTargetForActorInternal(IProtocol* aActor,
|
|
|
|
nsIEventTarget* aEventTarget)
|
|
|
|
{
|
2017-02-13 06:04:58 +00:00
|
|
|
// The EventTarget of a ToplevelProtocol shall never be set.
|
|
|
|
MOZ_RELEASE_ASSERT(aActor != this);
|
|
|
|
|
2016-10-29 03:46:59 +00:00
|
|
|
// We should only call this function on actors that haven't been used for IPC
|
|
|
|
// code yet. Otherwise we'll be posting stuff to the wrong event target before
|
|
|
|
// we're called.
|
|
|
|
MOZ_RELEASE_ASSERT(aActor->Id() == kNullActorId || aActor->Id() == kFreedActorId);
|
|
|
|
|
|
|
|
// Register the actor early. When it's registered again, it will keep the same
|
|
|
|
// ID.
|
|
|
|
int32_t id = Register(aActor);
|
|
|
|
aActor->SetId(id);
|
|
|
|
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
|
|
|
mEventTargetMap.AddWithID(aEventTarget, id);
|
|
|
|
}
|
|
|
|
|
2017-03-21 03:57:56 +00:00
|
|
|
void
|
|
|
|
IToplevelProtocol::ReplaceEventTargetForActorInternal(
|
|
|
|
IProtocol* aActor,
|
|
|
|
nsIEventTarget* aEventTarget)
|
|
|
|
{
|
|
|
|
// The EventTarget of a ToplevelProtocol shall never be set.
|
|
|
|
MOZ_RELEASE_ASSERT(aActor != this);
|
|
|
|
|
|
|
|
int32_t id = aActor->Id();
|
|
|
|
// The ID of the actor should have existed.
|
|
|
|
MOZ_RELEASE_ASSERT(id!= kNullActorId && id!= kFreedActorId);
|
|
|
|
|
|
|
|
MutexAutoLock lock(mEventTargetMutex);
|
|
|
|
mEventTargetMap.ReplaceWithID(aEventTarget, id);
|
|
|
|
}
|
|
|
|
|
2011-06-03 18:33:56 +00:00
|
|
|
} // namespace ipc
|
|
|
|
} // namespace mozilla
|