Source code

Revision control

Other Tools

/* -*- 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_dom_SyncedContextInlines_h
#define mozilla_dom_SyncedContextInlines_h
#include "mozilla/dom/SyncedContext.h"
#include "mozilla/dom/BrowsingContextGroup.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/ContentChild.h"
#include "nsReadableUtils.h"
namespace mozilla {
namespace dom {
namespace syncedcontext {
template <typename T>
struct IsMozillaMaybe : std::false_type {};
template <typename T>
struct IsMozillaMaybe<Maybe<T>> : std::true_type {};
// A super-sketchy logging only function for generating a human-readable version
// of the value of a synced context field.
template <typename T>
void FormatFieldValue(nsACString& aStr, const T& aValue) {
if constexpr (std::is_same_v<bool, T>) {
if (aValue) {
aStr.AppendLiteral("true");
} else {
aStr.AppendLiteral("false");
}
} else if constexpr (std::is_same_v<nsID, T>) {
aStr.Append(nsIDToCString(aValue).get());
} else if constexpr (std::is_integral_v<T>) {
aStr.AppendInt(aValue);
} else if constexpr (std::is_enum_v<T>) {
aStr.AppendInt(static_cast<std::underlying_type_t<T>>(aValue));
} else if constexpr (std::is_floating_point_v<T>) {
aStr.AppendFloat(aValue);
} else if constexpr (std::is_base_of_v<nsAString, T>) {
AppendUTF16toUTF8(aValue, aStr);
} else if constexpr (std::is_base_of_v<nsACString, T>) {
aStr.Append(aValue);
} else if constexpr (IsMozillaMaybe<T>::value) {
if (aValue) {
aStr.AppendLiteral("Some(");
FormatFieldValue(aStr, aValue.ref());
aStr.AppendLiteral(")");
} else {
aStr.AppendLiteral("Nothing");
}
} else {
aStr.AppendLiteral("???");
}
}
// Sketchy logging-only logic to generate a human-readable output of the actions
// a synced context transaction is going to perform.
template <typename Context>
nsAutoCString FormatTransaction(
IndexSet aModified, const typename Context::FieldValues& aOldValues,
const typename Context::FieldValues& aNewValues) {
nsAutoCString result;
Context::FieldValues::EachIndex([&](auto idx) {
if (aModified.contains(idx)) {
result.Append(Context::FieldIndexToName(idx));
result.AppendLiteral("(");
FormatFieldValue(result, aOldValues.Get(idx));
result.AppendLiteral("->");
FormatFieldValue(result, aNewValues.Get(idx));
result.AppendLiteral(") ");
}
});
return result;
}
template <typename Context>
nsCString FormatValidationError(IndexSet aFailedFields, const char* prefix) {
MOZ_ASSERT(!aFailedFields.isEmpty());
return nsDependentCString{prefix} +
StringJoin(", "_ns, aFailedFields,
[](nsACString& dest, const auto& idx) {
dest.Append(Context::FieldIndexToName(idx));
});
}
template <typename Context>
nsresult Transaction<Context>::Commit(Context* aOwner) {
if (NS_WARN_IF(aOwner->IsDiscarded())) {
return NS_ERROR_DOM_INVALID_STATE_ERR;
}
IndexSet failedFields = Validate(aOwner, nullptr);
if (!failedFields.isEmpty()) {
nsCString error = FormatValidationError<Context>(
failedFields, "CanSet failed for field(s): ");
MOZ_CRASH_UNSAFE_PRINTF("%s", error.get());
}
if (mModified.isEmpty()) {
return NS_OK;
}
if (XRE_IsContentProcess()) {
ContentChild* cc = ContentChild::GetSingleton();
// Increment the field epoch for fields affected by this transaction.
uint64_t epoch = cc->NextBrowsingContextFieldEpoch();
EachIndex([&](auto idx) {
if (mModified.contains(idx)) {
FieldEpoch(idx, aOwner) = epoch;
}
});
// Tell our derived class to send the correct "Commit" IPC message.
aOwner->SendCommitTransaction(cc, *this, epoch);
} else {
MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
// Tell our derived class to send the correct "Commit" IPC messages.
BrowsingContextGroup* group = aOwner->Group();
group->EachParent([&](ContentParent* aParent) {
aOwner->SendCommitTransaction(aParent, *this,
aParent->GetBrowsingContextFieldEpoch());
});
}
Apply(aOwner, /* aFromIPC */ false);
return NS_OK;
}
template <typename Context>
mozilla::ipc::IPCResult Transaction<Context>::CommitFromIPC(
const MaybeDiscarded<Context>& aOwner, ContentParent* aSource) {
MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
if (aOwner.IsNullOrDiscarded()) {
MOZ_LOG(Context::GetSyncLog(), LogLevel::Debug,
("IPC: Trying to send a message to dead or detached context"));
return IPC_OK();
}
Context* owner = aOwner.get();
// Validate that the set from content is allowed before continuing.
IndexSet failedFields = Validate(owner, aSource);
if (!failedFields.isEmpty()) {
nsCString error = FormatValidationError<Context>(
failedFields,
"Invalid Transaction from Child - CanSet failed for field(s): ");
return IPC_FAIL(aSource, error.get());
}
// Validate may have dropped some fields from the transaction, check it's not
// empty before continuing.
if (mModified.isEmpty()) {
return IPC_OK();
}
BrowsingContextGroup* group = owner->Group();
group->EachOtherParent(aSource, [&](ContentParent* aParent) {
owner->SendCommitTransaction(aParent, *this,
aParent->GetBrowsingContextFieldEpoch());
});
Apply(owner, /* aFromIPC */ true);
return IPC_OK();
}
template <typename Context>
mozilla::ipc::IPCResult Transaction<Context>::CommitFromIPC(
const MaybeDiscarded<Context>& aOwner, uint64_t aEpoch,
ContentChild* aSource) {
MOZ_DIAGNOSTIC_ASSERT(XRE_IsContentProcess());
if (aOwner.IsNullOrDiscarded()) {
MOZ_LOG(Context::GetSyncLog(), LogLevel::Debug,
("ChildIPC: Trying to send a message to dead or detached context"));
return IPC_OK();
}
Context* owner = aOwner.get();
// Clear any fields which have been obsoleted by the epoch.
EachIndex([&](auto idx) {
if (mModified.contains(idx) && FieldEpoch(idx, owner) > aEpoch) {
MOZ_LOG(
Context::GetSyncLog(), LogLevel::Debug,
("Transaction::Obsoleted(#%" PRIx64 ", %" PRIu64 ">%" PRIu64 "): %s",
owner->Id(), FieldEpoch(idx, owner), aEpoch,
Context::FieldIndexToName(idx)));
mModified -= idx;
}
});
if (mModified.isEmpty()) {
return IPC_OK();
}
Apply(owner, /* aFromIPC */ true);
return IPC_OK();
}
template <typename Context>
void Transaction<Context>::Apply(Context* aOwner, bool aFromIPC) {
MOZ_ASSERT(!mModified.isEmpty());
MOZ_LOG(
Context::GetSyncLog(), LogLevel::Debug,
("Transaction::Apply(#%" PRIx64 ", %s): %s", aOwner->Id(),
aFromIPC ? "ipc" : "local",
FormatTransaction<Context>(mModified, aOwner->mFields.mValues, mValues)
.get()));
EachIndex([&](auto idx) {
if (mModified.contains(idx)) {
auto& txnField = mValues.Get(idx);
auto& ownerField = aOwner->mFields.mValues.Get(idx);
std::swap(ownerField, txnField);
aOwner->DidSet(idx);
aOwner->DidSet(idx, std::move(txnField));
}
});
mModified.clear();
}
template <typename Context>
void Transaction<Context>::CommitWithoutSyncing(Context* aOwner) {
MOZ_LOG(
Context::GetSyncLog(), LogLevel::Debug,
("Transaction::CommitWithoutSyncing(#%" PRIx64 "): %s", aOwner->Id(),
FormatTransaction<Context>(mModified, aOwner->mFields.mValues, mValues)
.get()));
EachIndex([&](auto idx) {
if (mModified.contains(idx)) {
aOwner->mFields.mValues.Get(idx) = std::move(mValues.Get(idx));
}
});
mModified.clear();
}
inline CanSetResult AsCanSetResult(CanSetResult aValue) { return aValue; }
inline CanSetResult AsCanSetResult(bool aValue) {
return aValue ? CanSetResult::Allow : CanSetResult::Deny;
}
template <typename Context>
IndexSet Transaction<Context>::Validate(Context* aOwner,
ContentParent* aSource) {
IndexSet failedFields;
Transaction<Context> revertTxn;
EachIndex([&](auto idx) {
if (!mModified.contains(idx)) {
return;
}
switch (AsCanSetResult(aOwner->CanSet(idx, mValues.Get(idx), aSource))) {
case CanSetResult::Allow:
break;
case CanSetResult::Deny:
failedFields += idx;
break;
case CanSetResult::Revert:
revertTxn.mValues.Get(idx) = aOwner->mFields.mValues.Get(idx);
revertTxn.mModified += idx;
break;
}
});
// If any changes need to be reverted, log them, remove them from this
// transaction, and optionally send a message to the source process.
if (!revertTxn.mModified.isEmpty()) {
// NOTE: Logging with modified IndexSet from revert transaction, and values
// from this transaction, so we log the failed values we're going to revert.
MOZ_LOG(Context::GetSyncLog(), LogLevel::Debug,
("Transaction::PartialRevert(#%" PRIx64 ", pid %d): %s",
aOwner->Id(), aSource ? aSource->OtherPid() : -1,
FormatTransaction<Context>(revertTxn.mModified, mValues,
revertTxn.mValues)
.get()));
mModified -= revertTxn.mModified;
if (aSource) {
aOwner->SendCommitTransaction(aSource, revertTxn,
aSource->GetBrowsingContextFieldEpoch());
}
}
return failedFields;
}
template <typename Context>
void Transaction<Context>::Write(IPC::Message* aMsg,
mozilla::ipc::IProtocol* aActor) const {
// Record which field indices will be included, and then write those fields
// out.
uint64_t modified = mModified.serialize();
WriteIPDLParam(aMsg, aActor, modified);
EachIndex([&](auto idx) {
if (mModified.contains(idx)) {
WriteIPDLParam(aMsg, aActor, mValues.Get(idx));
}
});
}
template <typename Context>
bool Transaction<Context>::Read(const IPC::Message* aMsg, PickleIterator* aIter,
mozilla::ipc::IProtocol* aActor) {
// Read in which field indices were sent by the remote, followed by the fields
// identified by those indices.
uint64_t modified = 0;
if (!ReadIPDLParam(aMsg, aIter, aActor, &modified)) {
return false;
}
mModified.deserialize(modified);
bool ok = true;
EachIndex([&](auto idx) {
if (ok && mModified.contains(idx)) {
ok = ReadIPDLParam(aMsg, aIter, aActor, &mValues.Get(idx));
}
});
return ok;
}
template <typename Base, size_t Count>
void FieldValues<Base, Count>::Write(IPC::Message* aMsg,
mozilla::ipc::IProtocol* aActor) const {
// XXX The this-> qualification is necessary to work around a bug in older gcc
// versions causing an ICE.
EachIndex([&](auto idx) { WriteIPDLParam(aMsg, aActor, this->Get(idx)); });
}
template <typename Base, size_t Count>
bool FieldValues<Base, Count>::Read(const IPC::Message* aMsg,
PickleIterator* aIter,
mozilla::ipc::IProtocol* aActor) {
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(aMsg, aIter, aActor, &this->Get(idx));
}
});
return ok;
}
} // namespace syncedcontext
} // namespace dom
} // namespace mozilla
#endif // !defined(mozilla_dom_SyncedContextInlines_h)