commit ca58979a61e9583561c76dcc3119545079c944b5
parent 68043b8ca6bd75017a25ca6ad1326455447b8196
Author: Nika Layzell <nika@thelayzells.com>
Date: Wed, 29 Oct 2025 18:53:40 +0000
Bug 1754009 - Remove IPDLParamTraits, r=ipc-reviewers,necko-reviewers,media-playback-reviewers,profiler-reviewers,core-sessionstore-reviewers,ahale,mccr8,valentin,canaltinova,farre,karlt
4 years ago, we removed the need to have the separate IPDLParamTraits
type, but we never got around to fully removing it. This patch rips out
the remains of IPDLParamTraits.
Differential Revision: https://phabricator.services.mozilla.com/D266719
Diffstat:
64 files changed, 1050 insertions(+), 1463 deletions(-)
diff --git a/chrome/RegistryMessageUtils.h b/chrome/RegistryMessageUtils.h
@@ -6,7 +6,7 @@
#ifndef mozilla_RegistryMessageUtils_h
#define mozilla_RegistryMessageUtils_h
-#include "mozilla/ipc/IPDLParamTraits.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsString.h"
struct SerializedURI {
diff --git a/docshell/base/BrowsingContext.cpp b/docshell/base/BrowsingContext.cpp
@@ -4535,29 +4535,32 @@ void BrowsingContext::SynchronizeNavigationAPIState(
}
} // namespace dom
+} // namespace mozilla
+
+namespace IPC {
-namespace ipc {
+using mozilla::dom::BrowsingContext;
+using mozilla::dom::MaybeDiscarded;
-void IPDLParamTraits<dom::MaybeDiscarded<dom::BrowsingContext>>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::MaybeDiscarded<dom::BrowsingContext>& aParam) {
+void ParamTraits<MaybeDiscarded<BrowsingContext>>::Write(
+ IPC::MessageWriter* aWriter,
+ const MaybeDiscarded<BrowsingContext>& aParam) {
MOZ_DIAGNOSTIC_ASSERT(!aParam.GetMaybeDiscarded() ||
aParam.GetMaybeDiscarded()->EverAttached());
uint64_t id = aParam.ContextId();
- WriteIPDLParam(aWriter, aActor, id);
+ WriteParam(aWriter, id);
}
-bool IPDLParamTraits<dom::MaybeDiscarded<dom::BrowsingContext>>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor,
- dom::MaybeDiscarded<dom::BrowsingContext>* aResult) {
+bool ParamTraits<MaybeDiscarded<BrowsingContext>>::Read(
+ IPC::MessageReader* aReader, MaybeDiscarded<BrowsingContext>* aResult) {
uint64_t id = 0;
- if (!ReadIPDLParam(aReader, aActor, &id)) {
+ if (!ReadParam(aReader, &id)) {
return false;
}
if (id == 0) {
*aResult = nullptr;
- } else if (RefPtr<dom::BrowsingContext> bc = dom::BrowsingContext::Get(id)) {
+ } else if (RefPtr<BrowsingContext> bc = BrowsingContext::Get(id)) {
*aResult = std::move(bc);
} else {
aResult->SetDiscarded(id);
@@ -4565,46 +4568,40 @@ bool IPDLParamTraits<dom::MaybeDiscarded<dom::BrowsingContext>>::Read(
return true;
}
-void IPDLParamTraits<dom::BrowsingContext::IPCInitializer>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::BrowsingContext::IPCInitializer& aInit) {
+void ParamTraits<BrowsingContext::IPCInitializer>::Write(
+ IPC::MessageWriter* aWriter, const paramType& aInit) {
// Write actor ID parameters.
- WriteIPDLParam(aWriter, aActor, aInit.mId);
- WriteIPDLParam(aWriter, aActor, aInit.mParentId);
- WriteIPDLParam(aWriter, aActor, aInit.mWindowless);
- WriteIPDLParam(aWriter, aActor, aInit.mUseRemoteTabs);
- WriteIPDLParam(aWriter, aActor, aInit.mUseRemoteSubframes);
- WriteIPDLParam(aWriter, aActor, aInit.mCreatedDynamically);
- WriteIPDLParam(aWriter, aActor, aInit.mChildOffset);
- WriteIPDLParam(aWriter, aActor, aInit.mOriginAttributes);
- WriteIPDLParam(aWriter, aActor, aInit.mRequestContextId);
- WriteIPDLParam(aWriter, aActor, aInit.mSessionHistoryIndex);
- WriteIPDLParam(aWriter, aActor, aInit.mSessionHistoryCount);
- WriteIPDLParam(aWriter, aActor, aInit.mFields);
-}
-
-bool IPDLParamTraits<dom::BrowsingContext::IPCInitializer>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor,
- dom::BrowsingContext::IPCInitializer* aInit) {
+ WriteParam(aWriter, aInit.mId);
+ WriteParam(aWriter, aInit.mParentId);
+ WriteParam(aWriter, aInit.mWindowless);
+ WriteParam(aWriter, aInit.mUseRemoteTabs);
+ WriteParam(aWriter, aInit.mUseRemoteSubframes);
+ WriteParam(aWriter, aInit.mCreatedDynamically);
+ WriteParam(aWriter, aInit.mChildOffset);
+ WriteParam(aWriter, aInit.mOriginAttributes);
+ WriteParam(aWriter, aInit.mRequestContextId);
+ WriteParam(aWriter, aInit.mSessionHistoryIndex);
+ WriteParam(aWriter, aInit.mSessionHistoryCount);
+ WriteParam(aWriter, aInit.mFields);
+}
+
+bool ParamTraits<BrowsingContext::IPCInitializer>::Read(
+ IPC::MessageReader* aReader, paramType* aInit) {
// Read actor ID parameters.
- if (!ReadIPDLParam(aReader, aActor, &aInit->mId) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mParentId) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mWindowless) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mUseRemoteTabs) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mUseRemoteSubframes) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mCreatedDynamically) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mChildOffset) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mOriginAttributes) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mRequestContextId) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mSessionHistoryIndex) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mSessionHistoryCount) ||
- !ReadIPDLParam(aReader, aActor, &aInit->mFields)) {
- return false;
- }
- return true;
-}
-
-template struct IPDLParamTraits<dom::BrowsingContext::BaseTransaction>;
+ return ReadParam(aReader, &aInit->mId) &&
+ ReadParam(aReader, &aInit->mParentId) &&
+ ReadParam(aReader, &aInit->mWindowless) &&
+ ReadParam(aReader, &aInit->mUseRemoteTabs) &&
+ ReadParam(aReader, &aInit->mUseRemoteSubframes) &&
+ ReadParam(aReader, &aInit->mCreatedDynamically) &&
+ ReadParam(aReader, &aInit->mChildOffset) &&
+ ReadParam(aReader, &aInit->mOriginAttributes) &&
+ ReadParam(aReader, &aInit->mRequestContextId) &&
+ ReadParam(aReader, &aInit->mSessionHistoryIndex) &&
+ ReadParam(aReader, &aInit->mSessionHistoryCount) &&
+ ReadParam(aReader, &aInit->mFields);
+}
+
+template struct ParamTraits<BrowsingContext::BaseTransaction>;
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
diff --git a/docshell/base/BrowsingContext.h b/docshell/base/BrowsingContext.h
@@ -48,6 +48,8 @@ namespace IPC {
class Message;
class MessageReader;
class MessageWriter;
+template <typename T>
+struct ParamTraits;
} // namespace IPC
namespace mozilla {
@@ -58,9 +60,6 @@ class LogModule;
namespace ipc {
class IProtocol;
class IPCResult;
-
-template <typename T>
-struct IPDLParamTraits;
} // namespace ipc
namespace dom {
@@ -1639,26 +1638,24 @@ using MaybeDiscardedBrowsingContext = MaybeDiscarded<BrowsingContext>;
extern template class syncedcontext::Transaction<BrowsingContext>;
} // namespace dom
+} // namespace mozilla
// Allow sending BrowsingContext objects over IPC.
-namespace ipc {
+namespace IPC {
template <>
-struct IPDLParamTraits<dom::MaybeDiscarded<dom::BrowsingContext>> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::MaybeDiscarded<dom::BrowsingContext>& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- dom::MaybeDiscarded<dom::BrowsingContext>* aResult);
+struct ParamTraits<
+ mozilla::dom::MaybeDiscarded<mozilla::dom::BrowsingContext>> {
+ using paramType = mozilla::dom::MaybeDiscarded<mozilla::dom::BrowsingContext>;
+ static void Write(IPC::MessageWriter* aWriter, const paramType& aParam);
+ static bool Read(IPC::MessageReader* aReader, paramType* aResult);
};
template <>
-struct IPDLParamTraits<dom::BrowsingContext::IPCInitializer> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::BrowsingContext::IPCInitializer& aInitializer);
-
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- dom::BrowsingContext::IPCInitializer* aInitializer);
+struct ParamTraits<mozilla::dom::BrowsingContext::IPCInitializer> {
+ using paramType = mozilla::dom::BrowsingContext::IPCInitializer;
+ static void Write(IPC::MessageWriter* aWriter, const paramType& aInitializer);
+ static bool Read(IPC::MessageReader* aReader, paramType* aInitializer);
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif // !defined(mozilla_dom_BrowsingContext_h)
diff --git a/docshell/base/SyncedContext.h b/docshell/base/SyncedContext.h
@@ -24,14 +24,14 @@ namespace IPC {
class Message;
class MessageReader;
class MessageWriter;
+template <typename T>
+struct ParamTraits;
} // namespace IPC
namespace mozilla {
namespace ipc {
class IProtocol;
class IPCResult;
-template <typename T>
-struct IPDLParamTraits;
} // namespace ipc
namespace dom {
@@ -104,11 +104,10 @@ class Transaction {
void CommitWithoutSyncing(Context* aOwner);
private:
- friend struct mozilla::ipc::IPDLParamTraits<Transaction<Context>>;
+ friend struct IPC::ParamTraits<Transaction<Context>>;
- void Write(IPC::MessageWriter* aWriter,
- mozilla::ipc::IProtocol* aActor) const;
- bool Read(IPC::MessageReader* aReader, mozilla::ipc::IProtocol* aActor);
+ void Write(IPC::MessageWriter* aWriter) const;
+ bool Read(IPC::MessageReader* aReader);
// You probably don't want to directly call this method - instead call
// `Commit`, which will perform the necessary synchronization.
@@ -155,11 +154,10 @@ class FieldValues : public Base {
}
private:
- friend struct mozilla::ipc::IPDLParamTraits<FieldValues<Base, Count>>;
+ friend struct IPC::ParamTraits<FieldValues<Base, Count>>;
- void Write(IPC::MessageWriter* aWriter,
- mozilla::ipc::IProtocol* aActor) const;
- bool Read(IPC::MessageReader* aReader, mozilla::ipc::IProtocol* aActor);
+ void Write(IPC::MessageWriter* aWriter) const;
+ bool Read(IPC::MessageReader* aReader);
template <typename F, size_t... Indexes>
static void EachIndexInner(std::index_sequence<Indexes...> aIndexes,
@@ -362,40 +360,36 @@ using FieldSetterType = typename GetFieldSetterType<T>::SetterArg;
} // namespace syncedcontext
} // namespace dom
+} // namespace mozilla
-namespace ipc {
+namespace IPC {
template <typename Context>
-struct IPDLParamTraits<dom::syncedcontext::Transaction<Context>> {
- typedef dom::syncedcontext::Transaction<Context> paramType;
+struct ParamTraits<mozilla::dom::syncedcontext::Transaction<Context>> {
+ using paramType = mozilla::dom::syncedcontext::Transaction<Context>;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- aParam.Write(aWriter, aActor);
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ aParam.Write(aWriter);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- return aResult->Read(aReader, aActor);
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return aResult->Read(aReader);
}
};
template <typename Base, size_t Count>
-struct IPDLParamTraits<dom::syncedcontext::FieldValues<Base, Count>> {
- typedef dom::syncedcontext::FieldValues<Base, Count> paramType;
+struct ParamTraits<mozilla::dom::syncedcontext::FieldValues<Base, Count>> {
+ using paramType = mozilla::dom::syncedcontext::FieldValues<Base, Count>;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- aParam.Write(aWriter, aActor);
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ aParam.Write(aWriter);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- return aResult->Read(aReader, aActor);
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return aResult->Read(aReader);
}
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif // !defined(mozilla_dom_SyncedContext_h)
diff --git a/docshell/base/SyncedContextInlines.h b/docshell/base/SyncedContextInlines.h
@@ -297,27 +297,25 @@ typename Transaction<Context>::IndexSet Transaction<Context>::Validate(
}
template <typename Context>
-void Transaction<Context>::Write(IPC::MessageWriter* aWriter,
- mozilla::ipc::IProtocol* aActor) const {
+void Transaction<Context>::Write(IPC::MessageWriter* aWriter) const {
// Record which field indices will be included, and then write those fields
// out.
typename IndexSet::serializedType modified = mModified.serialize();
- WriteIPDLParam(aWriter, aActor, modified);
+ IPC::WriteParam(aWriter, modified);
EachIndex([&](auto idx) {
if (mModified.contains(idx)) {
- WriteIPDLParam(aWriter, aActor, mValues.Get(idx));
+ IPC::WriteParam(aWriter, mValues.Get(idx));
}
});
}
template <typename Context>
-bool Transaction<Context>::Read(IPC::MessageReader* aReader,
- mozilla::ipc::IProtocol* aActor) {
+bool Transaction<Context>::Read(IPC::MessageReader* aReader) {
// Read in which field indices were sent by the remote, followed by the fields
// identified by those indices.
typename IndexSet::serializedType modified =
typename IndexSet::serializedType{};
- if (!ReadIPDLParam(aReader, aActor, &modified)) {
+ if (!IPC::ReadParam(aReader, &modified)) {
return false;
}
mModified.deserialize(modified);
@@ -325,29 +323,27 @@ bool Transaction<Context>::Read(IPC::MessageReader* aReader,
bool ok = true;
EachIndex([&](auto idx) {
if (ok && mModified.contains(idx)) {
- ok = ReadIPDLParam(aReader, aActor, &mValues.Get(idx));
+ ok = IPC::ReadParam(aReader, &mValues.Get(idx));
}
});
return ok;
}
template <typename Base, size_t Count>
-void FieldValues<Base, Count>::Write(IPC::MessageWriter* aWriter,
- mozilla::ipc::IProtocol* aActor) const {
+void FieldValues<Base, Count>::Write(IPC::MessageWriter* aWriter) const {
// XXX The this-> qualification is necessary to work around a bug in older gcc
// versions causing an ICE.
- EachIndex([&](auto idx) { WriteIPDLParam(aWriter, aActor, this->Get(idx)); });
+ EachIndex([&](auto idx) { IPC::WriteParam(aWriter, this->Get(idx)); });
}
template <typename Base, size_t Count>
-bool FieldValues<Base, Count>::Read(IPC::MessageReader* aReader,
- mozilla::ipc::IProtocol* aActor) {
+bool FieldValues<Base, Count>::Read(IPC::MessageReader* aReader) {
bool ok = true;
EachIndex([&](auto idx) {
if (ok) {
// XXX The this-> qualification is necessary to work around a bug in older
// gcc versions causing an ICE.
- ok = ReadIPDLParam(aReader, aActor, &this->Get(idx));
+ ok = IPC::ReadParam(aReader, &this->Get(idx));
}
});
return ok;
diff --git a/docshell/base/WindowContext.cpp b/docshell/base/WindowContext.cpp
@@ -781,27 +781,29 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(WindowContext)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
} // namespace dom
+} // namespace mozilla
+
+namespace IPC {
-namespace ipc {
+using mozilla::dom::MaybeDiscarded;
+using mozilla::dom::WindowContext;
-void IPDLParamTraits<dom::MaybeDiscarded<dom::WindowContext>>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::MaybeDiscarded<dom::WindowContext>& aParam) {
+void ParamTraits<MaybeDiscarded<WindowContext>>::Write(
+ MessageWriter* aWriter, const MaybeDiscarded<WindowContext>& aParam) {
uint64_t id = aParam.ContextId();
- WriteIPDLParam(aWriter, aActor, id);
+ WriteParam(aWriter, id);
}
-bool IPDLParamTraits<dom::MaybeDiscarded<dom::WindowContext>>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor,
- dom::MaybeDiscarded<dom::WindowContext>* aResult) {
+bool ParamTraits<MaybeDiscarded<WindowContext>>::Read(
+ MessageReader* aReader, MaybeDiscarded<WindowContext>* aResult) {
uint64_t id = 0;
- if (!ReadIPDLParam(aReader, aActor, &id)) {
+ if (!ReadParam(aReader, &id)) {
return false;
}
if (id == 0) {
*aResult = nullptr;
- } else if (RefPtr<dom::WindowContext> wc = dom::WindowContext::GetById(id)) {
+ } else if (RefPtr<WindowContext> wc = WindowContext::GetById(id)) {
*aResult = std::move(wc);
} else {
aResult->SetDiscarded(id);
@@ -809,27 +811,24 @@ bool IPDLParamTraits<dom::MaybeDiscarded<dom::WindowContext>>::Read(
return true;
}
-void IPDLParamTraits<dom::WindowContext::IPCInitializer>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::WindowContext::IPCInitializer& aInit) {
+void ParamTraits<WindowContext::IPCInitializer>::Write(
+ MessageWriter* aWriter, const WindowContext::IPCInitializer& aInit) {
// Write actor ID parameters.
- WriteIPDLParam(aWriter, aActor, aInit.mInnerWindowId);
- WriteIPDLParam(aWriter, aActor, aInit.mOuterWindowId);
- WriteIPDLParam(aWriter, aActor, aInit.mBrowsingContextId);
- WriteIPDLParam(aWriter, aActor, aInit.mFields);
+ WriteParam(aWriter, aInit.mInnerWindowId);
+ WriteParam(aWriter, aInit.mOuterWindowId);
+ WriteParam(aWriter, aInit.mBrowsingContextId);
+ WriteParam(aWriter, aInit.mFields);
}
-bool IPDLParamTraits<dom::WindowContext::IPCInitializer>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor,
- dom::WindowContext::IPCInitializer* aInit) {
+bool ParamTraits<WindowContext::IPCInitializer>::Read(
+ MessageReader* aReader, WindowContext::IPCInitializer* aInit) {
// Read actor ID parameters.
- return ReadIPDLParam(aReader, aActor, &aInit->mInnerWindowId) &&
- ReadIPDLParam(aReader, aActor, &aInit->mOuterWindowId) &&
- ReadIPDLParam(aReader, aActor, &aInit->mBrowsingContextId) &&
- ReadIPDLParam(aReader, aActor, &aInit->mFields);
+ return ReadParam(aReader, &aInit->mInnerWindowId) &&
+ ReadParam(aReader, &aInit->mOuterWindowId) &&
+ ReadParam(aReader, &aInit->mBrowsingContextId) &&
+ ReadParam(aReader, &aInit->mFields);
}
-template struct IPDLParamTraits<dom::WindowContext::BaseTransaction>;
+template struct ParamTraits<WindowContext::BaseTransaction>;
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
diff --git a/docshell/base/WindowContext.h b/docshell/base/WindowContext.h
@@ -447,25 +447,22 @@ using MaybeDiscardedWindowContext = MaybeDiscarded<WindowContext>;
extern template class syncedcontext::Transaction<WindowContext>;
} // namespace dom
+} // namespace mozilla
-namespace ipc {
+namespace IPC {
template <>
-struct IPDLParamTraits<dom::MaybeDiscarded<dom::WindowContext>> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::MaybeDiscarded<dom::WindowContext>& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- dom::MaybeDiscarded<dom::WindowContext>* aResult);
+struct ParamTraits<mozilla::dom::MaybeDiscarded<mozilla::dom::WindowContext>> {
+ using paramType = mozilla::dom::MaybeDiscarded<mozilla::dom::WindowContext>;
+ static void Write(MessageWriter* aWriter, const paramType& aParam);
+ static bool Read(MessageReader* aReader, paramType* aResult);
};
template <>
-struct IPDLParamTraits<dom::WindowContext::IPCInitializer> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::WindowContext::IPCInitializer& aInitializer);
-
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- dom::WindowContext::IPCInitializer* aInitializer);
+struct ParamTraits<mozilla::dom::WindowContext::IPCInitializer> {
+ using paramType = mozilla::dom::WindowContext::IPCInitializer;
+ static void Write(MessageWriter* aWriter, const paramType& aInitializer);
+ static bool Read(MessageReader* aReader, paramType* aInitializer);
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif // !defined(mozilla_dom_WindowContext_h)
diff --git a/docshell/shistory/SessionHistoryEntry.cpp b/docshell/shistory/SessionHistoryEntry.cpp
@@ -35,7 +35,6 @@
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PolicyContainer.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/URIUtils.h"
@@ -1592,15 +1591,17 @@ already_AddRefed<nsIURI> SessionHistoryEntry::GetURIOrInheritedForAboutBlank()
}
} // namespace dom
+} // namespace mozilla
-namespace ipc {
+namespace IPC {
-void IPDLParamTraits<dom::SessionHistoryInfo>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::SessionHistoryInfo& aParam) {
+void ParamTraits<mozilla::dom::SessionHistoryInfo>::Write(
+ IPC::MessageWriter* aWriter,
+ const mozilla::dom::SessionHistoryInfo& aParam) {
nsCOMPtr<nsIInputStream> postData = aParam.GetPostData();
- Maybe<std::tuple<uint32_t, dom::ClonedMessageData>> stateData;
+ mozilla::Maybe<std::tuple<uint32_t, mozilla::dom::ClonedMessageData>>
+ stateData;
if (aParam.mStateData) {
stateData.emplace();
// FIXME: We should fail more aggressively if this fails, as currently we'll
@@ -1611,7 +1612,8 @@ void IPDLParamTraits<dom::SessionHistoryInfo>::Write(
aParam.mStateData->BuildClonedMessageData(std::get<1>(*stateData)));
}
- Maybe<std::tuple<uint32_t, dom::ClonedMessageData>> navigationState;
+ mozilla::Maybe<std::tuple<uint32_t, mozilla::dom::ClonedMessageData>>
+ navigationState;
if (aParam.mNavigationAPIState) {
navigationState.emplace();
NS_ENSURE_SUCCESS_VOID(aParam.mNavigationAPIState->GetFormatVersion(
@@ -1620,75 +1622,71 @@ void IPDLParamTraits<dom::SessionHistoryInfo>::Write(
std::get<1>(*navigationState)));
}
- WriteIPDLParam(aWriter, aActor, aParam.mURI);
- WriteIPDLParam(aWriter, aActor, aParam.mOriginalURI);
- WriteIPDLParam(aWriter, aActor, aParam.mResultPrincipalURI);
- WriteIPDLParam(aWriter, aActor, aParam.mUnstrippedURI);
- WriteIPDLParam(aWriter, aActor, aParam.mReferrerInfo);
- WriteIPDLParam(aWriter, aActor, aParam.mTitle);
- WriteIPDLParam(aWriter, aActor, aParam.mName);
- WriteIPDLParam(aWriter, aActor, postData);
- WriteIPDLParam(aWriter, aActor, aParam.mLoadType);
- WriteIPDLParam(aWriter, aActor, aParam.mScrollPositionX);
- WriteIPDLParam(aWriter, aActor, aParam.mScrollPositionY);
- WriteIPDLParam(aWriter, aActor, stateData);
- WriteIPDLParam(aWriter, aActor, aParam.mSrcdocData);
- WriteIPDLParam(aWriter, aActor, aParam.mBaseURI);
- WriteIPDLParam(aWriter, aActor, aParam.mNavigationKey);
- WriteIPDLParam(aWriter, aActor, aParam.mNavigationId);
- WriteIPDLParam(aWriter, aActor, aParam.mLoadReplace);
- WriteIPDLParam(aWriter, aActor, aParam.mURIWasModified);
- WriteIPDLParam(aWriter, aActor, aParam.mScrollRestorationIsManual);
- WriteIPDLParam(aWriter, aActor, aParam.mTransient);
- WriteIPDLParam(aWriter, aActor, aParam.mHasUserInteraction);
- WriteIPDLParam(aWriter, aActor, aParam.mHasUserActivation);
- WriteIPDLParam(aWriter, aActor, aParam.mSharedState.Get()->mId);
- WriteIPDLParam(aWriter, aActor,
- aParam.mSharedState.Get()->mTriggeringPrincipal);
- WriteIPDLParam(aWriter, aActor,
- aParam.mSharedState.Get()->mPrincipalToInherit);
- WriteIPDLParam(aWriter, aActor,
- aParam.mSharedState.Get()->mPartitionedPrincipalToInherit);
- WriteIPDLParam(aWriter, aActor, aParam.mSharedState.Get()->mPolicyContainer);
- WriteIPDLParam(aWriter, aActor, aParam.mSharedState.Get()->mContentType);
- WriteIPDLParam(aWriter, aActor,
- aParam.mSharedState.Get()->mLayoutHistoryState);
- WriteIPDLParam(aWriter, aActor, aParam.mSharedState.Get()->mCacheKey);
- WriteIPDLParam(aWriter, aActor,
- aParam.mSharedState.Get()->mIsFrameNavigation);
- WriteIPDLParam(aWriter, aActor, aParam.mSharedState.Get()->mSaveLayoutState);
- WriteIPDLParam(aWriter, aActor, navigationState);
-}
-
-bool IPDLParamTraits<dom::SessionHistoryInfo>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor,
- dom::SessionHistoryInfo* aResult) {
- Maybe<std::tuple<uint32_t, dom::ClonedMessageData>> stateData;
+ WriteParam(aWriter, aParam.mURI);
+ WriteParam(aWriter, aParam.mOriginalURI);
+ WriteParam(aWriter, aParam.mResultPrincipalURI);
+ WriteParam(aWriter, aParam.mUnstrippedURI);
+ WriteParam(aWriter, aParam.mReferrerInfo);
+ WriteParam(aWriter, aParam.mTitle);
+ WriteParam(aWriter, aParam.mName);
+ WriteParam(aWriter, postData);
+ WriteParam(aWriter, aParam.mLoadType);
+ WriteParam(aWriter, aParam.mScrollPositionX);
+ WriteParam(aWriter, aParam.mScrollPositionY);
+ WriteParam(aWriter, stateData);
+ WriteParam(aWriter, aParam.mSrcdocData);
+ WriteParam(aWriter, aParam.mBaseURI);
+ WriteParam(aWriter, aParam.mNavigationKey);
+ WriteParam(aWriter, aParam.mNavigationId);
+ WriteParam(aWriter, aParam.mLoadReplace);
+ WriteParam(aWriter, aParam.mURIWasModified);
+ WriteParam(aWriter, aParam.mScrollRestorationIsManual);
+ WriteParam(aWriter, aParam.mTransient);
+ WriteParam(aWriter, aParam.mHasUserInteraction);
+ WriteParam(aWriter, aParam.mHasUserActivation);
+ WriteParam(aWriter, aParam.mSharedState.Get()->mId);
+ WriteParam(aWriter, aParam.mSharedState.Get()->mTriggeringPrincipal);
+ WriteParam(aWriter, aParam.mSharedState.Get()->mPrincipalToInherit);
+ WriteParam(aWriter,
+ aParam.mSharedState.Get()->mPartitionedPrincipalToInherit);
+ WriteParam(aWriter, aParam.mSharedState.Get()->mPolicyContainer);
+ WriteParam(aWriter, aParam.mSharedState.Get()->mContentType);
+ WriteParam(aWriter, aParam.mSharedState.Get()->mLayoutHistoryState);
+ WriteParam(aWriter, aParam.mSharedState.Get()->mCacheKey);
+ WriteParam(aWriter, aParam.mSharedState.Get()->mIsFrameNavigation);
+ WriteParam(aWriter, aParam.mSharedState.Get()->mSaveLayoutState);
+ WriteParam(aWriter, navigationState);
+}
+
+bool ParamTraits<mozilla::dom::SessionHistoryInfo>::Read(
+ IPC::MessageReader* aReader, mozilla::dom::SessionHistoryInfo* aResult) {
+ mozilla::Maybe<std::tuple<uint32_t, mozilla::dom::ClonedMessageData>>
+ stateData;
uint64_t sharedId;
- if (!ReadIPDLParam(aReader, aActor, &aResult->mURI) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mOriginalURI) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mResultPrincipalURI) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mUnstrippedURI) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mReferrerInfo) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mTitle) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mName) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mPostData) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mLoadType) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mScrollPositionX) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mScrollPositionY) ||
- !ReadIPDLParam(aReader, aActor, &stateData) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mSrcdocData) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mBaseURI) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mNavigationKey) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mNavigationId) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mLoadReplace) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mURIWasModified) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mScrollRestorationIsManual) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mTransient) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mHasUserInteraction) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mHasUserActivation) ||
- !ReadIPDLParam(aReader, aActor, &sharedId)) {
- aActor->FatalError("Error reading fields for SessionHistoryInfo");
+ if (!ReadParam(aReader, &aResult->mURI) ||
+ !ReadParam(aReader, &aResult->mOriginalURI) ||
+ !ReadParam(aReader, &aResult->mResultPrincipalURI) ||
+ !ReadParam(aReader, &aResult->mUnstrippedURI) ||
+ !ReadParam(aReader, &aResult->mReferrerInfo) ||
+ !ReadParam(aReader, &aResult->mTitle) ||
+ !ReadParam(aReader, &aResult->mName) ||
+ !ReadParam(aReader, &aResult->mPostData) ||
+ !ReadParam(aReader, &aResult->mLoadType) ||
+ !ReadParam(aReader, &aResult->mScrollPositionX) ||
+ !ReadParam(aReader, &aResult->mScrollPositionY) ||
+ !ReadParam(aReader, &stateData) ||
+ !ReadParam(aReader, &aResult->mSrcdocData) ||
+ !ReadParam(aReader, &aResult->mBaseURI) ||
+ !ReadParam(aReader, &aResult->mNavigationKey) ||
+ !ReadParam(aReader, &aResult->mNavigationId) ||
+ !ReadParam(aReader, &aResult->mLoadReplace) ||
+ !ReadParam(aReader, &aResult->mURIWasModified) ||
+ !ReadParam(aReader, &aResult->mScrollRestorationIsManual) ||
+ !ReadParam(aReader, &aResult->mTransient) ||
+ !ReadParam(aReader, &aResult->mHasUserInteraction) ||
+ !ReadParam(aReader, &aResult->mHasUserActivation) ||
+ !ReadParam(aReader, &sharedId)) {
+ aReader->FatalError("Error reading fields for SessionHistoryInfo");
return false;
}
@@ -1697,12 +1695,12 @@ bool IPDLParamTraits<dom::SessionHistoryInfo>::Read(
nsCOMPtr<nsIPrincipal> partitionedPrincipalToInherit;
nsCOMPtr<nsIPolicyContainer> policyContainer;
nsCString contentType;
- if (!ReadIPDLParam(aReader, aActor, &triggeringPrincipal) ||
- !ReadIPDLParam(aReader, aActor, &principalToInherit) ||
- !ReadIPDLParam(aReader, aActor, &partitionedPrincipalToInherit) ||
- !ReadIPDLParam(aReader, aActor, &policyContainer) ||
- !ReadIPDLParam(aReader, aActor, &contentType)) {
- aActor->FatalError("Error reading fields for SessionHistoryInfo");
+ if (!ReadParam(aReader, &triggeringPrincipal) ||
+ !ReadParam(aReader, &principalToInherit) ||
+ !ReadParam(aReader, &partitionedPrincipalToInherit) ||
+ !ReadParam(aReader, &policyContainer) ||
+ !ReadParam(aReader, &contentType)) {
+ aReader->FatalError("Error reading fields for SessionHistoryInfo");
return false;
}
@@ -1712,14 +1710,14 @@ bool IPDLParamTraits<dom::SessionHistoryInfo>::Read(
// streams in content will be wrapped in
// nsMIMEInputStream(RemoteLazyInputStream) which is also cloneable.
if (aResult->mPostData && !NS_InputStreamIsCloneable(aResult->mPostData)) {
- aActor->FatalError(
+ aReader->FatalError(
"Unexpected non-cloneable postData for SessionHistoryInfo");
return false;
}
- dom::SHEntrySharedParentState* sharedState = nullptr;
+ mozilla::dom::SHEntrySharedParentState* sharedState = nullptr;
if (XRE_IsParentProcess()) {
- sharedState = dom::SHEntrySharedParentState::Lookup(sharedId);
+ sharedState = mozilla::dom::SHEntrySharedParentState::Lookup(sharedId);
}
if (sharedState) {
@@ -1763,17 +1761,14 @@ bool IPDLParamTraits<dom::SessionHistoryInfo>::Read(
aResult->mSharedState.Get()->mContentType = contentType;
}
- Maybe<std::tuple<uint32_t, dom::ClonedMessageData>> navigationState;
- if (!ReadIPDLParam(aReader, aActor,
- &aResult->mSharedState.Get()->mLayoutHistoryState) ||
- !ReadIPDLParam(aReader, aActor,
- &aResult->mSharedState.Get()->mCacheKey) ||
- !ReadIPDLParam(aReader, aActor,
- &aResult->mSharedState.Get()->mIsFrameNavigation) ||
- !ReadIPDLParam(aReader, aActor,
- &aResult->mSharedState.Get()->mSaveLayoutState) ||
- !ReadIPDLParam(aReader, aActor, &navigationState)) {
- aActor->FatalError("Error reading fields for SessionHistoryInfo");
+ mozilla::Maybe<std::tuple<uint32_t, mozilla::dom::ClonedMessageData>>
+ navigationState;
+ if (!ReadParam(aReader, &aResult->mSharedState.Get()->mLayoutHistoryState) ||
+ !ReadParam(aReader, &aResult->mSharedState.Get()->mCacheKey) ||
+ !ReadParam(aReader, &aResult->mSharedState.Get()->mIsFrameNavigation) ||
+ !ReadParam(aReader, &aResult->mSharedState.Get()->mSaveLayoutState) ||
+ !ReadParam(aReader, &navigationState)) {
+ aReader->FatalError("Error reading fields for SessionHistoryInfo");
return false;
}
@@ -1795,62 +1790,60 @@ bool IPDLParamTraits<dom::SessionHistoryInfo>::Read(
return true;
}
-void IPDLParamTraits<dom::LoadingSessionHistoryInfo>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::LoadingSessionHistoryInfo& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mInfo);
- WriteIPDLParam(aWriter, aActor, aParam.mContiguousEntries);
- WriteIPDLParam(aWriter, aActor, aParam.mTriggeringEntry);
- WriteIPDLParam(aWriter, aActor, aParam.mTriggeringNavigationType);
- WriteIPDLParam(aWriter, aActor, aParam.mLoadId);
- WriteIPDLParam(aWriter, aActor, aParam.mLoadIsFromSessionHistory);
- WriteIPDLParam(aWriter, aActor, aParam.mOffset);
- WriteIPDLParam(aWriter, aActor, aParam.mLoadingCurrentEntry);
- WriteIPDLParam(aWriter, aActor, aParam.mForceMaybeResetName);
-}
-
-bool IPDLParamTraits<dom::LoadingSessionHistoryInfo>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor,
- dom::LoadingSessionHistoryInfo* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mInfo) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mContiguousEntries) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mTriggeringEntry) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mTriggeringNavigationType) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mLoadId) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mLoadIsFromSessionHistory) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mOffset) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mLoadingCurrentEntry) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mForceMaybeResetName)) {
- aActor->FatalError("Error reading fields for LoadingSessionHistoryInfo");
+void ParamTraits<mozilla::dom::LoadingSessionHistoryInfo>::Write(
+ IPC::MessageWriter* aWriter,
+ const mozilla::dom::LoadingSessionHistoryInfo& aParam) {
+ WriteParam(aWriter, aParam.mInfo);
+ WriteParam(aWriter, aParam.mContiguousEntries);
+ WriteParam(aWriter, aParam.mTriggeringEntry);
+ WriteParam(aWriter, aParam.mTriggeringNavigationType);
+ WriteParam(aWriter, aParam.mLoadId);
+ WriteParam(aWriter, aParam.mLoadIsFromSessionHistory);
+ WriteParam(aWriter, aParam.mOffset);
+ WriteParam(aWriter, aParam.mLoadingCurrentEntry);
+ WriteParam(aWriter, aParam.mForceMaybeResetName);
+}
+
+bool ParamTraits<mozilla::dom::LoadingSessionHistoryInfo>::Read(
+ IPC::MessageReader* aReader,
+ mozilla::dom::LoadingSessionHistoryInfo* aResult) {
+ if (!ReadParam(aReader, &aResult->mInfo) ||
+ !ReadParam(aReader, &aResult->mContiguousEntries) ||
+ !ReadParam(aReader, &aResult->mTriggeringEntry) ||
+ !ReadParam(aReader, &aResult->mTriggeringNavigationType) ||
+ !ReadParam(aReader, &aResult->mLoadId) ||
+ !ReadParam(aReader, &aResult->mLoadIsFromSessionHistory) ||
+ !ReadParam(aReader, &aResult->mOffset) ||
+ !ReadParam(aReader, &aResult->mLoadingCurrentEntry) ||
+ !ReadParam(aReader, &aResult->mForceMaybeResetName)) {
+ aReader->FatalError("Error reading fields for LoadingSessionHistoryInfo");
return false;
}
return true;
}
-void IPDLParamTraits<nsILayoutHistoryState*>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor,
- nsILayoutHistoryState* aParam) {
+void ParamTraits<nsILayoutHistoryState*>::Write(IPC::MessageWriter* aWriter,
+ nsILayoutHistoryState* aParam) {
if (aParam) {
- WriteIPDLParam(aWriter, aActor, true);
+ WriteParam(aWriter, true);
bool scrollPositionOnly = false;
nsTArray<nsCString> keys;
nsTArray<mozilla::PresState> states;
aParam->GetContents(&scrollPositionOnly, keys, states);
- WriteIPDLParam(aWriter, aActor, scrollPositionOnly);
- WriteIPDLParam(aWriter, aActor, keys);
- WriteIPDLParam(aWriter, aActor, states);
+ WriteParam(aWriter, scrollPositionOnly);
+ WriteParam(aWriter, keys);
+ WriteParam(aWriter, states);
} else {
- WriteIPDLParam(aWriter, aActor, false);
+ WriteParam(aWriter, false);
}
}
-bool IPDLParamTraits<nsILayoutHistoryState*>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor,
- RefPtr<nsILayoutHistoryState>* aResult) {
+bool ParamTraits<nsILayoutHistoryState*>::Read(
+ IPC::MessageReader* aReader, RefPtr<nsILayoutHistoryState>* aResult) {
bool hasLayoutHistoryState = false;
- if (!ReadIPDLParam(aReader, aActor, &hasLayoutHistoryState)) {
- aActor->FatalError("Error reading fields for nsILayoutHistoryState");
+ if (!ReadParam(aReader, &hasLayoutHistoryState)) {
+ aReader->FatalError("Error reading fields for nsILayoutHistoryState");
return false;
}
@@ -1858,46 +1851,39 @@ bool IPDLParamTraits<nsILayoutHistoryState*>::Read(
bool scrollPositionOnly = false;
nsTArray<nsCString> keys;
nsTArray<mozilla::PresState> states;
- if (!ReadIPDLParam(aReader, aActor, &scrollPositionOnly) ||
- !ReadIPDLParam(aReader, aActor, &keys) ||
- !ReadIPDLParam(aReader, aActor, &states)) {
- aActor->FatalError("Error reading fields for nsILayoutHistoryState");
+ if (!ReadParam(aReader, &scrollPositionOnly) ||
+ !ReadParam(aReader, &keys) || !ReadParam(aReader, &states)) {
+ aReader->FatalError("Error reading fields for nsILayoutHistoryState");
}
if (keys.Length() != states.Length()) {
- aActor->FatalError("Error reading fields for nsILayoutHistoryState");
+ aReader->FatalError("Error reading fields for nsILayoutHistoryState");
return false;
}
*aResult = NS_NewLayoutHistoryState();
(*aResult)->SetScrollPositionOnly(scrollPositionOnly);
for (uint32_t i = 0; i < keys.Length(); ++i) {
- PresState& state = states[i];
- UniquePtr<PresState> newState = MakeUnique<PresState>(state);
+ mozilla::PresState& state = states[i];
+ auto newState = mozilla::MakeUnique<mozilla::PresState>(state);
(*aResult)->AddState(keys[i], std::move(newState));
}
}
return true;
}
-void IPDLParamTraits<mozilla::dom::Wireframe>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor,
- const mozilla::dom::Wireframe& aParam) {
+void ParamTraits<mozilla::dom::Wireframe>::Write(
+ IPC::MessageWriter* aWriter, const mozilla::dom::Wireframe& aParam) {
WriteParam(aWriter, aParam.mCanvasBackground);
WriteParam(aWriter, aParam.mRects);
}
-bool IPDLParamTraits<mozilla::dom::Wireframe>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor,
- mozilla::dom::Wireframe* aResult) {
+bool ParamTraits<mozilla::dom::Wireframe>::Read(
+ IPC::MessageReader* aReader, mozilla::dom::Wireframe* aResult) {
return ReadParam(aReader, &aResult->mCanvasBackground) &&
ReadParam(aReader, &aResult->mRects);
}
-} // namespace ipc
-} // namespace mozilla
-
-namespace IPC {
// Allow sending mozilla::dom::WireframeRectType enums over IPC.
template <>
struct ParamTraits<mozilla::dom::WireframeRectType>
diff --git a/docshell/shistory/SessionHistoryEntry.h b/docshell/shistory/SessionHistoryEntry.h
@@ -25,9 +25,9 @@ class nsIReferrerInfo;
class nsISHistory;
class nsIURI;
-namespace mozilla::ipc {
+namespace IPC {
template <typename P>
-struct IPDLParamTraits;
+struct ParamTraits;
}
namespace mozilla {
@@ -176,7 +176,7 @@ class SessionHistoryInfo {
private:
friend class SessionHistoryEntry;
- friend struct mozilla::ipc::IPDLParamTraits<SessionHistoryInfo>;
+ friend struct IPC::ParamTraits<SessionHistoryInfo>;
void MaybeUpdateTitleFromURI();
@@ -487,50 +487,46 @@ class SessionHistoryEntry : public nsISHEntry,
};
} // namespace dom
+} // namespace mozilla
-namespace ipc {
-
-class IProtocol;
+namespace IPC {
// Allow sending SessionHistoryInfo objects over IPC.
template <>
-struct IPDLParamTraits<dom::SessionHistoryInfo> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::SessionHistoryInfo& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- dom::SessionHistoryInfo* aResult);
+struct ParamTraits<mozilla::dom::SessionHistoryInfo> {
+ static void Write(IPC::MessageWriter* aWriter,
+ const mozilla::dom::SessionHistoryInfo& aParam);
+ static bool Read(IPC::MessageReader* aReader,
+ mozilla::dom::SessionHistoryInfo* aResult);
};
// Allow sending LoadingSessionHistoryInfo objects over IPC.
template <>
-struct IPDLParamTraits<dom::LoadingSessionHistoryInfo> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::LoadingSessionHistoryInfo& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- dom::LoadingSessionHistoryInfo* aResult);
+struct ParamTraits<mozilla::dom::LoadingSessionHistoryInfo> {
+ static void Write(IPC::MessageWriter* aWriter,
+ const mozilla::dom::LoadingSessionHistoryInfo& aParam);
+ static bool Read(IPC::MessageReader* aReader,
+ mozilla::dom::LoadingSessionHistoryInfo* aResult);
};
// Allow sending nsILayoutHistoryState objects over IPC.
template <>
-struct IPDLParamTraits<nsILayoutHistoryState*> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- nsILayoutHistoryState* aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+struct ParamTraits<nsILayoutHistoryState*> {
+ static void Write(IPC::MessageWriter* aWriter, nsILayoutHistoryState* aParam);
+ static bool Read(IPC::MessageReader* aReader,
RefPtr<nsILayoutHistoryState>* aResult);
};
-// Allow sending dom::Wireframe objects over IPC.
+// Allow sending mozilla::dom::Wireframe objects over IPC.
template <>
-struct IPDLParamTraits<mozilla::dom::Wireframe> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
+struct ParamTraits<mozilla::dom::Wireframe> {
+ static void Write(IPC::MessageWriter* aWriter,
const mozilla::dom::Wireframe& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+ static bool Read(IPC::MessageReader* aReader,
mozilla::dom::Wireframe* aResult);
};
-} // namespace ipc
-
-} // namespace mozilla
+} // namespace IPC
inline nsISupports* ToSupports(mozilla::dom::SessionHistoryEntry* aEntry) {
return static_cast<nsISHEntry*>(aEntry);
diff --git a/dom/base/nsDOMNavigationTiming.cpp b/dom/base/nsDOMNavigationTiming.cpp
@@ -11,7 +11,6 @@
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/Document.h"
#include "mozilla/glean/DomMetrics.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/ipc/URIUtils.h"
#include "nsCOMPtr.h"
#include "nsContentUtils.h"
@@ -542,45 +541,42 @@ nsDOMNavigationTiming::nsDOMNavigationTiming(nsDocShell* aDocShell,
aOther->mDocShellHasBeenActiveSinceNavigationStart) {}
/* static */
-void mozilla::ipc::IPDLParamTraits<nsDOMNavigationTiming*>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor,
- nsDOMNavigationTiming* aParam) {
+void IPC::ParamTraits<nsDOMNavigationTiming*>::Write(
+ MessageWriter* aWriter, nsDOMNavigationTiming* aParam) {
bool isNull = !aParam;
- WriteIPDLParam(aWriter, aActor, isNull);
+ WriteParam(aWriter, isNull);
if (isNull) {
return;
}
RefPtr<nsIURI> unloadedURI = aParam->mUnloadedURI.get();
RefPtr<nsIURI> loadedURI = aParam->mLoadedURI.get();
- WriteIPDLParam(aWriter, aActor, unloadedURI ? Some(unloadedURI) : Nothing());
- WriteIPDLParam(aWriter, aActor, loadedURI ? Some(loadedURI) : Nothing());
- WriteIPDLParam(aWriter, aActor, uint32_t(aParam->mNavigationType));
- WriteIPDLParam(aWriter, aActor, aParam->mNavigationStartHighRes);
- WriteIPDLParam(aWriter, aActor, aParam->mNavigationStart);
- WriteIPDLParam(aWriter, aActor, aParam->mNonBlankPaint);
- WriteIPDLParam(aWriter, aActor, aParam->mContentfulComposite);
- WriteIPDLParam(aWriter, aActor, aParam->mBeforeUnloadStart);
- WriteIPDLParam(aWriter, aActor, aParam->mUnloadStart);
- WriteIPDLParam(aWriter, aActor, aParam->mUnloadEnd);
- WriteIPDLParam(aWriter, aActor, aParam->mLoadEventStart);
- WriteIPDLParam(aWriter, aActor, aParam->mLoadEventEnd);
- WriteIPDLParam(aWriter, aActor, aParam->mDOMLoading);
- WriteIPDLParam(aWriter, aActor, aParam->mDOMInteractive);
- WriteIPDLParam(aWriter, aActor, aParam->mDOMContentLoadedEventStart);
- WriteIPDLParam(aWriter, aActor, aParam->mDOMContentLoadedEventEnd);
- WriteIPDLParam(aWriter, aActor, aParam->mDOMComplete);
- WriteIPDLParam(aWriter, aActor, aParam->mTTFI);
- WriteIPDLParam(aWriter, aActor,
- aParam->mDocShellHasBeenActiveSinceNavigationStart);
+ WriteParam(aWriter, unloadedURI ? Some(unloadedURI) : Nothing());
+ WriteParam(aWriter, loadedURI ? Some(loadedURI) : Nothing());
+ WriteParam(aWriter, uint32_t(aParam->mNavigationType));
+ WriteParam(aWriter, aParam->mNavigationStartHighRes);
+ WriteParam(aWriter, aParam->mNavigationStart);
+ WriteParam(aWriter, aParam->mNonBlankPaint);
+ WriteParam(aWriter, aParam->mContentfulComposite);
+ WriteParam(aWriter, aParam->mBeforeUnloadStart);
+ WriteParam(aWriter, aParam->mUnloadStart);
+ WriteParam(aWriter, aParam->mUnloadEnd);
+ WriteParam(aWriter, aParam->mLoadEventStart);
+ WriteParam(aWriter, aParam->mLoadEventEnd);
+ WriteParam(aWriter, aParam->mDOMLoading);
+ WriteParam(aWriter, aParam->mDOMInteractive);
+ WriteParam(aWriter, aParam->mDOMContentLoadedEventStart);
+ WriteParam(aWriter, aParam->mDOMContentLoadedEventEnd);
+ WriteParam(aWriter, aParam->mDOMComplete);
+ WriteParam(aWriter, aParam->mTTFI);
+ WriteParam(aWriter, aParam->mDocShellHasBeenActiveSinceNavigationStart);
}
/* static */
-bool mozilla::ipc::IPDLParamTraits<nsDOMNavigationTiming*>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor,
- RefPtr<nsDOMNavigationTiming>* aResult) {
+bool IPC::ParamTraits<nsDOMNavigationTiming*>::Read(
+ IPC::MessageReader* aReader, RefPtr<nsDOMNavigationTiming>* aResult) {
bool isNull;
- if (!ReadIPDLParam(aReader, aActor, &isNull)) {
+ if (!ReadParam(aReader, &isNull)) {
return false;
}
if (isNull) {
@@ -592,26 +588,25 @@ bool mozilla::ipc::IPDLParamTraits<nsDOMNavigationTiming*>::Read(
uint32_t type;
Maybe<RefPtr<nsIURI>> unloadedURI;
Maybe<RefPtr<nsIURI>> loadedURI;
- if (!ReadIPDLParam(aReader, aActor, &unloadedURI) ||
- !ReadIPDLParam(aReader, aActor, &loadedURI) ||
- !ReadIPDLParam(aReader, aActor, &type) ||
- !ReadIPDLParam(aReader, aActor, &timing->mNavigationStartHighRes) ||
- !ReadIPDLParam(aReader, aActor, &timing->mNavigationStart) ||
- !ReadIPDLParam(aReader, aActor, &timing->mNonBlankPaint) ||
- !ReadIPDLParam(aReader, aActor, &timing->mContentfulComposite) ||
- !ReadIPDLParam(aReader, aActor, &timing->mBeforeUnloadStart) ||
- !ReadIPDLParam(aReader, aActor, &timing->mUnloadStart) ||
- !ReadIPDLParam(aReader, aActor, &timing->mUnloadEnd) ||
- !ReadIPDLParam(aReader, aActor, &timing->mLoadEventStart) ||
- !ReadIPDLParam(aReader, aActor, &timing->mLoadEventEnd) ||
- !ReadIPDLParam(aReader, aActor, &timing->mDOMLoading) ||
- !ReadIPDLParam(aReader, aActor, &timing->mDOMInteractive) ||
- !ReadIPDLParam(aReader, aActor, &timing->mDOMContentLoadedEventStart) ||
- !ReadIPDLParam(aReader, aActor, &timing->mDOMContentLoadedEventEnd) ||
- !ReadIPDLParam(aReader, aActor, &timing->mDOMComplete) ||
- !ReadIPDLParam(aReader, aActor, &timing->mTTFI) ||
- !ReadIPDLParam(aReader, aActor,
- &timing->mDocShellHasBeenActiveSinceNavigationStart)) {
+ if (!ReadParam(aReader, &unloadedURI) || !ReadParam(aReader, &loadedURI) ||
+ !ReadParam(aReader, &type) ||
+ !ReadParam(aReader, &timing->mNavigationStartHighRes) ||
+ !ReadParam(aReader, &timing->mNavigationStart) ||
+ !ReadParam(aReader, &timing->mNonBlankPaint) ||
+ !ReadParam(aReader, &timing->mContentfulComposite) ||
+ !ReadParam(aReader, &timing->mBeforeUnloadStart) ||
+ !ReadParam(aReader, &timing->mUnloadStart) ||
+ !ReadParam(aReader, &timing->mUnloadEnd) ||
+ !ReadParam(aReader, &timing->mLoadEventStart) ||
+ !ReadParam(aReader, &timing->mLoadEventEnd) ||
+ !ReadParam(aReader, &timing->mDOMLoading) ||
+ !ReadParam(aReader, &timing->mDOMInteractive) ||
+ !ReadParam(aReader, &timing->mDOMContentLoadedEventStart) ||
+ !ReadParam(aReader, &timing->mDOMContentLoadedEventEnd) ||
+ !ReadParam(aReader, &timing->mDOMComplete) ||
+ !ReadParam(aReader, &timing->mTTFI) ||
+ !ReadParam(aReader,
+ &timing->mDocShellHasBeenActiveSinceNavigationStart)) {
return false;
}
timing->mNavigationType = nsDOMNavigationTiming::Type(type);
diff --git a/dom/base/nsDOMNavigationTiming.h b/dom/base/nsDOMNavigationTiming.h
@@ -26,12 +26,9 @@ namespace IPC {
class Message;
class MessageReader;
class MessageWriter;
-} // namespace IPC
-namespace mozilla::ipc {
-class IProtocol;
template <typename>
-struct IPDLParamTraits;
-} // namespace mozilla::ipc
+struct ParamTraits;
+} // namespace IPC
class nsDOMNavigationTiming final : public mozilla::RelativeTimeline {
public:
@@ -256,22 +253,22 @@ class nsDOMNavigationTiming final : public mozilla::RelativeTimeline {
bool mDocShellHasBeenActiveSinceNavigationStart;
- friend struct mozilla::ipc::IPDLParamTraits<nsDOMNavigationTiming*>;
+ friend struct IPC::ParamTraits<nsDOMNavigationTiming*>;
};
// IPDL serializer. Please be aware of the caveats in sending across
// the information and the potential resulting data leakage.
// For now, this serializer is to only be used under a very narrowed scope
// so that only the starting times are ever set.
-namespace mozilla::ipc {
+namespace IPC {
+
template <>
-struct IPDLParamTraits<nsDOMNavigationTiming*> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- nsDOMNavigationTiming* aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+struct ParamTraits<nsDOMNavigationTiming*> {
+ static void Write(MessageWriter* aWriter, nsDOMNavigationTiming* aParam);
+ static bool Read(MessageReader* aReader,
RefPtr<nsDOMNavigationTiming>* aResult);
};
-} // namespace mozilla::ipc
+} // namespace IPC
#endif /* nsDOMNavigationTiming_h___ */
diff --git a/dom/canvas/ParamTraits_IsEnumCase.h b/dom/canvas/ParamTraits_IsEnumCase.h
@@ -8,7 +8,6 @@
#include "IsEnumCase.h"
#include "ipc/IPCMessageUtils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
namespace IPC {
diff --git a/dom/canvas/ParamTraits_STL.h b/dom/canvas/ParamTraits_STL.h
@@ -9,7 +9,6 @@
#include <memory>
#include "ipc/IPCMessageUtils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
namespace IPC {
diff --git a/dom/canvas/ParamTraits_TiedFields.h b/dom/canvas/ParamTraits_TiedFields.h
@@ -8,7 +8,6 @@
#include "TiedFields.h"
#include "ipc/IPCMessageUtils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
namespace IPC {
diff --git a/dom/canvas/WebGLCommandQueue.h b/dom/canvas/WebGLCommandQueue.h
@@ -11,7 +11,6 @@
#include "QueueParamTraits.h"
#include "WebGLTypes.h"
#include "mozilla/gfx/Logging.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
namespace mozilla {
diff --git a/dom/canvas/WebGLIpdl.h b/dom/canvas/WebGLIpdl.h
@@ -15,7 +15,6 @@
#include "mozilla/ParamTraits_STL.h"
#include "mozilla/ParamTraits_TiedFields.h"
#include "mozilla/dom/BindingIPCUtils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/ipc/Shmem.h"
#include "mozilla/layers/LayersSurfaces.h"
@@ -118,55 +117,53 @@ class RaiiShmem final {
using Int32Vector = std::vector<int32_t>;
} // namespace webgl
+} // namespace mozilla
-namespace ipc {
+namespace IPC {
template <>
-struct IPDLParamTraits<mozilla::webgl::FrontBufferSnapshotIpc> final {
+struct ParamTraits<mozilla::webgl::FrontBufferSnapshotIpc> final {
using T = mozilla::webgl::FrontBufferSnapshotIpc;
- static void Write(IPC::MessageWriter* const writer, IProtocol* actor, T& in) {
+ static void Write(IPC::MessageWriter* const writer, T& in) {
WriteParam(writer, in.surfSize);
WriteParam(writer, in.byteStride);
- WriteIPDLParam(writer, actor, std::move(in.shmem));
+ WriteParam(writer, std::move(in.shmem));
}
- static bool Read(IPC::MessageReader* const reader, IProtocol* actor,
- T* const out) {
+ static bool Read(IPC::MessageReader* const reader, T* const out) {
return ReadParam(reader, &out->surfSize) &&
ReadParam(reader, &out->byteStride) &&
- ReadIPDLParam(reader, actor, &out->shmem);
+ ReadParam(reader, &out->shmem);
}
};
// -
template <>
-struct IPDLParamTraits<mozilla::webgl::ReadPixelsResultIpc> final {
+struct ParamTraits<mozilla::webgl::ReadPixelsResultIpc> final {
using T = mozilla::webgl::ReadPixelsResultIpc;
- static void Write(IPC::MessageWriter* const writer, IProtocol* actor, T& in) {
+ static void Write(MessageWriter* const writer, T& in) {
WriteParam(writer, in.subrect);
WriteParam(writer, in.byteStride);
- WriteIPDLParam(writer, actor, std::move(in.shmem));
+ WriteParam(writer, std::move(in.shmem));
}
- static bool Read(IPC::MessageReader* const reader, IProtocol* actor,
- T* const out) {
+ static bool Read(MessageReader* const reader, T* const out) {
return ReadParam(reader, &out->subrect) &&
ReadParam(reader, &out->byteStride) &&
- ReadIPDLParam(reader, actor, &out->shmem);
+ ReadParam(reader, &out->shmem);
}
};
// -
template <>
-struct IPDLParamTraits<mozilla::webgl::TexUnpackBlobDesc> final {
+struct ParamTraits<mozilla::webgl::TexUnpackBlobDesc> final {
using T = mozilla::webgl::TexUnpackBlobDesc;
- static void Write(IPC::MessageWriter* const writer, IProtocol* actor,
- T&& in) {
+ static void Write(MessageWriter* const writer, T&& in) {
WriteParam(writer, in.imageTarget);
WriteParam(writer, in.size);
WriteParam(writer, in.srcAlphaType);
@@ -174,33 +171,22 @@ struct IPDLParamTraits<mozilla::webgl::TexUnpackBlobDesc> final {
MOZ_RELEASE_ASSERT(!in.pboOffset);
WriteParam(writer, in.structuredSrcSize);
MOZ_RELEASE_ASSERT(!in.image);
- WriteIPDLParam(writer, actor, std::move(in.sd));
+ WriteParam(writer, std::move(in.sd));
MOZ_RELEASE_ASSERT(!in.sourceSurf);
WriteParam(writer, in.unpacking);
WriteParam(writer, in.applyUnpackTransforms);
}
- static bool Read(IPC::MessageReader* const reader, IProtocol* actor,
- T* const out) {
+ static bool Read(MessageReader* const reader, T* const out) {
return ReadParam(reader, &out->imageTarget) &&
ReadParam(reader, &out->size) &&
ReadParam(reader, &out->srcAlphaType) &&
ReadParam(reader, &out->structuredSrcSize) &&
- ReadIPDLParam(reader, actor, &out->sd) &&
- ReadParam(reader, &out->unpacking) &&
+ ReadParam(reader, &out->sd) && ReadParam(reader, &out->unpacking) &&
ReadParam(reader, &out->applyUnpackTransforms);
}
};
-} // namespace ipc
-
-namespace webgl {
-using Int32Vector = std::vector<int32_t>;
-} // namespace webgl
-} // namespace mozilla
-
-namespace IPC {
-
// -
template <class U, size_t PaddedSize>
diff --git a/dom/cookiestore/CookieStoreParent.cpp b/dom/cookiestore/CookieStoreParent.cpp
@@ -12,7 +12,7 @@
#include "mozilla/Maybe.h"
#include "mozilla/ScopeExit.h"
#include "mozilla/ipc/BackgroundParent.h"
-#include "mozilla/ipc/URIUtils.h" // for IPDLParamTraits<nsIURI*>
+#include "mozilla/ipc/URIUtils.h" // for ParamTraits<nsIURI*>
#include "mozilla/net/Cookie.h"
#include "mozilla/net/CookieCommons.h"
#include "mozilla/net/CookieParser.h"
diff --git a/dom/file/ipc/IPCBlobUtils.h b/dom/file/ipc/IPCBlobUtils.h
@@ -9,7 +9,6 @@
#include "mozilla/RefPtr.h"
#include "mozilla/dom/File.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
/*
* Blobs and IPC
diff --git a/dom/ipc/DocShellMessageUtils.cpp b/dom/ipc/DocShellMessageUtils.cpp
@@ -7,7 +7,6 @@
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/DOMTypes.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "nsSerializationHelper.h"
namespace IPC {
diff --git a/dom/ipc/DocShellMessageUtils.h b/dom/ipc/DocShellMessageUtils.h
@@ -9,7 +9,6 @@
#include "ipc/EnumSerializer.h"
#include "mozilla/ScrollbarPreferences.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "nsCOMPtr.h"
#include "nsDocShellLoadState.h"
#include "nsIDocumentViewer.h"
diff --git a/dom/ipc/PermissionMessageUtils.cpp b/dom/ipc/PermissionMessageUtils.cpp
@@ -6,31 +6,30 @@
#include "mozilla/dom/PermissionMessageUtils.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
#include "mozilla/ipc/BackgroundUtils.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
#include "nsCOMPtr.h"
#include "nsIPrincipal.h"
-namespace mozilla::ipc {
+namespace IPC {
-void IPDLParamTraits<nsIPrincipal*>::Write(IPC::MessageWriter* aWriter,
- IProtocol* aActor,
- nsIPrincipal* aParam) {
- Maybe<PrincipalInfo> info;
+void ParamTraits<nsIPrincipal*>::Write(IPC::MessageWriter* aWriter,
+ nsIPrincipal* aParam) {
+ mozilla::Maybe<mozilla::ipc::PrincipalInfo> info;
if (aParam) {
info.emplace();
nsresult rv = PrincipalToPrincipalInfo(aParam, info.ptr());
MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
}
- WriteIPDLParam(aWriter, aActor, info);
+ WriteParam(aWriter, info);
}
-bool IPDLParamTraits<nsIPrincipal*>::Read(IPC::MessageReader* aReader,
- IProtocol* aActor,
- RefPtr<nsIPrincipal>* aResult) {
- Maybe<PrincipalInfo> info;
- if (!ReadIPDLParam(aReader, aActor, &info)) {
+bool ParamTraits<nsIPrincipal*>::Read(IPC::MessageReader* aReader,
+ RefPtr<nsIPrincipal>* aResult) {
+ mozilla::Maybe<mozilla::ipc::PrincipalInfo> info;
+ if (!ReadParam(aReader, &info)) {
return false;
}
@@ -49,4 +48,4 @@ bool IPDLParamTraits<nsIPrincipal*>::Read(IPC::MessageReader* aReader,
return true;
}
-} // namespace mozilla::ipc
+} // namespace IPC
diff --git a/dom/ipc/PermissionMessageUtils.h b/dom/ipc/PermissionMessageUtils.h
@@ -8,24 +8,21 @@
#define mozilla_dom_permission_message_utils_h__
#include "ipc/IPCMessageUtils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "nsCOMPtr.h"
#include "nsIPrincipal.h"
-namespace mozilla::ipc {
+namespace IPC {
template <>
-struct IPDLParamTraits<nsIPrincipal*> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- nsIPrincipal* aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- RefPtr<nsIPrincipal>* aResult);
+struct ParamTraits<nsIPrincipal*> {
+ static void Write(IPC::MessageWriter* aWriter, nsIPrincipal* aParam);
+ static bool Read(IPC::MessageReader* aReader, RefPtr<nsIPrincipal>* aResult);
// Overload to support deserializing nsCOMPtr<nsIPrincipal> directly.
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+ static bool Read(IPC::MessageReader* aReader,
nsCOMPtr<nsIPrincipal>* aResult) {
RefPtr<nsIPrincipal> result;
- if (!Read(aReader, aActor, &result)) {
+ if (!Read(aReader, &result)) {
return false;
}
*aResult = std::move(result);
@@ -33,6 +30,6 @@ struct IPDLParamTraits<nsIPrincipal*> {
}
};
-} // namespace mozilla::ipc
+} // namespace IPC
#endif // mozilla_dom_permission_message_utils_h__
diff --git a/dom/ipc/PropertyBagUtils.cpp b/dom/ipc/PropertyBagUtils.cpp
@@ -6,6 +6,7 @@
#include "PropertyBagUtils.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
#include "mozilla/SimpleEnumerator.h"
#include "mozilla/dom/DOMTypes.h"
#include "nsCOMPtr.h"
@@ -15,14 +16,12 @@
#include "nsIURI.h"
#include "nsVariant.h"
-using namespace IPC;
using namespace mozilla::dom;
-namespace mozilla::ipc {
+namespace IPC {
-void IPDLParamTraits<nsIVariant*>::Write(MessageWriter* aWriter,
- IProtocol* aActor,
- nsIVariant* aParam) {
+void ParamTraits<nsIVariant*>::Write(MessageWriter* aWriter,
+ nsIVariant* aParam) {
IDPLVariant variant;
variant.type() = aParam->GetDataType();
@@ -131,18 +130,17 @@ void IPDLParamTraits<nsIVariant*>::Write(MessageWriter* aWriter,
MOZ_CRASH("Non handled variant type, patch welcome");
break;
}
- WriteIPDLParam(aWriter, aActor, variant);
+ WriteParam(aWriter, variant);
}
-bool IPDLParamTraits<nsIVariant*>::Read(MessageReader* aReader,
- IProtocol* aActor,
- RefPtr<nsIVariant>* aResult) {
+bool ParamTraits<nsIVariant*>::Read(MessageReader* aReader,
+ RefPtr<nsIVariant>* aResult) {
IDPLVariant value;
- if (!ReadIPDLParam(aReader, aActor, &value)) {
+ if (!ReadParam(aReader, &value)) {
return false;
}
- auto variant = MakeRefPtr<nsVariant>();
+ auto variant = mozilla::MakeRefPtr<nsVariant>();
switch (value.type()) {
case nsIDataType::VTYPE_INT8:
@@ -219,16 +217,15 @@ bool IPDLParamTraits<nsIVariant*>::Read(MessageReader* aReader,
return true;
}
-void IPDLParamTraits<nsIPropertyBag2*>::Write(MessageWriter* aWriter,
- IProtocol* aActor,
- nsIPropertyBag2* aParam) {
+void ParamTraits<nsIPropertyBag2*>::Write(MessageWriter* aWriter,
+ nsIPropertyBag2* aParam) {
// We send a nsIPropertyBag as an array of IPDLProperty
nsTArray<IPDLProperty> bag;
nsCOMPtr<nsISimpleEnumerator> enumerator;
if (aParam &&
NS_SUCCEEDED(aParam->GetEnumerator(getter_AddRefs(enumerator)))) {
- for (auto& property : SimpleEnumerator<nsIProperty>(enumerator)) {
+ for (auto& property : mozilla::SimpleEnumerator<nsIProperty>(enumerator)) {
nsString name;
nsCOMPtr<nsIVariant> value;
MOZ_ALWAYS_SUCCEEDS(property->GetName(name));
@@ -236,18 +233,17 @@ void IPDLParamTraits<nsIPropertyBag2*>::Write(MessageWriter* aWriter,
bag.AppendElement(IPDLProperty{name, value});
}
}
- WriteIPDLParam(aWriter, aActor, bag);
+ WriteParam(aWriter, bag);
}
-bool IPDLParamTraits<nsIPropertyBag2*>::Read(MessageReader* aReader,
- IProtocol* aActor,
- RefPtr<nsIPropertyBag2>* aResult) {
+bool ParamTraits<nsIPropertyBag2*>::Read(MessageReader* aReader,
+ RefPtr<nsIPropertyBag2>* aResult) {
nsTArray<IPDLProperty> bag;
- if (!ReadIPDLParam(aReader, aActor, &bag)) {
+ if (!ReadParam(aReader, &bag)) {
return false;
}
- auto properties = MakeRefPtr<nsHashPropertyBag>();
+ auto properties = mozilla::MakeRefPtr<nsHashPropertyBag>();
for (auto& entry : bag) {
nsCOMPtr<nsIVariant> variant = std::move(entry.value());
@@ -258,4 +254,4 @@ bool IPDLParamTraits<nsIPropertyBag2*>::Read(MessageReader* aReader,
return true;
}
-} // namespace mozilla::ipc
+} // namespace IPC
diff --git a/dom/ipc/PropertyBagUtils.h b/dom/ipc/PropertyBagUtils.h
@@ -7,32 +7,28 @@
#ifndef IPC_PropertyBagUtils_h
#define IPC_PropertyBagUtils_h
-#include "mozilla/ipc/IPDLParamTraits.h"
+#include "chrome/common/ipc_message_utils.h"
#include "nsIPropertyBag2.h"
#include "nsIVariant.h"
-namespace mozilla::ipc {
+namespace IPC {
/**
* Limited nsIVariant support. Not all types are implemented and only
* nsIURI is implemented with nsIVariant::GetAsInterface.
*/
template <>
-struct IPDLParamTraits<nsIVariant*> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- nsIVariant* aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- RefPtr<nsIVariant>* aResult);
+struct ParamTraits<nsIVariant*> {
+ static void Write(MessageWriter* aWriter, nsIVariant* aParam);
+ static bool Read(MessageReader* aReader, RefPtr<nsIVariant>* aResult);
};
template <>
-struct IPDLParamTraits<nsIPropertyBag2*> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- nsIPropertyBag2* aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- RefPtr<nsIPropertyBag2>* aResult);
+struct ParamTraits<nsIPropertyBag2*> {
+ static void Write(MessageWriter* aWriter, nsIPropertyBag2* aParam);
+ static bool Read(MessageReader* aReader, RefPtr<nsIPropertyBag2>* aResult);
};
-} // namespace mozilla::ipc
+} // namespace IPC
#endif // mozilla_ipc_URIUtils_h
diff --git a/dom/media/ipc/RemoteImageHolder.cpp b/dom/media/ipc/RemoteImageHolder.cpp
@@ -181,33 +181,33 @@ RemoteImageHolder::~RemoteImageHolder() {
}
}
-/* static */ void ipc::IPDLParamTraits<RemoteImageHolder>::Write(
- IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- RemoteImageHolder&& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mSource);
- WriteIPDLParam(aWriter, aActor, aParam.mSize);
- WriteIPDLParam(aWriter, aActor, aParam.mColorDepth);
- WriteIPDLParam(aWriter, aActor, aParam.mSD);
- WriteIPDLParam(aWriter, aActor, aParam.mYUVColorSpace);
- WriteIPDLParam(aWriter, aActor, aParam.mColorPrimaries);
- WriteIPDLParam(aWriter, aActor, aParam.mTransferFunction);
- WriteIPDLParam(aWriter, aActor, aParam.mColorRange);
+} // namespace mozilla
+
+/* static */ void IPC::ParamTraits<mozilla::RemoteImageHolder>::Write(
+ MessageWriter* aWriter, mozilla::RemoteImageHolder&& aParam) {
+ WriteParam(aWriter, aParam.mSource);
+ WriteParam(aWriter, aParam.mSize);
+ WriteParam(aWriter, aParam.mColorDepth);
+ WriteParam(aWriter, aParam.mSD);
+ WriteParam(aWriter, aParam.mYUVColorSpace);
+ WriteParam(aWriter, aParam.mColorPrimaries);
+ WriteParam(aWriter, aParam.mTransferFunction);
+ WriteParam(aWriter, aParam.mColorRange);
// Empty this holder.
- aParam.mSD = Nothing();
+ aParam.mSD = mozilla::Nothing();
aParam.mManager = nullptr;
}
-/* static */ bool ipc::IPDLParamTraits<RemoteImageHolder>::Read(
- IPC::MessageReader* aReader, ipc::IProtocol* aActor,
- RemoteImageHolder* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mSource) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mSize) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mColorDepth) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mSD) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mYUVColorSpace) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mColorPrimaries) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mTransferFunction) ||
- !ReadIPDLParam(aReader, aActor, &aResult->mColorRange)) {
+/* static */ bool IPC::ParamTraits<mozilla::RemoteImageHolder>::Read(
+ MessageReader* aReader, mozilla::RemoteImageHolder* aResult) {
+ if (!ReadParam(aReader, &aResult->mSource) ||
+ !ReadParam(aReader, &aResult->mSize) ||
+ !ReadParam(aReader, &aResult->mColorDepth) ||
+ !ReadParam(aReader, &aResult->mSD) ||
+ !ReadParam(aReader, &aResult->mYUVColorSpace) ||
+ !ReadParam(aReader, &aResult->mColorPrimaries) ||
+ !ReadParam(aReader, &aResult->mTransferFunction) ||
+ !ReadParam(aReader, &aResult->mColorRange)) {
return false;
}
@@ -215,20 +215,21 @@ RemoteImageHolder::~RemoteImageHolder() {
return true;
}
- if (auto* manager = aActor->Manager()) {
- if (manager->GetProtocolId() == ProtocolId::PRemoteMediaManagerMsgStart) {
- aResult->mManager =
- XRE_IsContentProcess()
- ? static_cast<IGPUVideoSurfaceManager*>(
- static_cast<RemoteMediaManagerChild*>(manager))
- : static_cast<IGPUVideoSurfaceManager*>(
- static_cast<RemoteMediaManagerParent*>(manager));
- return true;
+ if (auto* actor = aReader->GetActor()) {
+ if (auto* manager = actor->Manager()) {
+ if (manager->GetProtocolId() ==
+ mozilla::ipc::ProtocolId::PRemoteMediaManagerMsgStart) {
+ aResult->mManager =
+ XRE_IsContentProcess()
+ ? static_cast<mozilla::IGPUVideoSurfaceManager*>(
+ static_cast<mozilla::RemoteMediaManagerChild*>(manager))
+ : static_cast<mozilla::IGPUVideoSurfaceManager*>(
+ static_cast<mozilla::RemoteMediaManagerParent*>(manager));
+ return true;
+ }
}
}
MOZ_ASSERT_UNREACHABLE("Unexpected or missing protocol manager!");
return false;
}
-
-} // namespace mozilla
diff --git a/dom/media/ipc/RemoteImageHolder.h b/dom/media/ipc/RemoteImageHolder.h
@@ -21,7 +21,7 @@ class IGPUVideoSurfaceManager;
class SurfaceDescriptor;
} // namespace layers
class RemoteImageHolder final {
- friend struct ipc::IPDLParamTraits<RemoteImageHolder>;
+ friend struct IPC::ParamTraits<RemoteImageHolder>;
public:
RemoteImageHolder();
@@ -59,14 +59,13 @@ class RemoteImageHolder final {
gfx::ColorRange mColorRange = {};
};
+} // namespace mozilla
+
template <>
-struct ipc::IPDLParamTraits<RemoteImageHolder> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- RemoteImageHolder&& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- RemoteImageHolder* aResult);
+struct IPC::ParamTraits<mozilla::RemoteImageHolder> {
+ static void Write(MessageWriter* aWriter,
+ mozilla::RemoteImageHolder&& aParam);
+ static bool Read(MessageReader* aReader, mozilla::RemoteImageHolder* aResult);
};
-} // namespace mozilla
-
#endif // mozilla_dom_media_RemoteImageHolder_h
diff --git a/dom/media/ipc/RemoteMediaData.cpp b/dom/media/ipc/RemoteMediaData.cpp
@@ -108,29 +108,31 @@ already_AddRefed<MediaByteBuffer> RemoteArrayOfByteBuffer::MediaByteBufferAt(
return buffer.forget();
}
-/*static */ void ipc::IPDLParamTraits<RemoteArrayOfByteBuffer>::Write(
- IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- const RemoteArrayOfByteBuffer& aVar) {
- WriteIPDLParam(aWriter, aActor, aVar.mIsValid);
+} // namespace mozilla
+
+/*static */ void IPC::ParamTraits<mozilla::RemoteArrayOfByteBuffer>::Write(
+ IPC::MessageWriter* aWriter, const mozilla::RemoteArrayOfByteBuffer& aVar) {
+ WriteParam(aWriter, aVar.mIsValid);
// We need the following gymnastic as the Shmem transfered over IPC will be
// revoked. We must create a temporary one instead so that it can be recycled
// later back into the original ShmemPool.
if (aVar.mBuffers) {
- WriteIPDLParam(aWriter, aActor, Some(ipc::Shmem(*aVar.mBuffers)));
+ WriteParam(aWriter, mozilla::Some(mozilla::ipc::Shmem(*aVar.mBuffers)));
} else {
- WriteIPDLParam(aWriter, aActor, Maybe<ipc::Shmem>());
+ WriteParam(aWriter, mozilla::Maybe<mozilla::ipc::Shmem>());
}
- WriteIPDLParam(aWriter, aActor, aVar.mOffsets);
+ WriteParam(aWriter, aVar.mOffsets);
}
-/* static */ bool ipc::IPDLParamTraits<RemoteArrayOfByteBuffer>::Read(
- IPC::MessageReader* aReader, mozilla::ipc::IProtocol* aActor,
- RemoteArrayOfByteBuffer* aVar) {
- return ReadIPDLParam(aReader, aActor, &aVar->mIsValid) &&
- ReadIPDLParam(aReader, aActor, &aVar->mBuffers) &&
- ReadIPDLParam(aReader, aActor, &aVar->mOffsets);
+/* static */ bool IPC::ParamTraits<mozilla::RemoteArrayOfByteBuffer>::Read(
+ IPC::MessageReader* aReader, mozilla::RemoteArrayOfByteBuffer* aVar) {
+ return ReadParam(aReader, &aVar->mIsValid) &&
+ ReadParam(aReader, &aVar->mBuffers) &&
+ ReadParam(aReader, &aVar->mOffsets);
}
+namespace mozilla {
+
bool ArrayOfRemoteMediaRawData::Fill(
const nsTArray<RefPtr<MediaRawData>>& aData,
std::function<ShmemBuffer(size_t)>&& aAllocator) {
@@ -234,23 +236,23 @@ already_AddRefed<MediaRawData> ArrayOfRemoteMediaRawData::ElementAt(
return rawData.forget();
}
-/*static */ void ipc::IPDLParamTraits<ArrayOfRemoteMediaRawData*>::Write(
- IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- ArrayOfRemoteMediaRawData* aVar) {
- WriteIPDLParam(aWriter, aActor, std::move(aVar->mSamples));
- WriteIPDLParam(aWriter, aActor, std::move(aVar->mBuffers));
- WriteIPDLParam(aWriter, aActor, std::move(aVar->mAlphaBuffers));
- WriteIPDLParam(aWriter, aActor, std::move(aVar->mExtraDatas));
+} // namespace mozilla
+
+/*static */ void IPC::ParamTraits<mozilla::ArrayOfRemoteMediaRawData*>::Write(
+ MessageWriter* aWriter, mozilla::ArrayOfRemoteMediaRawData* aVar) {
+ WriteParam(aWriter, std::move(aVar->mSamples));
+ WriteParam(aWriter, std::move(aVar->mBuffers));
+ WriteParam(aWriter, std::move(aVar->mAlphaBuffers));
+ WriteParam(aWriter, std::move(aVar->mExtraDatas));
}
-/* static */ bool ipc::IPDLParamTraits<ArrayOfRemoteMediaRawData*>::Read(
- IPC::MessageReader* aReader, mozilla::ipc::IProtocol* aActor,
- RefPtr<ArrayOfRemoteMediaRawData>* aVar) {
- auto array = MakeRefPtr<ArrayOfRemoteMediaRawData>();
- if (!ReadIPDLParam(aReader, aActor, &array->mSamples) ||
- !ReadIPDLParam(aReader, aActor, &array->mBuffers) ||
- !ReadIPDLParam(aReader, aActor, &array->mAlphaBuffers) ||
- !ReadIPDLParam(aReader, aActor, &array->mExtraDatas)) {
+/* static */ bool IPC::ParamTraits<mozilla::ArrayOfRemoteMediaRawData*>::Read(
+ MessageReader* aReader, RefPtr<mozilla::ArrayOfRemoteMediaRawData>* aVar) {
+ auto array = mozilla::MakeRefPtr<mozilla::ArrayOfRemoteMediaRawData>();
+ if (!ReadParam(aReader, &array->mSamples) ||
+ !ReadParam(aReader, &array->mBuffers) ||
+ !ReadParam(aReader, &array->mAlphaBuffers) ||
+ !ReadParam(aReader, &array->mExtraDatas)) {
return false;
}
*aVar = std::move(array);
@@ -258,29 +260,29 @@ already_AddRefed<MediaRawData> ArrayOfRemoteMediaRawData::ElementAt(
}
/* static */ void
-ipc::IPDLParamTraits<ArrayOfRemoteMediaRawData::RemoteMediaRawData>::Write(
- IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- const paramType& aVar) {
- WriteIPDLParam(aWriter, aActor, aVar.mBase);
- WriteIPDLParam(aWriter, aActor, aVar.mEOS);
- WriteIPDLParam(aWriter, aActor, aVar.mHeight);
- WriteIPDLParam(aWriter, aActor, aVar.mTemporalLayerId);
- WriteIPDLParam(aWriter, aActor, aVar.mOriginalPresentationWindow);
- WriteIPDLParam(aWriter, aActor, aVar.mCryptoConfig);
+IPC::ParamTraits<mozilla::ArrayOfRemoteMediaRawData::RemoteMediaRawData>::Write(
+ MessageWriter* aWriter, const paramType& aVar) {
+ WriteParam(aWriter, aVar.mBase);
+ WriteParam(aWriter, aVar.mEOS);
+ WriteParam(aWriter, aVar.mHeight);
+ WriteParam(aWriter, aVar.mTemporalLayerId);
+ WriteParam(aWriter, aVar.mOriginalPresentationWindow);
+ WriteParam(aWriter, aVar.mCryptoConfig);
}
/* static */ bool
-ipc::IPDLParamTraits<ArrayOfRemoteMediaRawData::RemoteMediaRawData>::Read(
- IPC::MessageReader* aReader, ipc::IProtocol* aActor, paramType* aVar) {
- MediaDataIPDL mBase;
- return ReadIPDLParam(aReader, aActor, &aVar->mBase) &&
- ReadIPDLParam(aReader, aActor, &aVar->mEOS) &&
- ReadIPDLParam(aReader, aActor, &aVar->mHeight) &&
- ReadIPDLParam(aReader, aActor, &aVar->mTemporalLayerId) &&
- ReadIPDLParam(aReader, aActor, &aVar->mOriginalPresentationWindow) &&
- ReadIPDLParam(aReader, aActor, &aVar->mCryptoConfig);
+IPC::ParamTraits<mozilla::ArrayOfRemoteMediaRawData::RemoteMediaRawData>::Read(
+ MessageReader* aReader, paramType* aVar) {
+ mozilla::MediaDataIPDL mBase;
+ return ReadParam(aReader, &aVar->mBase) && ReadParam(aReader, &aVar->mEOS) &&
+ ReadParam(aReader, &aVar->mHeight) &&
+ ReadParam(aReader, &aVar->mTemporalLayerId) &&
+ ReadParam(aReader, &aVar->mOriginalPresentationWindow) &&
+ ReadParam(aReader, &aVar->mCryptoConfig);
};
+namespace mozilla {
+
bool ArrayOfRemoteAudioData::Fill(
const AudioData* aData, std::function<ShmemBuffer(size_t)>&& aAllocator) {
mSamples.AppendElement(RemoteAudioData{
@@ -344,19 +346,20 @@ already_AddRefed<AudioData> ArrayOfRemoteAudioData::ElementAt(
return audioData.forget();
}
-/*static */ void ipc::IPDLParamTraits<ArrayOfRemoteAudioData*>::Write(
- IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- ArrayOfRemoteAudioData* aVar) {
- WriteIPDLParam(aWriter, aActor, std::move(aVar->mSamples));
- WriteIPDLParam(aWriter, aActor, std::move(aVar->mBuffers));
+} // namespace mozilla
+
+/*static */ void IPC::ParamTraits<mozilla::ArrayOfRemoteAudioData*>::Write(
+ IPC::MessageWriter* aWriter, mozilla::ArrayOfRemoteAudioData* aVar) {
+ WriteParam(aWriter, std::move(aVar->mSamples));
+ WriteParam(aWriter, std::move(aVar->mBuffers));
}
-/* static */ bool ipc::IPDLParamTraits<ArrayOfRemoteAudioData*>::Read(
- IPC::MessageReader* aReader, mozilla::ipc::IProtocol* aActor,
- RefPtr<ArrayOfRemoteAudioData>* aVar) {
- auto array = MakeRefPtr<ArrayOfRemoteAudioData>();
- if (!ReadIPDLParam(aReader, aActor, &array->mSamples) ||
- !ReadIPDLParam(aReader, aActor, &array->mBuffers)) {
+/* static */ bool IPC::ParamTraits<mozilla::ArrayOfRemoteAudioData*>::Read(
+ IPC::MessageReader* aReader,
+ RefPtr<mozilla::ArrayOfRemoteAudioData>* aVar) {
+ auto array = mozilla::MakeRefPtr<mozilla::ArrayOfRemoteAudioData>();
+ if (!ReadParam(aReader, &array->mSamples) ||
+ !ReadParam(aReader, &array->mBuffers)) {
return false;
}
*aVar = std::move(array);
@@ -364,34 +367,28 @@ already_AddRefed<AudioData> ArrayOfRemoteAudioData::ElementAt(
}
/* static */ void
-ipc::IPDLParamTraits<ArrayOfRemoteAudioData::RemoteAudioData>::Write(
- IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- const paramType& aVar) {
- WriteIPDLParam(aWriter, aActor, aVar.mBase);
- WriteIPDLParam(aWriter, aActor, aVar.mChannels);
- WriteIPDLParam(aWriter, aActor, aVar.mRate);
- WriteIPDLParam(aWriter, aActor, aVar.mChannelMap);
- WriteIPDLParam(aWriter, aActor, aVar.mOriginalTime);
- WriteIPDLParam(aWriter, aActor, aVar.mTrimWindow);
- WriteIPDLParam(aWriter, aActor, aVar.mFrames);
- WriteIPDLParam(aWriter, aActor, aVar.mDataOffset);
+IPC::ParamTraits<mozilla::ArrayOfRemoteAudioData::RemoteAudioData>::Write(
+ IPC::MessageWriter* aWriter, const paramType& aVar) {
+ WriteParam(aWriter, aVar.mBase);
+ WriteParam(aWriter, aVar.mChannels);
+ WriteParam(aWriter, aVar.mRate);
+ WriteParam(aWriter, aVar.mChannelMap);
+ WriteParam(aWriter, aVar.mOriginalTime);
+ WriteParam(aWriter, aVar.mTrimWindow);
+ WriteParam(aWriter, aVar.mFrames);
+ WriteParam(aWriter, aVar.mDataOffset);
}
/* static */ bool
-ipc::IPDLParamTraits<ArrayOfRemoteAudioData::RemoteAudioData>::Read(
- IPC::MessageReader* aReader, ipc::IProtocol* aActor, paramType* aVar) {
- MediaDataIPDL mBase;
- if (!ReadIPDLParam(aReader, aActor, &aVar->mBase) ||
- !ReadIPDLParam(aReader, aActor, &aVar->mChannels) ||
- !ReadIPDLParam(aReader, aActor, &aVar->mRate) ||
- !ReadIPDLParam(aReader, aActor, &aVar->mChannelMap) ||
- !ReadIPDLParam(aReader, aActor, &aVar->mOriginalTime) ||
- !ReadIPDLParam(aReader, aActor, &aVar->mTrimWindow) ||
- !ReadIPDLParam(aReader, aActor, &aVar->mFrames) ||
- !ReadIPDLParam(aReader, aActor, &aVar->mDataOffset)) {
- return false;
- }
- return true;
+IPC::ParamTraits<mozilla::ArrayOfRemoteAudioData::RemoteAudioData>::Read(
+ IPC::MessageReader* aReader, paramType* aVar) {
+ mozilla::MediaDataIPDL mBase;
+ return ReadParam(aReader, &aVar->mBase) &&
+ ReadParam(aReader, &aVar->mChannels) &&
+ ReadParam(aReader, &aVar->mRate) &&
+ ReadParam(aReader, &aVar->mChannelMap) &&
+ ReadParam(aReader, &aVar->mOriginalTime) &&
+ ReadParam(aReader, &aVar->mTrimWindow) &&
+ ReadParam(aReader, &aVar->mFrames) &&
+ ReadParam(aReader, &aVar->mDataOffset);
};
-
-} // namespace mozilla
diff --git a/dom/media/ipc/RemoteMediaData.h b/dom/media/ipc/RemoteMediaData.h
@@ -62,7 +62,7 @@ class RemoteVideoData final {
const int32_t& frameID() const { return mFrameID; }
private:
- friend struct ipc::IPDLParamTraits<RemoteVideoData>;
+ friend struct IPC::ParamTraits<RemoteVideoData>;
MediaDataIPDL mBase;
IntSize mDisplay;
RemoteImageHolder mImage;
@@ -105,7 +105,7 @@ class ArrayOfRemoteVideoData final {
private:
~ArrayOfRemoteVideoData() = default;
- friend struct ipc::IPDLParamTraits<mozilla::ArrayOfRemoteVideoData*>;
+ friend struct IPC::ParamTraits<mozilla::ArrayOfRemoteVideoData*>;
nsTArray<RemoteVideoData> mArray;
};
@@ -196,7 +196,7 @@ class RemoteArrayOfByteBuffer {
virtual ~RemoteArrayOfByteBuffer();
private:
- friend struct ipc::IPDLParamTraits<RemoteArrayOfByteBuffer>;
+ friend struct IPC::ParamTraits<RemoteArrayOfByteBuffer>;
// Allocate shmem, false if an error occurred.
bool AllocateShmem(size_t aSize,
std::function<ShmemBuffer(size_t)>& aAllocator);
@@ -255,7 +255,7 @@ class ArrayOfRemoteMediaRawData {
};
private:
- friend struct ipc::IPDLParamTraits<ArrayOfRemoteMediaRawData*>;
+ friend struct IPC::ParamTraits<ArrayOfRemoteMediaRawData*>;
virtual ~ArrayOfRemoteMediaRawData() = default;
nsTArray<RemoteMediaRawData> mSamples;
@@ -290,7 +290,7 @@ class ArrayOfRemoteAudioData final {
bool IsValid() const { return mBuffers.IsValid(); }
struct RemoteAudioData {
- friend struct ipc::IPDLParamTraits<RemoteVideoData>;
+ friend struct IPC::ParamTraits<RemoteVideoData>;
MediaDataIPDL mBase;
uint32_t mChannels;
uint32_t mRate;
@@ -302,111 +302,95 @@ class ArrayOfRemoteAudioData final {
};
private:
- friend struct ipc::IPDLParamTraits<ArrayOfRemoteAudioData*>;
+ friend struct IPC::ParamTraits<ArrayOfRemoteAudioData*>;
~ArrayOfRemoteAudioData() = default;
nsTArray<RemoteAudioData> mSamples;
RemoteArrayOfByteBuffer mBuffers;
};
-namespace ipc {
+} // namespace mozilla
+
+namespace IPC {
template <>
-struct IPDLParamTraits<RemoteVideoData> {
- typedef RemoteVideoData paramType;
- static void Write(IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- paramType&& aVar) {
- WriteIPDLParam(aWriter, aActor, std::move(aVar.mBase));
- WriteIPDLParam(aWriter, aActor, std::move(aVar.mDisplay));
- WriteIPDLParam(aWriter, aActor, std::move(aVar.mImage));
+struct ParamTraits<mozilla::RemoteVideoData> {
+ using paramType = mozilla::RemoteVideoData;
+ static void Write(MessageWriter* aWriter, paramType&& aVar) {
+ WriteParam(aWriter, std::move(aVar.mBase));
+ WriteParam(aWriter, std::move(aVar.mDisplay));
+ WriteParam(aWriter, std::move(aVar.mImage));
aWriter->WriteBytes(&aVar.mFrameID, 4);
}
- static bool Read(IPC::MessageReader* aReader, mozilla::ipc::IProtocol* aActor,
- paramType* aVar) {
- if (!ReadIPDLParam(aReader, aActor, &aVar->mBase) ||
- !ReadIPDLParam(aReader, aActor, &aVar->mDisplay) ||
- !ReadIPDLParam(aReader, aActor, &aVar->mImage) ||
- !aReader->ReadBytesInto(&aVar->mFrameID, 4)) {
- return false;
- }
- return true;
+ static bool Read(IPC::MessageReader* aReader, paramType* aVar) {
+ return ReadParam(aReader, &aVar->mBase) &&
+ ReadParam(aReader, &aVar->mDisplay) &&
+ ReadParam(aReader, &aVar->mImage) &&
+ aReader->ReadBytesInto(&aVar->mFrameID, 4);
}
};
template <>
-struct IPDLParamTraits<ArrayOfRemoteVideoData*> {
- typedef ArrayOfRemoteVideoData paramType;
- static void Write(IPC::MessageWriter* aWriter,
- mozilla::ipc::IProtocol* aActor, paramType* aVar) {
- WriteIPDLParam(aWriter, aActor, std::move(aVar->mArray));
+struct ParamTraits<mozilla::ArrayOfRemoteVideoData*> {
+ using paramType = mozilla::ArrayOfRemoteVideoData;
+ static void Write(IPC::MessageWriter* aWriter, paramType* aVar) {
+ WriteParam(aWriter, std::move(aVar->mArray));
}
- static bool Read(IPC::MessageReader* aReader, ipc::IProtocol* aActor,
- RefPtr<paramType>* aVar) {
- nsTArray<RemoteVideoData> array;
- if (!ReadIPDLParam(aReader, aActor, &array)) {
+ static bool Read(IPC::MessageReader* aReader, RefPtr<paramType>* aVar) {
+ nsTArray<mozilla::RemoteVideoData> array;
+ if (!ReadParam(aReader, &array)) {
return false;
}
- auto results = MakeRefPtr<ArrayOfRemoteVideoData>(std::move(array));
+ auto results =
+ mozilla::MakeRefPtr<mozilla::ArrayOfRemoteVideoData>(std::move(array));
*aVar = std::move(results);
return true;
}
};
template <>
-struct IPDLParamTraits<RemoteArrayOfByteBuffer> {
- typedef RemoteArrayOfByteBuffer paramType;
+struct ParamTraits<mozilla::RemoteArrayOfByteBuffer> {
+ using paramType = mozilla::RemoteArrayOfByteBuffer;
// We do not want to move the RemoteArrayOfByteBuffer as we want to recycle
// the shmem it contains for another time.
- static void Write(IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- const paramType& aVar);
+ static void Write(IPC::MessageWriter* aWriter, const paramType& aVar);
- static bool Read(IPC::MessageReader* aReader, ipc::IProtocol* aActor,
- paramType* aVar);
+ static bool Read(IPC::MessageReader* aReader, paramType* aVar);
};
template <>
-struct IPDLParamTraits<ArrayOfRemoteMediaRawData::RemoteMediaRawData> {
- typedef ArrayOfRemoteMediaRawData::RemoteMediaRawData paramType;
- static void Write(IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- const paramType& aVar);
+struct ParamTraits<mozilla::ArrayOfRemoteMediaRawData::RemoteMediaRawData> {
+ using paramType = mozilla::ArrayOfRemoteMediaRawData::RemoteMediaRawData;
+ static void Write(MessageWriter* aWriter, const paramType& aVar);
- static bool Read(IPC::MessageReader* aReader, ipc::IProtocol* aActor,
- paramType* aVar);
+ static bool Read(MessageReader* aReader, paramType* aVar);
};
template <>
-struct IPDLParamTraits<ArrayOfRemoteMediaRawData*> {
- typedef ArrayOfRemoteMediaRawData paramType;
- static void Write(IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- paramType* aVar);
+struct ParamTraits<mozilla::ArrayOfRemoteMediaRawData*> {
+ using paramType = mozilla::ArrayOfRemoteMediaRawData;
+ static void Write(MessageWriter* aWriter, paramType* aVar);
- static bool Read(IPC::MessageReader* aReader, ipc::IProtocol* aActor,
- RefPtr<paramType>* aVar);
+ static bool Read(MessageReader* aReader, RefPtr<paramType>* aVar);
};
template <>
-struct IPDLParamTraits<ArrayOfRemoteAudioData::RemoteAudioData> {
- typedef ArrayOfRemoteAudioData::RemoteAudioData paramType;
- static void Write(IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- const paramType& aVar);
+struct ParamTraits<mozilla::ArrayOfRemoteAudioData::RemoteAudioData> {
+ using paramType = mozilla::ArrayOfRemoteAudioData::RemoteAudioData;
+ static void Write(MessageWriter* aWriter, const paramType& aVar);
- static bool Read(IPC::MessageReader* aReader, ipc::IProtocol* aActor,
- paramType* aVar);
+ static bool Read(MessageReader* aReader, paramType* aVar);
};
template <>
-struct IPDLParamTraits<ArrayOfRemoteAudioData*> {
- typedef ArrayOfRemoteAudioData paramType;
- static void Write(IPC::MessageWriter* aWriter, ipc::IProtocol* aActor,
- paramType* aVar);
+struct ParamTraits<mozilla::ArrayOfRemoteAudioData*> {
+ using paramType = mozilla::ArrayOfRemoteAudioData;
+ static void Write(MessageWriter* aWriter, paramType* aVar);
- static bool Read(IPC::MessageReader* aReader, ipc::IProtocol* aActor,
- RefPtr<paramType>* aVar);
+ static bool Read(MessageReader* aReader, RefPtr<paramType>* aVar);
};
-} // namespace ipc
-
-} // namespace mozilla
+} // namespace IPC
#endif // mozilla_dom_media_ipc_RemoteMediaData_h
diff --git a/dom/performance/PerformanceTiming.h b/dom/performance/PerformanceTiming.h
@@ -14,7 +14,6 @@
#include "mozilla/BasePrincipal.h"
#include "mozilla/StaticPrefs_dom.h"
#include "mozilla/dom/PerformanceTimingTypes.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/net/nsServerTiming.h"
#include "nsContentUtils.h"
#include "nsDOMNavigationTiming.h"
@@ -31,8 +30,7 @@ enum class RenderBlockingStatusType : uint8_t;
class PerformanceTimingData final : public CacheablePerformanceTimingData {
friend class PerformanceTiming;
- friend struct mozilla::ipc::IPDLParamTraits<
- mozilla::dom::PerformanceTimingData>;
+ friend struct IPC::ParamTraits<mozilla::dom::PerformanceTimingData>;
// https://w3c.github.io/resource-timing/#dom-performanceresourcetiming-transfersize
// The transferSize getter steps are to perform the following steps:
@@ -396,176 +394,103 @@ class PerformanceTiming final : public nsWrapperCache {
} // namespace mozilla::dom
-namespace mozilla::ipc {
+namespace IPC {
template <>
-struct IPDLParamTraits<mozilla::dom::PerformanceTimingData> {
+struct ParamTraits<mozilla::dom::PerformanceTimingData> {
using paramType = mozilla::dom::PerformanceTimingData;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mServerTiming);
- WriteIPDLParam(aWriter, aActor, aParam.mNextHopProtocol);
- WriteIPDLParam(aWriter, aActor, aParam.mAsyncOpen);
- WriteIPDLParam(aWriter, aActor, aParam.mRedirectStart);
- WriteIPDLParam(aWriter, aActor, aParam.mRedirectEnd);
- WriteIPDLParam(aWriter, aActor, aParam.mDomainLookupStart);
- WriteIPDLParam(aWriter, aActor, aParam.mDomainLookupEnd);
- WriteIPDLParam(aWriter, aActor, aParam.mConnectStart);
- WriteIPDLParam(aWriter, aActor, aParam.mSecureConnectionStart);
- WriteIPDLParam(aWriter, aActor, aParam.mConnectEnd);
- WriteIPDLParam(aWriter, aActor, aParam.mRequestStart);
- WriteIPDLParam(aWriter, aActor, aParam.mResponseStart);
- WriteIPDLParam(aWriter, aActor, aParam.mCacheReadStart);
- WriteIPDLParam(aWriter, aActor, aParam.mResponseEnd);
- WriteIPDLParam(aWriter, aActor, aParam.mCacheReadEnd);
- WriteIPDLParam(aWriter, aActor, aParam.mWorkerStart);
- WriteIPDLParam(aWriter, aActor, aParam.mWorkerRequestStart);
- WriteIPDLParam(aWriter, aActor, aParam.mWorkerResponseEnd);
- WriteIPDLParam(aWriter, aActor, aParam.mZeroTime);
- WriteIPDLParam(aWriter, aActor, aParam.mFetchStart);
- WriteIPDLParam(aWriter, aActor, aParam.mEncodedBodySize);
- WriteIPDLParam(aWriter, aActor, aParam.mTransferSize);
- WriteIPDLParam(aWriter, aActor, aParam.mDecodedBodySize);
- WriteIPDLParam(aWriter, aActor, aParam.mResponseStatus);
- WriteIPDLParam(aWriter, aActor, aParam.mRedirectCount);
- WriteIPDLParam(aWriter, aActor, aParam.mContentType);
- WriteIPDLParam(aWriter, aActor, aParam.mAllRedirectsSameOrigin);
- WriteIPDLParam(aWriter, aActor, aParam.mAllRedirectsPassTAO);
- WriteIPDLParam(aWriter, aActor, aParam.mSecureConnection);
- WriteIPDLParam(aWriter, aActor, aParam.mBodyInfoAccessAllowed);
- WriteIPDLParam(aWriter, aActor, aParam.mTimingAllowed);
- WriteIPDLParam(aWriter, aActor, aParam.mInitialized);
+ static void Write(IPC::MessageWriter* aWriter, const paramType& aParam) {
+ WriteParam(aWriter, aParam.mServerTiming);
+ WriteParam(aWriter, aParam.mNextHopProtocol);
+ WriteParam(aWriter, aParam.mAsyncOpen);
+ WriteParam(aWriter, aParam.mRedirectStart);
+ WriteParam(aWriter, aParam.mRedirectEnd);
+ WriteParam(aWriter, aParam.mDomainLookupStart);
+ WriteParam(aWriter, aParam.mDomainLookupEnd);
+ WriteParam(aWriter, aParam.mConnectStart);
+ WriteParam(aWriter, aParam.mSecureConnectionStart);
+ WriteParam(aWriter, aParam.mConnectEnd);
+ WriteParam(aWriter, aParam.mRequestStart);
+ WriteParam(aWriter, aParam.mResponseStart);
+ WriteParam(aWriter, aParam.mCacheReadStart);
+ WriteParam(aWriter, aParam.mResponseEnd);
+ WriteParam(aWriter, aParam.mCacheReadEnd);
+ WriteParam(aWriter, aParam.mWorkerStart);
+ WriteParam(aWriter, aParam.mWorkerRequestStart);
+ WriteParam(aWriter, aParam.mWorkerResponseEnd);
+ WriteParam(aWriter, aParam.mZeroTime);
+ WriteParam(aWriter, aParam.mFetchStart);
+ WriteParam(aWriter, aParam.mEncodedBodySize);
+ WriteParam(aWriter, aParam.mTransferSize);
+ WriteParam(aWriter, aParam.mDecodedBodySize);
+ WriteParam(aWriter, aParam.mResponseStatus);
+ WriteParam(aWriter, aParam.mRedirectCount);
+ WriteParam(aWriter, aParam.mContentType);
+ WriteParam(aWriter, aParam.mAllRedirectsSameOrigin);
+ WriteParam(aWriter, aParam.mAllRedirectsPassTAO);
+ WriteParam(aWriter, aParam.mSecureConnection);
+ WriteParam(aWriter, aParam.mBodyInfoAccessAllowed);
+ WriteParam(aWriter, aParam.mTimingAllowed);
+ WriteParam(aWriter, aParam.mInitialized);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mServerTiming)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mNextHopProtocol)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mAsyncOpen)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mRedirectStart)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mRedirectEnd)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mDomainLookupStart)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mDomainLookupEnd)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mConnectStart)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mSecureConnectionStart)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mConnectEnd)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mRequestStart)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mResponseStart)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mCacheReadStart)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mResponseEnd)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mCacheReadEnd)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mWorkerStart)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mWorkerRequestStart)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mWorkerResponseEnd)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mZeroTime)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mFetchStart)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mEncodedBodySize)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mTransferSize)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mDecodedBodySize)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mResponseStatus)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mRedirectCount)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mContentType)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mAllRedirectsSameOrigin)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mAllRedirectsPassTAO)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mSecureConnection)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mBodyInfoAccessAllowed)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mTimingAllowed)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mInitialized)) {
- return false;
- }
- return true;
+ static bool Read(IPC::MessageReader* aReader, paramType* aResult) {
+ return ReadParam(aReader, &aResult->mServerTiming) &&
+ ReadParam(aReader, &aResult->mNextHopProtocol) &&
+ ReadParam(aReader, &aResult->mAsyncOpen) &&
+ ReadParam(aReader, &aResult->mRedirectStart) &&
+ ReadParam(aReader, &aResult->mRedirectEnd) &&
+ ReadParam(aReader, &aResult->mDomainLookupStart) &&
+ ReadParam(aReader, &aResult->mDomainLookupEnd) &&
+ ReadParam(aReader, &aResult->mConnectStart) &&
+ ReadParam(aReader, &aResult->mSecureConnectionStart) &&
+ ReadParam(aReader, &aResult->mConnectEnd) &&
+ ReadParam(aReader, &aResult->mRequestStart) &&
+ ReadParam(aReader, &aResult->mResponseStart) &&
+ ReadParam(aReader, &aResult->mCacheReadStart) &&
+ ReadParam(aReader, &aResult->mResponseEnd) &&
+ ReadParam(aReader, &aResult->mCacheReadEnd) &&
+ ReadParam(aReader, &aResult->mWorkerStart) &&
+ ReadParam(aReader, &aResult->mWorkerRequestStart) &&
+ ReadParam(aReader, &aResult->mWorkerResponseEnd) &&
+ ReadParam(aReader, &aResult->mZeroTime) &&
+ ReadParam(aReader, &aResult->mFetchStart) &&
+ ReadParam(aReader, &aResult->mEncodedBodySize) &&
+ ReadParam(aReader, &aResult->mTransferSize) &&
+ ReadParam(aReader, &aResult->mDecodedBodySize) &&
+ ReadParam(aReader, &aResult->mResponseStatus) &&
+ ReadParam(aReader, &aResult->mRedirectCount) &&
+ ReadParam(aReader, &aResult->mContentType) &&
+ ReadParam(aReader, &aResult->mAllRedirectsSameOrigin) &&
+ ReadParam(aReader, &aResult->mAllRedirectsPassTAO) &&
+ ReadParam(aReader, &aResult->mSecureConnection) &&
+ ReadParam(aReader, &aResult->mBodyInfoAccessAllowed) &&
+ ReadParam(aReader, &aResult->mTimingAllowed) &&
+ ReadParam(aReader, &aResult->mInitialized);
}
};
template <>
-struct IPDLParamTraits<nsIServerTiming*> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- nsIServerTiming* aParam) {
+struct ParamTraits<nsIServerTiming*> {
+ static void Write(IPC::MessageWriter* aWriter, nsIServerTiming* aParam) {
nsAutoCString name;
(void)aParam->GetName(name);
double duration = 0;
(void)aParam->GetDuration(&duration);
nsAutoCString description;
(void)aParam->GetDescription(description);
- WriteIPDLParam(aWriter, aActor, name);
- WriteIPDLParam(aWriter, aActor, duration);
- WriteIPDLParam(aWriter, aActor, description);
+ WriteParam(aWriter, name);
+ WriteParam(aWriter, duration);
+ WriteParam(aWriter, description);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+ static bool Read(IPC::MessageReader* aReader,
RefPtr<nsIServerTiming>* aResult) {
nsAutoCString name;
double duration;
nsAutoCString description;
- if (!ReadIPDLParam(aReader, aActor, &name)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &duration)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &description)) {
+ if (!ReadParam(aReader, &name) || !ReadParam(aReader, &duration) ||
+ !ReadParam(aReader, &description)) {
return false;
}
@@ -578,6 +503,6 @@ struct IPDLParamTraits<nsIServerTiming*> {
}
};
-} // namespace mozilla::ipc
+} // namespace IPC
#endif // mozilla_dom_PerformanceTiming_h
diff --git a/dom/security/featurepolicy/FeaturePolicyUtils.cpp b/dom/security/featurepolicy/FeaturePolicyUtils.cpp
@@ -6,13 +6,13 @@
#include "FeaturePolicyUtils.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
#include "mozilla/StaticPrefs_dom.h"
#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/FeaturePolicyViolationReportBody.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/ReportingUtils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "nsContentUtils.h"
#include "nsIOService.h"
#include "nsJSUtils.h"
@@ -245,50 +245,28 @@ void FeaturePolicyUtils::ReportViolation(Document* aDocument,
}
} // namespace dom
+} // namespace mozilla
-namespace ipc {
-
-void IPDLParamTraits<dom::FeaturePolicyInfo>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor,
- const dom::FeaturePolicyInfo& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mInheritedDeniedFeatureNames);
- WriteIPDLParam(aWriter, aActor, aParam.mAttributeEnabledFeatureNames);
- WriteIPDLParam(aWriter, aActor, aParam.mDeclaredString);
- WriteIPDLParam(aWriter, aActor, aParam.mDefaultOrigin);
- WriteIPDLParam(aWriter, aActor, aParam.mSelfOrigin);
- WriteIPDLParam(aWriter, aActor, aParam.mSrcOrigin);
-}
-
-bool IPDLParamTraits<dom::FeaturePolicyInfo>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor,
- dom::FeaturePolicyInfo* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mInheritedDeniedFeatureNames)) {
- return false;
- }
-
- if (!ReadIPDLParam(aReader, aActor,
- &aResult->mAttributeEnabledFeatureNames)) {
- return false;
- }
-
- if (!ReadIPDLParam(aReader, aActor, &aResult->mDeclaredString)) {
- return false;
- }
-
- if (!ReadIPDLParam(aReader, aActor, &aResult->mDefaultOrigin)) {
- return false;
- }
-
- if (!ReadIPDLParam(aReader, aActor, &aResult->mSelfOrigin)) {
- return false;
- }
+namespace IPC {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mSrcOrigin)) {
- return false;
- }
+void ParamTraits<mozilla::dom::FeaturePolicyInfo>::Write(
+ MessageWriter* aWriter, const mozilla::dom::FeaturePolicyInfo& aParam) {
+ WriteParam(aWriter, aParam.mInheritedDeniedFeatureNames);
+ WriteParam(aWriter, aParam.mAttributeEnabledFeatureNames);
+ WriteParam(aWriter, aParam.mDeclaredString);
+ WriteParam(aWriter, aParam.mDefaultOrigin);
+ WriteParam(aWriter, aParam.mSelfOrigin);
+ WriteParam(aWriter, aParam.mSrcOrigin);
+}
- return true;
+bool ParamTraits<mozilla::dom::FeaturePolicyInfo>::Read(
+ MessageReader* aReader, mozilla::dom::FeaturePolicyInfo* aResult) {
+ return ReadParam(aReader, &aResult->mInheritedDeniedFeatureNames) &&
+ ReadParam(aReader, &aResult->mAttributeEnabledFeatureNames) &&
+ ReadParam(aReader, &aResult->mDeclaredString) &&
+ ReadParam(aReader, &aResult->mDefaultOrigin) &&
+ ReadParam(aReader, &aResult->mSelfOrigin) &&
+ ReadParam(aReader, &aResult->mSrcOrigin);
}
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
diff --git a/dom/security/featurepolicy/FeaturePolicyUtils.h b/dom/security/featurepolicy/FeaturePolicyUtils.h
@@ -69,23 +69,21 @@ class FeaturePolicyUtils final {
};
} // namespace dom
+} // namespace mozilla
-namespace ipc {
-
-class IProtocol;
+namespace IPC {
template <typename T>
-struct IPDLParamTraits;
+struct ParamTraits;
template <>
-struct IPDLParamTraits<dom::FeaturePolicyInfo> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
+struct ParamTraits<mozilla::dom::FeaturePolicyInfo> {
+ static void Write(MessageWriter* aWriter,
const mozilla::dom::FeaturePolicyInfo& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- dom::FeaturePolicyInfo* aResult);
+ static bool Read(MessageReader* aReader,
+ mozilla::dom::FeaturePolicyInfo* aResult);
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif // mozilla_dom_FeaturePolicyUtils_h
diff --git a/dom/webgpu/ipc/WebGPUTypes.h b/dom/webgpu/ipc/WebGPUTypes.h
@@ -12,7 +12,6 @@
#include "mozilla/Maybe.h"
#include "mozilla/ParamTraits_STL.h"
#include "mozilla/dom/BindingDeclarations.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/layers/LayersSurfaces.h"
#include "nsString.h"
diff --git a/gfx/ipc/CrossProcessPaint.h b/gfx/ipc/CrossProcessPaint.h
@@ -83,7 +83,7 @@ class PaintFragment final {
PaintFragment& operator=(PaintFragment&&) = default;
protected:
- friend struct mozilla::ipc::IPDLParamTraits<PaintFragment>;
+ friend struct IPC::ParamTraits<PaintFragment>;
friend CrossProcessPaint;
typedef mozilla::ipc::ByteBuf ByteBuf;
diff --git a/gfx/ipc/FileHandleWrapper.h b/gfx/ipc/FileHandleWrapper.h
@@ -10,13 +10,12 @@
#include "mozilla/UniquePtrExtensions.h"
#include "nsISupportsImpl.h"
-namespace mozilla {
-
-namespace ipc {
-template <typename T>
-struct IPDLParamTraits;
-} // namespace ipc
+namespace IPC {
+template <typename P>
+struct ParamTraits;
+}
+namespace mozilla {
namespace gfx {
//
@@ -26,7 +25,7 @@ namespace gfx {
// could reduce the number of shared handles in a process.
//
class FileHandleWrapper {
- friend struct mozilla::ipc::IPDLParamTraits<gfx::FileHandleWrapper*>;
+ friend struct IPC::ParamTraits<gfx::FileHandleWrapper*>;
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(FileHandleWrapper);
diff --git a/gfx/ipc/GfxMessageUtils.h b/gfx/ipc/GfxMessageUtils.h
@@ -30,7 +30,6 @@
#include "nsRegion.h"
#include "mozilla/Array.h"
#include "mozilla/ipc/FileDescriptor.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
@@ -1238,20 +1237,19 @@ struct ParamTraits<mozilla::fontlist::Pointer> {
}
};
-} // namespace IPC
-
-namespace mozilla {
-namespace ipc {
-
template <>
-struct IPDLParamTraits<gfx::PaintFragment> {
+struct ParamTraits<mozilla::gfx::PaintFragment> {
typedef mozilla::gfx::PaintFragment paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- paramType&& aParam) {
- Shmem shmem;
+ static void Write(IPC::MessageWriter* aWriter, paramType&& aParam) {
+ if (!aWriter->GetActor()) {
+ aWriter->FatalError("Need an actor");
+ return;
+ }
+
+ mozilla::ipc::Shmem shmem;
if (aParam.mSize.IsEmpty() ||
- !aActor->AllocShmem(aParam.mRecording.mLen, &shmem)) {
- WriteParam(aWriter, gfx::IntSize(0, 0));
+ !aWriter->GetActor()->AllocShmem(aParam.mRecording.mLen, &shmem)) {
+ WriteParam(aWriter, mozilla::gfx::IntSize(0, 0));
return;
}
@@ -1259,57 +1257,59 @@ struct IPDLParamTraits<gfx::PaintFragment> {
aParam.mRecording.mLen);
WriteParam(aWriter, aParam.mSize);
- WriteIPDLParam(aWriter, aActor, std::move(shmem));
+ WriteParam(aWriter, std::move(shmem));
WriteParam(aWriter, aParam.mDependencies);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
+ static bool Read(IPC::MessageReader* aReader, paramType* aResult) {
+ if (!aReader->GetActor()) {
+ return false;
+ }
if (!ReadParam(aReader, &aResult->mSize)) {
return false;
}
if (aResult->mSize.IsEmpty()) {
return true;
}
- Shmem shmem;
- if (!ReadIPDLParam(aReader, aActor, &shmem) ||
+ mozilla::ipc::Shmem shmem;
+ if (!ReadParam(aReader, &shmem) ||
!ReadParam(aReader, &aResult->mDependencies)) {
- aActor->DeallocShmem(shmem);
+ aReader->GetActor()->DeallocShmem(shmem);
return false;
}
if (!aResult->mRecording.Allocate(shmem.Size<uint8_t>())) {
aResult->mSize.SizeTo(0, 0);
- aActor->DeallocShmem(shmem);
+ aReader->GetActor()->DeallocShmem(shmem);
return true;
}
memcpy(aResult->mRecording.mData, shmem.get<uint8_t>(),
shmem.Size<uint8_t>());
- aActor->DeallocShmem(shmem);
+ aReader->GetActor()->DeallocShmem(shmem);
return true;
}
};
template <>
-struct IPDLParamTraits<gfx::FileHandleWrapper*> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- gfx::FileHandleWrapper* aParam) {
+struct ParamTraits<mozilla::gfx::FileHandleWrapper*> {
+ static void Write(MessageWriter* aWriter,
+ mozilla::gfx::FileHandleWrapper* aParam) {
if (!aParam) {
- WriteIPDLParam(aWriter, aActor, false);
+ WriteParam(aWriter, false);
return;
}
- WriteIPDLParam(aWriter, aActor, true);
+ WriteParam(aWriter, true);
mozilla::ipc::FileDescriptor desc(aParam->GetHandle());
- WriteIPDLParam(aWriter, aActor, desc);
+ WriteParam(aWriter, desc);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- RefPtr<gfx::FileHandleWrapper>* aResult) {
+ static bool Read(MessageReader* aReader,
+ RefPtr<mozilla::gfx::FileHandleWrapper>* aResult) {
*aResult = nullptr;
bool notnull = false;
- if (!ReadIPDLParam(aReader, aActor, ¬null)) {
+ if (!ReadParam(aReader, ¬null)) {
return false;
}
@@ -1318,17 +1318,16 @@ struct IPDLParamTraits<gfx::FileHandleWrapper*> {
}
mozilla::ipc::FileDescriptor desc;
- if (!ReadIPDLParam(aReader, aActor, &desc)) {
+ if (!ReadParam(aReader, &desc)) {
return false;
}
- auto wrapper =
- MakeRefPtr<gfx::FileHandleWrapper>(desc.TakePlatformHandle());
+ auto wrapper = mozilla::MakeRefPtr<mozilla::gfx::FileHandleWrapper>(
+ desc.TakePlatformHandle());
*aResult = std::move(wrapper);
return true;
}
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif /* __GFXMESSAGEUTILS_H__ */
diff --git a/gfx/layers/ipc/LayersMessageUtils.h b/gfx/layers/ipc/LayersMessageUtils.h
@@ -1229,26 +1229,20 @@ struct ParamTraits<mozilla::layers::CompositorScrollUpdate> {
}
};
-} /* namespace IPC */
-
-namespace mozilla {
-namespace ipc {
-
template <>
-struct IPDLParamTraits<layers::GpuFence*> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- layers::GpuFence* aParam) {
+struct ParamTraits<mozilla::layers::GpuFence*> {
+ static void Write(MessageWriter* aWriter, mozilla::layers::GpuFence* aParam) {
if (aParam) {
MOZ_ASSERT_UNREACHABLE("unexpected to be called");
}
- WriteIPDLParam(aWriter, aActor, false);
+ WriteParam(aWriter, false);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- RefPtr<layers::GpuFence>* aResult) {
+ static bool Read(MessageReader* aReader,
+ RefPtr<mozilla::layers::GpuFence>* aResult) {
*aResult = nullptr;
bool notnull = false;
- if (!ReadIPDLParam(aReader, aActor, ¬null)) {
+ if (!ReadParam(aReader, ¬null)) {
return false;
}
@@ -1261,8 +1255,7 @@ struct IPDLParamTraits<layers::GpuFence*> {
}
};
-} // namespace ipc
-} // namespace mozilla
+} /* namespace IPC */
#define DEFINE_SERVO_PARAMTRAITS(ty_) \
MOZ_DEFINE_RUST_PARAMTRAITS(mozilla::ty_, Servo_##ty_##_Serialize, \
diff --git a/gfx/layers/wr/RenderRootTypes.cpp b/gfx/layers/wr/RenderRootTypes.cpp
@@ -8,67 +8,64 @@
#include "mozilla/layers/WebRenderMessageUtils.h"
#include "mozilla/layers/WebRenderBridgeChild.h"
-namespace mozilla {
-namespace ipc {
+using namespace mozilla::layers;
-void IPDLParamTraits<mozilla::layers::DisplayListData>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor, paramType&& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mIdNamespace);
- WriteIPDLParam(aWriter, aActor, aParam.mRect);
- WriteIPDLParam(aWriter, aActor, aParam.mCommands);
- WriteIPDLParam(aWriter, aActor, std::move(aParam.mDLItems));
- WriteIPDLParam(aWriter, aActor, std::move(aParam.mDLCache));
- WriteIPDLParam(aWriter, aActor, std::move(aParam.mDLSpatialTree));
- WriteIPDLParam(aWriter, aActor, aParam.mDLDesc);
- WriteIPDLParam(aWriter, aActor, aParam.mResourceUpdates);
- WriteIPDLParam(aWriter, aActor, aParam.mSmallShmems);
- WriteIPDLParam(aWriter, aActor, std::move(aParam.mLargeShmems));
- WriteIPDLParam(aWriter, aActor, aParam.mScrollData);
+namespace IPC {
+
+void ParamTraits<DisplayListData>::Write(IPC::MessageWriter* aWriter,
+ paramType&& aParam) {
+ WriteParam(aWriter, aParam.mIdNamespace);
+ WriteParam(aWriter, aParam.mRect);
+ WriteParam(aWriter, aParam.mCommands);
+ WriteParam(aWriter, std::move(aParam.mDLItems));
+ WriteParam(aWriter, std::move(aParam.mDLCache));
+ WriteParam(aWriter, std::move(aParam.mDLSpatialTree));
+ WriteParam(aWriter, aParam.mDLDesc);
+ WriteParam(aWriter, aParam.mResourceUpdates);
+ WriteParam(aWriter, aParam.mSmallShmems);
+ WriteParam(aWriter, std::move(aParam.mLargeShmems));
+ WriteParam(aWriter, aParam.mScrollData);
}
-bool IPDLParamTraits<mozilla::layers::DisplayListData>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor, paramType* aResult) {
- if (ReadIPDLParam(aReader, aActor, &aResult->mIdNamespace) &&
- ReadIPDLParam(aReader, aActor, &aResult->mRect) &&
- ReadIPDLParam(aReader, aActor, &aResult->mCommands) &&
- ReadIPDLParam(aReader, aActor, &aResult->mDLItems) &&
- ReadIPDLParam(aReader, aActor, &aResult->mDLCache) &&
- ReadIPDLParam(aReader, aActor, &aResult->mDLSpatialTree) &&
- ReadIPDLParam(aReader, aActor, &aResult->mDLDesc) &&
- ReadIPDLParam(aReader, aActor, &aResult->mResourceUpdates) &&
- ReadIPDLParam(aReader, aActor, &aResult->mSmallShmems) &&
- ReadIPDLParam(aReader, aActor, &aResult->mLargeShmems) &&
- ReadIPDLParam(aReader, aActor, &aResult->mScrollData)) {
- return true;
- }
- return false;
+bool ParamTraits<DisplayListData>::Read(IPC::MessageReader* aReader,
+ paramType* aResult) {
+ return ReadParam(aReader, &aResult->mIdNamespace) &&
+ ReadParam(aReader, &aResult->mRect) &&
+ ReadParam(aReader, &aResult->mCommands) &&
+ ReadParam(aReader, &aResult->mDLItems) &&
+ ReadParam(aReader, &aResult->mDLCache) &&
+ ReadParam(aReader, &aResult->mDLSpatialTree) &&
+ ReadParam(aReader, &aResult->mDLDesc) &&
+ ReadParam(aReader, &aResult->mResourceUpdates) &&
+ ReadParam(aReader, &aResult->mSmallShmems) &&
+ ReadParam(aReader, &aResult->mLargeShmems) &&
+ ReadParam(aReader, &aResult->mScrollData);
}
-void WriteScrollUpdates(IPC::MessageWriter* aWriter, IProtocol* aActor,
- layers::ScrollUpdatesMap& aParam) {
+static void WriteScrollUpdates(IPC::MessageWriter* aWriter,
+ ScrollUpdatesMap& aParam) {
// ICK: we need to manually serialize this map because
// nsTHashMap doesn't support it (and other maps cause other issues)
- WriteIPDLParam(aWriter, aActor, aParam.Count());
+ WriteParam(aWriter, aParam.Count());
for (auto it = aParam.ConstIter(); !it.Done(); it.Next()) {
- WriteIPDLParam(aWriter, aActor, it.Key());
- WriteIPDLParam(aWriter, aActor, it.Data());
+ WriteParam(aWriter, it.Key());
+ WriteParam(aWriter, it.Data());
}
}
-bool ReadScrollUpdates(IPC::MessageReader* aReader, IProtocol* aActor,
- layers::ScrollUpdatesMap* aResult) {
+static bool ReadScrollUpdates(IPC::MessageReader* aReader,
+ ScrollUpdatesMap* aResult) {
// Manually deserialize mScrollUpdates as a stream of K,V pairs
uint32_t count;
- if (!ReadIPDLParam(aReader, aActor, &count)) {
+ if (!ReadParam(aReader, &count)) {
return false;
}
- layers::ScrollUpdatesMap map(count);
+ ScrollUpdatesMap map(count);
for (size_t i = 0; i < count; ++i) {
- layers::ScrollableLayerGuid::ViewID key;
+ ScrollableLayerGuid::ViewID key;
nsTArray<mozilla::ScrollPositionUpdate> data;
- if (!ReadIPDLParam(aReader, aActor, &key) ||
- !ReadIPDLParam(aReader, aActor, &data)) {
+ if (!ReadParam(aReader, &key) || !ReadParam(aReader, &data)) {
return false;
}
map.InsertOrUpdate(key, std::move(data));
@@ -79,30 +76,26 @@ bool ReadScrollUpdates(IPC::MessageReader* aReader, IProtocol* aActor,
return true;
}
-void IPDLParamTraits<mozilla::layers::TransactionData>::Write(
- IPC::MessageWriter* aWriter, IProtocol* aActor, paramType&& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mIdNamespace);
- WriteIPDLParam(aWriter, aActor, aParam.mCommands);
- WriteIPDLParam(aWriter, aActor, aParam.mResourceUpdates);
- WriteIPDLParam(aWriter, aActor, aParam.mSmallShmems);
- WriteIPDLParam(aWriter, aActor, std::move(aParam.mLargeShmems));
- WriteScrollUpdates(aWriter, aActor, aParam.mScrollUpdates);
- WriteIPDLParam(aWriter, aActor, aParam.mPaintSequenceNumber);
+void ParamTraits<TransactionData>::Write(IPC::MessageWriter* aWriter,
+ paramType&& aParam) {
+ WriteParam(aWriter, aParam.mIdNamespace);
+ WriteParam(aWriter, aParam.mCommands);
+ WriteParam(aWriter, aParam.mResourceUpdates);
+ WriteParam(aWriter, aParam.mSmallShmems);
+ WriteParam(aWriter, std::move(aParam.mLargeShmems));
+ WriteScrollUpdates(aWriter, aParam.mScrollUpdates);
+ WriteParam(aWriter, aParam.mPaintSequenceNumber);
}
-bool IPDLParamTraits<mozilla::layers::TransactionData>::Read(
- IPC::MessageReader* aReader, IProtocol* aActor, paramType* aResult) {
- if (ReadIPDLParam(aReader, aActor, &aResult->mIdNamespace) &&
- ReadIPDLParam(aReader, aActor, &aResult->mCommands) &&
- ReadIPDLParam(aReader, aActor, &aResult->mResourceUpdates) &&
- ReadIPDLParam(aReader, aActor, &aResult->mSmallShmems) &&
- ReadIPDLParam(aReader, aActor, &aResult->mLargeShmems) &&
- ReadScrollUpdates(aReader, aActor, &aResult->mScrollUpdates) &&
- ReadIPDLParam(aReader, aActor, &aResult->mPaintSequenceNumber)) {
- return true;
- }
- return false;
+bool ParamTraits<TransactionData>::Read(IPC::MessageReader* aReader,
+ paramType* aResult) {
+ return ReadParam(aReader, &aResult->mIdNamespace) &&
+ ReadParam(aReader, &aResult->mCommands) &&
+ ReadParam(aReader, &aResult->mResourceUpdates) &&
+ ReadParam(aReader, &aResult->mSmallShmems) &&
+ ReadParam(aReader, &aResult->mLargeShmems) &&
+ ReadScrollUpdates(aReader, &aResult->mScrollUpdates) &&
+ ReadParam(aReader, &aResult->mPaintSequenceNumber);
}
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
diff --git a/gfx/layers/wr/RenderRootTypes.h b/gfx/layers/wr/RenderRootTypes.h
@@ -43,32 +43,28 @@ struct TransactionData {
typedef Maybe<TransactionData> MaybeTransactionData;
} // namespace layers
+} // namespace mozilla
-namespace ipc {
+namespace IPC {
template <>
-struct IPDLParamTraits<mozilla::layers::DisplayListData> {
+struct ParamTraits<mozilla::layers::DisplayListData> {
typedef mozilla::layers::DisplayListData paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- paramType&& aParam);
+ static void Write(MessageWriter* aWriter, paramType&& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult);
+ static bool Read(MessageReader* aReader, paramType* aResult);
};
template <>
-struct IPDLParamTraits<mozilla::layers::TransactionData> {
+struct ParamTraits<mozilla::layers::TransactionData> {
typedef mozilla::layers::TransactionData paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- paramType&& aParam);
+ static void Write(MessageWriter* aWriter, paramType&& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult);
+ static bool Read(MessageReader* aReader, paramType* aResult);
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif /* GFX_RENDERROOTTYPES_H */
diff --git a/ipc/chromium/src/chrome/common/ipc_message_utils.h b/ipc/chromium/src/chrome/common/ipc_message_utils.h
@@ -32,8 +32,6 @@ class nsCOMPtr;
namespace mozilla::ipc {
class IProtocol;
-template <typename P>
-struct IPDLParamTraits;
namespace shared_memory {
class Cursor;
}
@@ -704,34 +702,10 @@ template <typename P, typename F>
return ReadSequenceParamImpl<P>(reader, allocator(length), length);
}
-// Temporary fallback class to allow types to declare serialization using the
-// IPDLParamTraits type class. Will be removed once all remaining
-// IPDLParamTraits implementations are gone. (bug 1754009)
-
-template <class P>
-struct ParamTraitsIPDLFallback {
- template <class R>
- static auto Write(MessageWriter* writer, R&& p)
- -> decltype(mozilla::ipc::IPDLParamTraits<P>::Write(writer,
- writer->GetActor(),
- std::forward<R>(p))) {
- mozilla::ipc::IPDLParamTraits<P>::Write(writer, writer->GetActor(),
- std::forward<R>(p));
- }
- template <class R>
- static auto Read(MessageReader* reader, R* r)
- -> decltype(mozilla::ipc::IPDLParamTraits<P>::Read(reader,
- reader->GetActor(),
- r)) {
- return mozilla::ipc::IPDLParamTraits<P>::Read(reader, reader->GetActor(),
- r);
- }
-};
-
// Fundamental types.
template <class P>
-struct ParamTraitsFundamental : ParamTraitsIPDLFallback<P> {};
+struct ParamTraitsFundamental;
template <>
struct ParamTraitsFundamental<bool> {
@@ -1187,8 +1161,13 @@ struct ParamTraitsMozilla<nsresult> {
}
};
-// See comments for the IPDLParamTraits specializations for RefPtr<T> and
-// nsCOMPtr<T> for more details.
+// When being passed `RefPtr<T>` or `nsCOMPtr<T>`, forward to a specialization
+// for the underlying target type. The parameter type will be passed as `T*`,
+// and result as `RefPtr<T>*`.
+//
+// This is done explicitly to ensure that the deleted `&&` overload for
+// `operator T*` is not selected in generic contexts, and to support
+// deserializing into `nsCOMPtr<T>`.
template <class T>
struct ParamTraitsMozilla<RefPtr<T>> {
static void Write(MessageWriter* writer, const RefPtr<T>& p) {
diff --git a/ipc/docs/ipdl.rst b/ipc/docs/ipdl.rst
@@ -923,11 +923,9 @@ advanced use is beyond the scope of this document.
annotation. See `Actors and Messages in C++`_ for more.
.. note::
- In the past, it was required to specialize ``mozilla::ipc::IPDLParamTraits<T>``
- instead of ``IPC::ParamTraits<T>`` if you needed the actor object itself during
- serialization or deserialization. These days the actor can be fetched using
- ``IPC::Message{Reader,Writer}::GetActor()`` in ``IPC::ParamTraits``, so that
- trait should be used for all new serializations.
+ If you need to access the actor object during serialization, use
+ ``IPC::Message{Reader,Writer}::GetActor()``. This should be null-checked, as
+ it may not be set if an actor is unavailable.
A special case worth mentioning is that of enums. Enums are a common source of
security holes since code is rarely safe with enum values that are not valid.
diff --git a/ipc/glue/Endpoint.cpp b/ipc/glue/Endpoint.cpp
@@ -6,7 +6,7 @@
#include "mozilla/ipc/Endpoint.h"
#include "chrome/common/ipc_message.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsThreadUtils.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
@@ -95,12 +95,15 @@ bool UntypedManagedEndpoint::BindCommon(IProtocol* aActor,
return true;
}
+} // namespace mozilla::ipc
+
+namespace IPC {
+
/* static */
-void IPDLParamTraits<UntypedManagedEndpoint>::Write(IPC::MessageWriter* aWriter,
- IProtocol* aActor,
- paramType&& aParam) {
+void ParamTraits<mozilla::ipc::UntypedManagedEndpoint>::Write(
+ MessageWriter* aWriter, paramType&& aParam) {
bool isValid = aParam.mInner.isSome();
- WriteIPDLParam(aWriter, aActor, isValid);
+ WriteParam(aWriter, isValid);
if (!isValid) {
return;
}
@@ -111,24 +114,23 @@ void IPDLParamTraits<UntypedManagedEndpoint>::Write(IPC::MessageWriter* aWriter,
MOZ_RELEASE_ASSERT(inner.mOtherSide, "Has not been sent over IPC yet");
MOZ_RELEASE_ASSERT(inner.mOtherSide->ActorEventTarget()->IsOnCurrentThread(),
"Must be being sent from the correct thread");
- MOZ_RELEASE_ASSERT(
- inner.mOtherSide->Get() && inner.mOtherSide->Get()->ToplevelProtocol() ==
- aActor->ToplevelProtocol(),
- "Must be being sent over the same toplevel protocol");
-
- WriteIPDLParam(aWriter, aActor, inner.mId);
- WriteIPDLParam(aWriter, aActor, inner.mType);
- WriteIPDLParam(aWriter, aActor, inner.mManagerId);
- WriteIPDLParam(aWriter, aActor, inner.mManagerType);
+ MOZ_RELEASE_ASSERT(inner.mOtherSide->Get() && aWriter->GetActor() &&
+ inner.mOtherSide->Get()->ToplevelProtocol() ==
+ aWriter->GetActor()->ToplevelProtocol(),
+ "Must be being sent over the same toplevel protocol");
+
+ WriteParam(aWriter, inner.mId);
+ WriteParam(aWriter, inner.mType);
+ WriteParam(aWriter, inner.mManagerId);
+ WriteParam(aWriter, inner.mManagerType);
}
/* static */
-bool IPDLParamTraits<UntypedManagedEndpoint>::Read(IPC::MessageReader* aReader,
- IProtocol* aActor,
- paramType* aResult) {
- *aResult = UntypedManagedEndpoint{};
+bool ParamTraits<mozilla::ipc::UntypedManagedEndpoint>::Read(
+ MessageReader* aReader, paramType* aResult) {
+ *aResult = mozilla::ipc::UntypedManagedEndpoint{};
bool isValid = false;
- if (!aActor || !ReadIPDLParam(aReader, aActor, &isValid)) {
+ if (!aReader->GetActor() || !ReadParam(aReader, &isValid)) {
return false;
}
if (!isValid) {
@@ -137,17 +139,13 @@ bool IPDLParamTraits<UntypedManagedEndpoint>::Read(IPC::MessageReader* aReader,
aResult->mInner.emplace();
auto& inner = *aResult->mInner;
- inner.mToplevel = aActor->ToplevelProtocol()->GetWeakLifecycleProxy();
- return ReadIPDLParam(aReader, aActor, &inner.mId) &&
- ReadIPDLParam(aReader, aActor, &inner.mType) &&
- ReadIPDLParam(aReader, aActor, &inner.mManagerId) &&
- ReadIPDLParam(aReader, aActor, &inner.mManagerType);
+ inner.mToplevel =
+ aReader->GetActor()->ToplevelProtocol()->GetWeakLifecycleProxy();
+ return ReadParam(aReader, &inner.mId) && ReadParam(aReader, &inner.mType) &&
+ ReadParam(aReader, &inner.mManagerId) &&
+ ReadParam(aReader, &inner.mManagerType);
}
-} // namespace mozilla::ipc
-
-namespace IPC {
-
void ParamTraits<mozilla::ipc::UntypedEndpoint>::Write(MessageWriter* aWriter,
paramType&& aParam) {
IPC::WriteParam(aWriter, std::move(aParam.mPort));
diff --git a/ipc/glue/Endpoint.h b/ipc/glue/Endpoint.h
@@ -219,7 +219,7 @@ class UntypedManagedEndpoint {
bool BindCommon(IProtocol* aActor, IRefCountedProtocol* aManager);
private:
- friend struct IPDLParamTraits<UntypedManagedEndpoint>;
+ friend struct IPC::ParamTraits<UntypedManagedEndpoint>;
struct Inner {
// Pointers to the toplevel actor which will manage this connection. When
diff --git a/ipc/glue/FileDescriptor.cpp b/ipc/glue/FileDescriptor.cpp
@@ -6,7 +6,6 @@
#include "FileDescriptor.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "nsDebug.h"
@@ -91,26 +90,28 @@ FileDescriptor::UniquePlatformHandle FileDescriptor::Clone(
return UniqueFileHandle();
}
-void IPDLParamTraits<FileDescriptor>::Write(IPC::MessageWriter* aWriter,
- IProtocol* aActor,
- const FileDescriptor& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.ClonePlatformHandle());
+} // namespace ipc
+} // namespace mozilla
+
+namespace IPC {
+
+void ParamTraits<mozilla::ipc::FileDescriptor>::Write(
+ MessageWriter* aWriter, const mozilla::ipc::FileDescriptor& aParam) {
+ WriteParam(aWriter, aParam.ClonePlatformHandle());
}
-bool IPDLParamTraits<FileDescriptor>::Read(IPC::MessageReader* aReader,
- IProtocol* aActor,
- FileDescriptor* aResult) {
- UniqueFileHandle handle;
- if (!ReadIPDLParam(aReader, aActor, &handle)) {
+bool ParamTraits<mozilla::ipc::FileDescriptor>::Read(
+ MessageReader* aReader, mozilla::ipc::FileDescriptor* aResult) {
+ mozilla::UniqueFileHandle handle;
+ if (!ReadParam(aReader, &handle)) {
return false;
}
- *aResult = FileDescriptor(std::move(handle));
+ *aResult = mozilla::ipc::FileDescriptor(std::move(handle));
if (!aResult->IsValid()) {
printf_stderr("IPDL protocol Error: Received an invalid file descriptor\n");
}
return true;
}
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
diff --git a/ipc/glue/ForkServer.cpp b/ipc/glue/ForkServer.cpp
@@ -15,7 +15,6 @@
#include "mozilla/Omnijar.h"
#include "mozilla/ProcessType.h"
#include "mozilla/ipc/FileDescriptor.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/ipc/ProcessUtils.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/SetProcessTitle.h"
@@ -286,7 +285,7 @@ bool ForkServer::HandleForkNewSubprocess(UniquePtr<IPC::Message> aMessage) {
IPC::Message reply(MSG_ROUTING_CONTROL, Reply_ForkNewSubprocess__ID);
IPC::MessageWriter writer(reply);
- WriteIPDLParam(&writer, nullptr, pid);
+ WriteParam(&writer, pid);
mTcver->SendInfallible(reply, "failed to send a reply message");
return false;
diff --git a/ipc/glue/ForkServiceChild.cpp b/ipc/glue/ForkServiceChild.cpp
@@ -10,7 +10,6 @@
#include "mozilla/Atomics.h"
#include "mozilla/Logging.h"
#include "mozilla/ipc/GeckoChildProcessHost.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/StaticPrefs_dom.h"
#include "mozilla/Services.h"
@@ -149,7 +148,7 @@ Result<Ok, LaunchError> ForkServiceChild::SendForkNewSubprocess(
WriteParam(&writer, aOptions.fork_flags);
WriteParam(&writer, std::move(aOptions.sandbox_chroot_server));
#endif
- WriteIPDLParam(&writer, nullptr, std::move(execChild));
+ WriteParam(&writer, std::move(execChild));
if (!mTcver->Send(msg)) {
MOZ_LOG(gForkServiceLog, LogLevel::Verbose,
("the pipe to the fork server is closed or having errors"));
@@ -189,7 +188,7 @@ Result<Ok, LaunchError> ForkServiceChild::SendForkNewSubprocess(
}
IPC::MessageReader reader(*reply);
- if (!ReadIPDLParam(&reader, nullptr, aPid)) {
+ if (!ReadParam(&reader, aPid)) {
MOZ_CRASH("Error deserializing 'pid_t'");
}
reader.EndRead();
diff --git a/ipc/glue/IPDLParamTraits.h b/ipc/glue/IPDLParamTraits.h
@@ -1,63 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* 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/. */
-
-#ifndef mozilla_ipc_IPDLParamTraits_h
-#define mozilla_ipc_IPDLParamTraits_h
-
-#include "chrome/common/ipc_message_utils.h"
-#include "ipc/IPCMessageUtilsSpecializations.h"
-
-#include "nsTArray.h"
-
-#include <type_traits>
-
-namespace mozilla {
-namespace ipc {
-
-class IProtocol;
-
-//
-// IPDLParamTraits was an extended version of ParamTraits. Unlike ParamTraits,
-// IPDLParamTraits passes an additional IProtocol* argument to the
-// write and read methods.
-//
-// Previously this was required for serializing and deserializing types which
-// require knowledge of which protocol they're being sent over, however the
-// actor is now available through `IPC::Message{Writer,Reader}::GetActor()` so
-// the extra argument is no longer necessary. Please use `IPC::ParamTraits` in
-// the future.
-//
-// Types which implement IPDLParamTraits are also supported by ParamTraits.
-//
-template <typename P>
-struct IPDLParamTraits {};
-
-//
-// WriteIPDLParam and ReadIPDLParam are like IPC::WriteParam and IPC::ReadParam,
-// however, they also accept a redundant extra actor argument.
-//
-// NOTE: WriteIPDLParam takes a universal reference, so that it can support
-// whatever reference type is supported by the underlying ParamTraits::Write
-// implementation.
-//
-template <typename P>
-static MOZ_NEVER_INLINE void WriteIPDLParam(IPC::MessageWriter* aWriter,
- IProtocol* aActor, P&& aParam) {
- MOZ_ASSERT(aActor == aWriter->GetActor());
- IPC::WriteParam(aWriter, std::forward<P>(aParam));
-}
-
-template <typename P>
-static MOZ_NEVER_INLINE bool ReadIPDLParam(IPC::MessageReader* aReader,
- IProtocol* aActor, P* aResult) {
- MOZ_ASSERT(aActor == aReader->GetActor());
- return IPC::ReadParam(aReader, aResult);
-}
-
-} // namespace ipc
-} // namespace mozilla
-
-#endif // defined(mozilla_ipc_IPDLParamTraits_h)
diff --git a/ipc/glue/ProtocolMessageUtils.h b/ipc/glue/ProtocolMessageUtils.h
@@ -24,8 +24,6 @@ template <class PFooSide>
class Endpoint;
template <class PFooSide>
class ManagedEndpoint;
-template <typename P>
-struct IPDLParamTraits;
} // namespace mozilla::ipc
namespace IPC {
@@ -76,46 +74,37 @@ struct ParamTraits<mozilla::ipc::EndpointProcInfo> {
}
};
-} // namespace IPC
-
-namespace mozilla::ipc {
-
template <>
-struct IPDLParamTraits<UntypedManagedEndpoint> {
- using paramType = UntypedManagedEndpoint;
+struct ParamTraits<mozilla::ipc::UntypedManagedEndpoint> {
+ using paramType = mozilla::ipc::UntypedManagedEndpoint;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- paramType&& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult);
+ static void Write(MessageWriter* aWriter, paramType&& aParam);
+ static bool Read(MessageReader* aReader, paramType* aResult);
};
template <class PFooSide>
-struct IPDLParamTraits<ManagedEndpoint<PFooSide>> {
- using paramType = ManagedEndpoint<PFooSide>;
+struct ParamTraits<mozilla::ipc::ManagedEndpoint<PFooSide>> {
+ using paramType = mozilla::ipc::ManagedEndpoint<PFooSide>;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- paramType&& aParam) {
- IPDLParamTraits<UntypedManagedEndpoint>::Write(aWriter, aActor,
- std::move(aParam));
+ static void Write(IPC::MessageWriter* aWriter, paramType&& aParam) {
+ ParamTraits<mozilla::ipc::UntypedManagedEndpoint>::Write(aWriter,
+ std::move(aParam));
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- return IPDLParamTraits<UntypedManagedEndpoint>::Read(aReader, aActor,
- aResult);
+ static bool Read(IPC::MessageReader* aReader, paramType* aResult) {
+ return ParamTraits<mozilla::ipc::UntypedManagedEndpoint>::Read(aReader,
+ aResult);
}
};
template <>
-struct IPDLParamTraits<FileDescriptor> {
- typedef FileDescriptor paramType;
+struct ParamTraits<mozilla::ipc::FileDescriptor> {
+ using paramType = mozilla::ipc::FileDescriptor;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult);
+ static void Write(MessageWriter* aWriter, const paramType& aParam);
+ static bool Read(MessageReader* aReader, paramType* aResult);
};
-} // namespace mozilla::ipc
+
+} // namespace IPC
#endif // IPC_GLUE_PROTOCOLMESSAGEUTILS_H
diff --git a/ipc/glue/ProtocolUtils.cpp b/ipc/glue/ProtocolUtils.cpp
@@ -18,7 +18,6 @@
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/MessageChannel.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/StaticMutex.h"
#if defined(DEBUG) || defined(FUZZING)
# include "mozilla/Tokenizer.h"
@@ -803,7 +802,7 @@ void IPDLResolverInner::ResolveOrReject(
}
IPC::MessageWriter writer(*reply, actor);
- WriteIPDLParam(&writer, actor, aResolve);
+ WriteParam(&writer, aResolve);
aWrite(reply.get(), actor);
actor->ChannelSend(std::move(reply));
@@ -830,7 +829,7 @@ IPDLResolverInner::~IPDLResolverInner() {
ResolveOrReject(false, [](IPC::Message* aMessage, IProtocol* aActor) {
IPC::MessageWriter writer(*aMessage, aActor);
ResponseRejectReason reason = ResponseRejectReason::ResolverDestroyed;
- WriteIPDLParam(&writer, aActor, reason);
+ WriteParam(&writer, reason);
});
}
}
diff --git a/ipc/glue/Shmem.cpp b/ipc/glue/Shmem.cpp
@@ -165,46 +165,53 @@ UniquePtr<IPC::Message> Shmem::MkDestroyedMessage(
return MakeUnique<ShmemDestroyed>(routingId, mId);
}
-void IPDLParamTraits<Shmem>::Write(IPC::MessageWriter* aWriter,
- IProtocol* aActor, Shmem&& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mId);
- WriteIPDLParam(aWriter, aActor, uint32_t(aParam.mSize));
+} // namespace ipc
+} // namespace mozilla
+
+namespace IPC {
+
+void ParamTraits<mozilla::ipc::Shmem>::Write(IPC::MessageWriter* aWriter,
+ paramType&& aParam) {
+ WriteParam(aWriter, aParam.mId);
+ WriteParam(aWriter, uint32_t(aParam.mSize));
#ifdef DEBUG
- WriteIPDLParam(aWriter, aActor, aParam.mUnsafe);
+ WriteParam(aWriter, aParam.mUnsafe);
#endif
aParam.RevokeRights();
aParam.forget();
}
-bool IPDLParamTraits<Shmem>::Read(IPC::MessageReader* aReader,
- IProtocol* aActor, paramType* aResult) {
+bool ParamTraits<mozilla::ipc::Shmem>::Read(IPC::MessageReader* aReader,
+ paramType* aResult) {
+ if (!aReader->GetActor()) {
+ return false;
+ }
+
paramType::id_t id;
uint32_t size;
- if (!ReadIPDLParam(aReader, aActor, &id) ||
- !ReadIPDLParam(aReader, aActor, &size)) {
+ if (!ReadParam(aReader, &id) || !ReadParam(aReader, &size)) {
return false;
}
bool unsafe = false;
#ifdef DEBUG
- if (!ReadIPDLParam(aReader, aActor, &unsafe)) {
+ if (!ReadParam(aReader, &unsafe)) {
return false;
}
#endif
- auto* segment = aActor->LookupSharedMemory(id);
+ auto* segment = aReader->GetActor()->LookupSharedMemory(id);
if (segment) {
if (size > segment->Size()) {
return false;
}
- *aResult = Shmem(segment, id, size, unsafe);
+ *aResult = mozilla::ipc::Shmem(segment, id, size, unsafe);
return true;
}
- *aResult = Shmem();
+ *aResult = mozilla::ipc::Shmem();
return true;
}
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
diff --git a/ipc/glue/Shmem.h b/ipc/glue/Shmem.h
@@ -57,11 +57,8 @@ namespace mozilla::ipc {
class IProtocol;
class IToplevelProtocol;
-template <typename P>
-struct IPDLParamTraits;
-
class Shmem final {
- friend struct IPDLParamTraits<Shmem>;
+ friend struct IPC::ParamTraits<Shmem>;
friend class IProtocol;
friend class IToplevelProtocol;
diff --git a/ipc/glue/ShmemMessageUtils.h b/ipc/glue/ShmemMessageUtils.h
@@ -8,23 +8,18 @@
#define mozilla_ipc_ShmemMessageUtils_h
#include "ipc/IPCMessageUtils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/ipc/Shmem.h"
-namespace mozilla {
-namespace ipc {
+namespace IPC {
template <>
-struct IPDLParamTraits<Shmem> {
- typedef Shmem paramType;
+struct ParamTraits<mozilla::ipc::Shmem> {
+ using paramType = mozilla::ipc::Shmem;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- paramType&& aParam);
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult);
+ static void Write(IPC::MessageWriter* aWriter, paramType&& aParam);
+ static bool Read(IPC::MessageReader* aReader, paramType* aResult);
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif // ifndef mozilla_ipc_ShmemMessageUtils_h
diff --git a/ipc/glue/TaintingIPCUtils.h b/ipc/glue/TaintingIPCUtils.h
@@ -9,33 +9,25 @@
#include "mozilla/Tainting.h"
-#include "base/basictypes.h"
-#include "base/process.h"
+#include "chrome/common/ipc_message_utils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
-
-namespace mozilla {
-namespace ipc {
+namespace IPC {
template <typename T>
-struct IPDLParamTraits<mozilla::Tainted<T>> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const mozilla::Tainted<T>& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mValue);
+struct ParamTraits<mozilla::Tainted<T>> {
+ static void Write(MessageWriter* aWriter, const mozilla::Tainted<T>& aParam) {
+ WriteParam(aWriter, aParam.mValue);
}
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- mozilla::Tainted<T>&& aParam) {
- WriteIPDLParam(aWriter, aActor, std::move(aParam.mValue));
+ static void Write(MessageWriter* aWriter, mozilla::Tainted<T>&& aParam) {
+ WriteParam(aWriter, std::move(aParam.mValue));
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- mozilla::Tainted<T>* aResult) {
- return ReadIPDLParam(aReader, aActor, &(aResult->mValue));
+ static bool Read(MessageReader* aReader, mozilla::Tainted<T>* aResult) {
+ return ReadParam(aReader, &(aResult->mValue));
}
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif // ifndef mozilla_ipc_Tainting_h
diff --git a/ipc/glue/URIUtils.h b/ipc/glue/URIUtils.h
@@ -7,8 +7,8 @@
#ifndef mozilla_ipc_URIUtils_h
#define mozilla_ipc_URIUtils_h
+#include "ipc/IPCMessageUtilsSpecializations.h"
#include "mozilla/ipc/URIParams.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "nsCOMPtr.h"
#include "nsIURI.h"
@@ -23,27 +23,29 @@ already_AddRefed<nsIURI> DeserializeURI(const URIParams& aParams);
already_AddRefed<nsIURI> DeserializeURI(const Maybe<URIParams>& aParams);
+} // namespace ipc
+} // namespace mozilla
+
+namespace IPC {
+
template <>
-struct IPDLParamTraits<nsIURI*> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- nsIURI* aParam) {
- Maybe<URIParams> params;
- SerializeURI(aParam, params);
- WriteIPDLParam(aWriter, aActor, params);
+struct ParamTraits<nsIURI*> {
+ static void Write(IPC::MessageWriter* aWriter, nsIURI* aParam) {
+ mozilla::Maybe<mozilla::ipc::URIParams> params;
+ mozilla::ipc::SerializeURI(aParam, params);
+ WriteParam(aWriter, params);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- RefPtr<nsIURI>* aResult) {
- Maybe<URIParams> params;
- if (!ReadIPDLParam(aReader, aActor, ¶ms)) {
+ static bool Read(IPC::MessageReader* aReader, RefPtr<nsIURI>* aResult) {
+ mozilla::Maybe<mozilla::ipc::URIParams> params;
+ if (!ReadParam(aReader, ¶ms)) {
return false;
}
- *aResult = DeserializeURI(params);
+ *aResult = mozilla::ipc::DeserializeURI(params);
return true;
}
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif // mozilla_ipc_URIUtils_h
diff --git a/ipc/glue/moz.build b/ipc/glue/moz.build
@@ -38,7 +38,6 @@ EXPORTS.mozilla.ipc += [
"IPCForwards.h",
"IPCStreamUtils.h",
"IPCTypes.h",
- "IPDLParamTraits.h",
"IPDLStructMember.h",
"LaunchError.h",
"MessageChannel.h",
diff --git a/mfbt/Tainting.h b/mfbt/Tainting.h
@@ -14,16 +14,16 @@
#include <utility>
#include "mozilla/MacroArgs.h"
+namespace IPC {
+template <typename P>
+struct ParamTraits;
+}
+
namespace mozilla {
template <typename T>
class Tainted;
-namespace ipc {
-template <typename>
-struct IPDLParamTraits;
-}
-
/*
* The Tainted<> class allows data to be wrapped and considered 'tainted'; which
* requires explicit validation of the data before it can be used for
@@ -66,7 +66,7 @@ class Tainted {
T& Coerce() { return this->mValue; }
const T& Coerce() const { return this->mValue; }
- friend struct mozilla::ipc::IPDLParamTraits<Tainted<T>>;
+ friend struct IPC::ParamTraits<Tainted<T>>;
};
// ====================================================================
diff --git a/mfbt/Variant.h b/mfbt/Variant.h
@@ -27,11 +27,6 @@ struct ParamTraits;
namespace mozilla {
-namespace ipc {
-template <typename T>
-struct IPDLParamTraits;
-} // namespace ipc
-
template <typename... Ts>
class Variant;
@@ -578,7 +573,6 @@ template <typename... Ts>
class MOZ_INHERIT_TYPE_ANNOTATIONS_FROM_TEMPLATE_ARGS
MOZ_NON_PARAM MOZ_GSL_OWNER Variant {
friend struct IPC::ParamTraits<mozilla::Variant<Ts...>>;
- friend struct mozilla::ipc::IPDLParamTraits<mozilla::Variant<Ts...>>;
using Tag = typename detail::VariantTag<Ts...>::Type;
using Impl = detail::VariantImplementation<Tag, 0, Ts...>;
diff --git a/netwerk/dns/DNSByTypeRecord.h b/netwerk/dns/DNSByTypeRecord.h
@@ -6,7 +6,6 @@
#define DNSByTypeRecord_h__
#include "mozilla/net/HTTPSSVC.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "ipc/IPCMessageUtils.h"
#include "mozilla/net/NeckoMessageUtils.h"
@@ -38,227 +37,158 @@ struct IPCTypeRecord {
} // namespace net
} // namespace mozilla
-namespace mozilla {
-namespace ipc {
+namespace IPC {
template <>
-struct IPDLParamTraits<mozilla::net::IPCTypeRecord> {
+struct ParamTraits<mozilla::net::IPCTypeRecord> {
typedef mozilla::net::IPCTypeRecord paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mData);
- WriteIPDLParam(aWriter, aActor, aParam.mTTL);
- WriteIPDLParam(aWriter, aActor, aParam.mIsTRR);
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ WriteParam(aWriter, aParam.mData);
+ WriteParam(aWriter, aParam.mTTL);
+ WriteParam(aWriter, aParam.mIsTRR);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mData)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mTTL)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mIsTRR)) {
- return false;
- }
- return true;
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return ReadParam(aReader, &aResult->mData) &&
+ ReadParam(aReader, &aResult->mTTL) &&
+ ReadParam(aReader, &aResult->mIsTRR);
}
};
template <>
-struct IPDLParamTraits<mozilla::Nothing> {
+struct ParamTraits<mozilla::Nothing> {
typedef mozilla::Nothing paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
bool isSome = false;
- WriteIPDLParam(aWriter, aActor, isSome);
+ WriteParam(aWriter, isSome);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
+ static bool Read(MessageReader* aReader, paramType* aResult) {
bool isSome;
- if (!ReadIPDLParam(aReader, aActor, &isSome)) {
+ if (!ReadParam(aReader, &isSome)) {
return false;
}
- *aResult = Nothing();
+ *aResult = mozilla::Nothing();
return true;
}
};
template <>
-struct IPDLParamTraits<mozilla::net::SVCB> {
+struct ParamTraits<mozilla::net::SVCB> {
typedef mozilla::net::SVCB paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mSvcFieldPriority);
- WriteIPDLParam(aWriter, aActor, aParam.mSvcDomainName);
- WriteIPDLParam(aWriter, aActor, aParam.mEchConfig);
- WriteIPDLParam(aWriter, aActor, aParam.mODoHConfig);
- WriteIPDLParam(aWriter, aActor, aParam.mHasIPHints);
- WriteIPDLParam(aWriter, aActor, aParam.mHasEchConfig);
- WriteIPDLParam(aWriter, aActor, aParam.mSvcFieldValue);
- }
-
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mSvcFieldPriority)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mSvcDomainName)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mEchConfig)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mODoHConfig)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mHasIPHints)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mHasEchConfig)) {
- return false;
- }
- if (!ReadIPDLParam(aReader, aActor, &aResult->mSvcFieldValue)) {
- return false;
- }
- return true;
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ WriteParam(aWriter, aParam.mSvcFieldPriority);
+ WriteParam(aWriter, aParam.mSvcDomainName);
+ WriteParam(aWriter, aParam.mEchConfig);
+ WriteParam(aWriter, aParam.mODoHConfig);
+ WriteParam(aWriter, aParam.mHasIPHints);
+ WriteParam(aWriter, aParam.mHasEchConfig);
+ WriteParam(aWriter, aParam.mSvcFieldValue);
+ }
+
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return ReadParam(aReader, &aResult->mSvcFieldPriority) &&
+ ReadParam(aReader, &aResult->mSvcDomainName) &&
+ ReadParam(aReader, &aResult->mEchConfig) &&
+ ReadParam(aReader, &aResult->mODoHConfig) &&
+ ReadParam(aReader, &aResult->mHasIPHints) &&
+ ReadParam(aReader, &aResult->mHasEchConfig) &&
+ ReadParam(aReader, &aResult->mSvcFieldValue);
}
};
template <>
-struct IPDLParamTraits<mozilla::net::SvcParamAlpn> {
+struct ParamTraits<mozilla::net::SvcParamAlpn> {
typedef mozilla::net::SvcParamAlpn paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mValue);
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ WriteParam(aWriter, aParam.mValue);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
- return false;
- }
- return true;
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return ReadParam(aReader, &aResult->mValue);
}
};
template <>
-struct IPDLParamTraits<mozilla::net::SvcParamNoDefaultAlpn> {
+struct ParamTraits<mozilla::net::SvcParamNoDefaultAlpn> {
typedef mozilla::net::SvcParamNoDefaultAlpn paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {}
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- return true;
- }
+ static bool Read(MessageReader* aReader, paramType* aResult) { return true; }
};
template <>
-struct IPDLParamTraits<mozilla::net::SvcParamPort> {
+struct ParamTraits<mozilla::net::SvcParamPort> {
typedef mozilla::net::SvcParamPort paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mValue);
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ WriteParam(aWriter, aParam.mValue);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
- return false;
- }
- return true;
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return ReadParam(aReader, &aResult->mValue);
}
};
template <>
-struct IPDLParamTraits<mozilla::net::SvcParamIpv4Hint> {
+struct ParamTraits<mozilla::net::SvcParamIpv4Hint> {
typedef mozilla::net::SvcParamIpv4Hint paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mValue);
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ WriteParam(aWriter, aParam.mValue);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
- return false;
- }
- return true;
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return ReadParam(aReader, &aResult->mValue);
}
};
template <>
-struct IPDLParamTraits<mozilla::net::SvcParamEchConfig> {
+struct ParamTraits<mozilla::net::SvcParamEchConfig> {
typedef mozilla::net::SvcParamEchConfig paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mValue);
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ WriteParam(aWriter, aParam.mValue);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
- return false;
- }
- return true;
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return ReadParam(aReader, &aResult->mValue);
}
};
template <>
-struct IPDLParamTraits<mozilla::net::SvcParamIpv6Hint> {
+struct ParamTraits<mozilla::net::SvcParamIpv6Hint> {
typedef mozilla::net::SvcParamIpv6Hint paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mValue);
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ WriteParam(aWriter, aParam.mValue);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
- return false;
- }
- return true;
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return ReadParam(aReader, &aResult->mValue);
}
};
template <>
-struct IPDLParamTraits<mozilla::net::SvcParamODoHConfig> {
+struct ParamTraits<mozilla::net::SvcParamODoHConfig> {
typedef mozilla::net::SvcParamODoHConfig paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mValue);
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ WriteParam(aWriter, aParam.mValue);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
- return false;
- }
- return true;
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return ReadParam(aReader, &aResult->mValue);
}
};
template <>
-struct IPDLParamTraits<mozilla::net::SvcFieldValue> {
+struct ParamTraits<mozilla::net::SvcFieldValue> {
typedef mozilla::net::SvcFieldValue paramType;
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
- const paramType& aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mValue);
+ static void Write(MessageWriter* aWriter, const paramType& aParam) {
+ WriteParam(aWriter, aParam.mValue);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
- paramType* aResult) {
- if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
- return false;
- }
- return true;
+ static bool Read(MessageReader* aReader, paramType* aResult) {
+ return ReadParam(aReader, &aResult->mValue);
}
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif // DNSByTypeRecord_h__
diff --git a/security/manager/ssl/TransportSecurityInfo.cpp b/security/manager/ssl/TransportSecurityInfo.cpp
@@ -7,6 +7,7 @@
#include "TransportSecurityInfo.h"
#include "ipc/IPCMessageUtils.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
#include "mozilla/Base64.h"
#include "mozpkix/pkixtypes.h"
#include "nsBase64Encoder.h"
@@ -24,8 +25,6 @@
#include "secerr.h"
#include "ssl.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
-
// nsITransportSecurityInfo should not be created via do_CreateInstance. This
// stub prevents that.
template <>
diff --git a/security/manager/ssl/nsNSSCertificate.cpp b/security/manager/ssl/nsNSSCertificate.cpp
@@ -11,13 +11,13 @@
#include "X509CertValidity.h"
#include "certdb.h"
#include "ipc/IPCMessageUtils.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
#include "mozilla/Assertions.h"
#include "mozilla/Base64.h"
#include "mozilla/Casting.h"
#include "mozilla/NotNull.h"
#include "mozilla/Span.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/net/DNS.h"
#include "mozpkix/Result.h"
#include "mozpkix/pkixnss.h"
diff --git a/toolkit/components/backgroundhangmonitor/HangAnnotations.h b/toolkit/components/backgroundhangmonitor/HangAnnotations.h
@@ -9,13 +9,13 @@
#include <set>
+#include "ipc/IPCMessageUtilsSpecializations.h"
#include "mozilla/HangTypes.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/Mutex.h"
#include "mozilla/Vector.h"
#include "nsString.h"
#include "nsTArray.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
namespace mozilla {
@@ -56,16 +56,16 @@ class BackgroundHangAnnotators {
std::set<BackgroundHangAnnotator*> mAnnotators;
};
-namespace ipc {
+} // namespace mozilla
+
+namespace IPC {
template <>
-struct IPDLParamTraits<mozilla::BackgroundHangAnnotations>
- : public IPDLParamTraits<nsTArray<mozilla::HangAnnotation>> {
+struct ParamTraits<mozilla::BackgroundHangAnnotations>
+ : public ParamTraits<nsTArray<mozilla::HangAnnotation>> {
typedef mozilla::BackgroundHangAnnotations paramType;
};
-} // namespace ipc
-
-} // namespace mozilla
+} // namespace IPC
#endif // mozilla_HangAnnotations_h
diff --git a/toolkit/components/sessionstore/SessionStoreMessageUtils.h b/toolkit/components/sessionstore/SessionStoreMessageUtils.h
@@ -6,7 +6,6 @@
#define mozilla_dom_SessionStoreMessageUtils_h
#include "ipc/IPCMessageUtils.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#include "mozilla/ipc/URIUtils.h"
#include "SessionStoreData.h"
#include "SessionStoreUtils.h"
@@ -67,45 +66,40 @@ struct ParamTraits<InputFormData> {
}
};
-} // namespace IPC
-
-namespace mozilla {
-namespace ipc {
-
template <>
-struct IPDLParamTraits<mozilla::dom::SessionStoreRestoreData*> {
+struct ParamTraits<mozilla::dom::SessionStoreRestoreData*> {
// Note that we intentionally don't de/serialize mChildren here. The receiver
// won't be doing anything with the children lists, and it avoids sending form
// data for subframes to the content processes of their embedders.
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
+ static void Write(IPC::MessageWriter* aWriter,
mozilla::dom::SessionStoreRestoreData* aParam) {
bool isNull = !aParam;
- WriteIPDLParam(aWriter, aActor, isNull);
+ WriteParam(aWriter, isNull);
if (isNull) {
return;
}
- WriteIPDLParam(aWriter, aActor, aParam->mURI);
- WriteIPDLParam(aWriter, aActor, aParam->mInnerHTML);
- WriteIPDLParam(aWriter, aActor, aParam->mScroll);
- WriteIPDLParam(aWriter, aActor, aParam->mEntries);
+ WriteParam(aWriter, aParam->mURI);
+ WriteParam(aWriter, aParam->mInnerHTML);
+ WriteParam(aWriter, aParam->mScroll);
+ WriteParam(aWriter, aParam->mEntries);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+ static bool Read(IPC::MessageReader* aReader,
RefPtr<mozilla::dom::SessionStoreRestoreData>* aResult) {
*aResult = nullptr;
bool isNull;
- if (!ReadIPDLParam(aReader, aActor, &isNull)) {
+ if (!ReadParam(aReader, &isNull)) {
return false;
}
if (isNull) {
return true;
}
- auto data = MakeRefPtr<mozilla::dom::SessionStoreRestoreData>();
- if (!ReadIPDLParam(aReader, aActor, &data->mURI) ||
- !ReadIPDLParam(aReader, aActor, &data->mInnerHTML) ||
- !ReadIPDLParam(aReader, aActor, &data->mScroll) ||
- !ReadIPDLParam(aReader, aActor, &data->mEntries)) {
+ auto data = mozilla::MakeRefPtr<mozilla::dom::SessionStoreRestoreData>();
+ if (!ReadParam(aReader, &data->mURI) ||
+ !ReadParam(aReader, &data->mInnerHTML) ||
+ !ReadParam(aReader, &data->mScroll) ||
+ !ReadParam(aReader, &data->mEntries)) {
return false;
}
*aResult = std::move(data);
@@ -114,21 +108,20 @@ struct IPDLParamTraits<mozilla::dom::SessionStoreRestoreData*> {
};
template <>
-struct IPDLParamTraits<mozilla::dom::SessionStoreRestoreData::Entry> {
- static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
+struct ParamTraits<mozilla::dom::SessionStoreRestoreData::Entry> {
+ static void Write(IPC::MessageWriter* aWriter,
mozilla::dom::SessionStoreRestoreData::Entry aParam) {
- WriteIPDLParam(aWriter, aActor, aParam.mData);
- WriteIPDLParam(aWriter, aActor, aParam.mIsXPath);
+ WriteParam(aWriter, aParam.mData);
+ WriteParam(aWriter, aParam.mIsXPath);
}
- static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+ static bool Read(IPC::MessageReader* aReader,
mozilla::dom::SessionStoreRestoreData::Entry* aResult) {
- return ReadIPDLParam(aReader, aActor, &aResult->mData) &&
- ReadIPDLParam(aReader, aActor, &aResult->mIsXPath);
+ return ReadParam(aReader, &aResult->mData) &&
+ ReadParam(aReader, &aResult->mIsXPath);
}
};
-} // namespace ipc
-} // namespace mozilla
+} // namespace IPC
#endif // mozilla_dom_SessionStoreMessageUtils_h
diff --git a/toolkit/components/sessionstore/SessionStoreRestoreData.h b/toolkit/components/sessionstore/SessionStoreRestoreData.h
@@ -44,7 +44,7 @@ class SessionStoreRestoreData final : public nsISessionStoreRestoreData {
nsTArray<Entry> mEntries;
nsTArray<RefPtr<SessionStoreRestoreData>> mChildren;
- friend struct mozilla::ipc::IPDLParamTraits<SessionStoreRestoreData*>;
+ friend struct IPC::ParamTraits<SessionStoreRestoreData*>;
};
} // namespace mozilla::dom
diff --git a/tools/profiler/core/ProfileAdditionalInformation.cpp b/tools/profiler/core/ProfileAdditionalInformation.cpp
@@ -6,13 +6,13 @@
#include "ProfileAdditionalInformation.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
#include "jsapi.h"
#include "js/JSON.h"
#include "js/PropertyAndElement.h"
#include "js/Value.h"
#include "mozilla/Assertions.h"
#include "mozilla/JSONStringWriteFuncs.h"
-#include "mozilla/ipc/IPDLParamTraits.h"
#ifdef MOZ_GECKO_PROFILER
# include "platform.h"
diff --git a/widget/nsGUIEventIPC.h b/widget/nsGUIEventIPC.h
@@ -11,8 +11,7 @@
#include "mozilla/ContentCache.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/dom/Touch.h"
-#include "mozilla/ipc/IPDLParamTraits.h" // for ReadIPDLParam and WriteIPDLParam
-#include "mozilla/ipc/URIUtils.h" // for IPDLParamTraits<nsIURI*>
+#include "mozilla/ipc/URIUtils.h" // for ParamTraits<nsIURI*>
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/MiscEvents.h"
#include "mozilla/MouseEvents.h"
@@ -862,7 +861,7 @@ struct ParamTraits<mozilla::widget::InputContext> {
WriteParam(aWriter, aParam.mOrigin);
WriteParam(aWriter, aParam.mHasHandledUserInput);
WriteParam(aWriter, aParam.mInPrivateBrowsing);
- mozilla::ipc::WriteIPDLParam(aWriter, aWriter->GetActor(), aParam.mURI);
+ WriteParam(aWriter, aParam.mURI);
}
static bool Read(MessageReader* aReader, paramType* aResult) {
@@ -875,8 +874,7 @@ struct ParamTraits<mozilla::widget::InputContext> {
ReadParam(aReader, &aResult->mOrigin) &&
ReadParam(aReader, &aResult->mHasHandledUserInput) &&
ReadParam(aReader, &aResult->mInPrivateBrowsing) &&
- mozilla::ipc::ReadIPDLParam(aReader, aReader->GetActor(),
- address_of(aResult->mURI));
+ ReadParam(aReader, address_of(aResult->mURI));
}
};
