Bug 1609990 - AgentCluster comparison in MessagePort and BroadcastChannel - part 2 - MessageDataType, r=smaug

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

--HG--
extra : moz-landing-system : lando

dom/broadcastchannel/BroadcastChannel.cpp

@@ -349,8 +349,18 @@ void BroadcastChannel::PostMessage(JSContext* aCx,
     return;
   }
 
-  RefPtr<SharedMessageBody> data =
-      new SharedMessageBody(StructuredCloneHolder::TransferringNotSupported);
+  Maybe<nsID> agentClusterId;
+  nsCOMPtr<nsIGlobalObject> global = GetOwnerGlobal();
+  MOZ_ASSERT(global);
+  if (global) {
+    Maybe<ClientInfo> clientInfo = global->GetClientInfo();
+    if (clientInfo) {
+      agentClusterId = clientInfo->AgentClusterId();
+    }
+  }
+
+  RefPtr<SharedMessageBody> data = new SharedMessageBody(
+      StructuredCloneHolder::TransferringNotSupported, agentClusterId);
 
   data->Write(aCx, aMessage, JS::UndefinedHandleValue, mPortUUID,
               mRefMessageBodyService, aRv);

dom/broadcastchannel/BroadcastChannelService.cpp

@@ -96,8 +96,9 @@ void BroadcastChannelService::PostMessage(BroadcastChannelParent* aParent,
 
   // We need to keep the array alive for the life-time of this operation.
   nsTArray<RefPtr<BlobImpl>> blobImpls;
-  if (aData.type() == MessageData::TClonedMessageData) {
-    const nsTArray<IPCBlob>& blobs = aData.get_ClonedMessageData().blobs();
+  if (aData.data().type() == MessageDataType::TClonedMessageData) {
+    const nsTArray<IPCBlob>& blobs =
+        aData.data().get_ClonedMessageData().blobs();
     if (!blobs.IsEmpty()) {
       blobImpls.SetCapacity(blobs.Length());
 
@@ -127,10 +128,11 @@ void BroadcastChannelService::PostMessage(BroadcastChannelParent* aParent,
 
     // We need to have a copy of the data for this parent.
     MessageData newData(aData);
-    MOZ_ASSERT(newData.type() == aData.type());
+    MOZ_ASSERT(newData.data().type() == aData.data().type());
 
     if (!blobImpls.IsEmpty()) {
-      nsTArray<IPCBlob>& newBlobImpls = newData.get_ClonedMessageData().blobs();
+      nsTArray<IPCBlob>& newBlobImpls =
+          newData.data().get_ClonedMessageData().blobs();
       MOZ_ASSERT(blobImpls.Length() == newBlobImpls.Length());
 
       // Serialize Blob objects for this message.
@@ -147,9 +149,9 @@ void BroadcastChannelService::PostMessage(BroadcastChannelParent* aParent,
   }
 
   // If this is a refMessageData, we need to know when it can be released.
-  if (aData.type() == MessageData::TRefMessageData) {
+  if (aData.data().type() == MessageDataType::TRefMessageData) {
     Unused << aParent->SendRefMessageDelivered(
-        aData.get_RefMessageData().uuid(), selectedActorsOnSamePid);
+        aData.data().get_RefMessageData().uuid(), selectedActorsOnSamePid);
   }
 }
 

dom/ipc/DOMTypes.ipdlh

@@ -72,11 +72,16 @@ struct RefMessageData {
   nsID uuid;
 };
 
-union MessageData {
+union MessageDataType {
   ClonedMessageData;
   RefMessageData;
 };
 
+struct MessageData {
+  nsID? agentClusterId;
+  MessageDataType data;
+};
+
 union IPCDataTransferData
 {
   nsString;  // text

dom/ipc/SharedMessageBody.cpp

@@ -19,8 +19,11 @@ using namespace ipc;
 namespace dom {
 
 SharedMessageBody::SharedMessageBody(
-    StructuredCloneHolder::TransferringSupport aSupportsTransferring)
-    : mRefDataId({}), mSupportsTransferring(aSupportsTransferring) {}
+    StructuredCloneHolder::TransferringSupport aSupportsTransferring,
+    const Maybe<nsID>& aAgentClusterId)
+    : mRefDataId(Nothing()),
+      mSupportsTransferring(aSupportsTransferring),
+      mAgentClusterId(aAgentClusterId) {}
 
 void SharedMessageBody::Write(JSContext* aCx, JS::Handle<JS::Value> aValue,
                               JS::Handle<JS::Value> aTransfers, nsID& aPortID,
@@ -44,7 +47,7 @@ void SharedMessageBody::Write(JSContext* aCx, JS::Handle<JS::Value> aValue,
   RefPtr<RefMessageBody> refData =
       new RefMessageBody(aPortID, std::move(mCloneData));
 
-  mRefDataId = aRefMessageBodyService->Register(refData.forget(), aRv);
+  mRefDataId.emplace(aRefMessageBodyService->Register(refData.forget(), aRv));
 }
 
 void SharedMessageBody::Read(JSContext* aCx,
@@ -59,12 +62,13 @@ void SharedMessageBody::Read(JSContext* aCx,
   }
 
   MOZ_ASSERT(!mRefData);
+  MOZ_ASSERT(mRefDataId.isSome());
 
   if (aReadMethod == SharedMessageBody::StealRefMessageBody) {
-    mRefData = aRefMessageBodyService->Steal(mRefDataId);
+    mRefData = aRefMessageBodyService->Steal(mRefDataId.value());
   } else {
     MOZ_ASSERT(aReadMethod == SharedMessageBody::KeepRefMessageBody);
-    mRefData = aRefMessageBodyService->GetAndCount(mRefDataId);
+    mRefData = aRefMessageBodyService->GetAndCount(mRefDataId.value());
   }
 
   if (!mRefData) {
@@ -92,15 +96,18 @@ void SharedMessageBody::FromSharedToMessageChild(
   MOZ_ASSERT(aManager);
   MOZ_ASSERT(aData);
 
+  aMessage.agentClusterId() = aData->mAgentClusterId;
+
   if (aData->mCloneData) {
     ClonedMessageData clonedData;
     aData->mCloneData->BuildClonedMessageDataForBackgroundChild(aManager,
                                                                 clonedData);
-    aMessage = clonedData;
+    aMessage.data() = clonedData;
     return;
   }
 
-  aMessage = RefMessageData(aData->mRefDataId);
+  MOZ_ASSERT(aData->mRefDataId.isSome());
+  aMessage.data() = RefMessageData(aData->mRefDataId.value());
 }
 
 /* static */
@@ -122,16 +129,17 @@ void SharedMessageBody::FromSharedToMessagesChild(
 already_AddRefed<SharedMessageBody> SharedMessageBody::FromMessageToSharedChild(
     MessageData& aMessage,
     StructuredCloneHolder::TransferringSupport aSupportsTransferring) {
-  RefPtr<SharedMessageBody> data = new SharedMessageBody(aSupportsTransferring);
+  RefPtr<SharedMessageBody> data =
+      new SharedMessageBody(aSupportsTransferring, aMessage.agentClusterId());
 
-  if (aMessage.type() == MessageData::TClonedMessageData) {
+  if (aMessage.data().type() == MessageDataType::TClonedMessageData) {
     data->mCloneData = MakeUnique<ipc::StructuredCloneData>(
         JS::StructuredCloneScope::UnknownDestination, aSupportsTransferring);
     data->mCloneData->StealFromClonedMessageDataForBackgroundChild(
-        aMessage.get_ClonedMessageData());
+        aMessage.data().get_ClonedMessageData());
   } else {
-    MOZ_ASSERT(aMessage.type() == MessageData::TRefMessageData);
-    data->mRefDataId = aMessage.get_RefMessageData().uuid();
+    MOZ_ASSERT(aMessage.data().type() == MessageDataType::TRefMessageData);
+    data->mRefDataId.emplace(aMessage.data().get_RefMessageData().uuid());
   }
 
   return data.forget();
@@ -141,15 +149,17 @@ already_AddRefed<SharedMessageBody> SharedMessageBody::FromMessageToSharedChild(
 already_AddRefed<SharedMessageBody> SharedMessageBody::FromMessageToSharedChild(
     const MessageData& aMessage,
     StructuredCloneHolder::TransferringSupport aSupportsTransferring) {
-  RefPtr<SharedMessageBody> data = new SharedMessageBody(aSupportsTransferring);
+  RefPtr<SharedMessageBody> data =
+      new SharedMessageBody(aSupportsTransferring, aMessage.agentClusterId());
 
-  if (aMessage.type() == MessageData::TClonedMessageData) {
+  if (aMessage.data().type() == MessageDataType::TClonedMessageData) {
     data->mCloneData = MakeUnique<ipc::StructuredCloneData>(
         JS::StructuredCloneScope::UnknownDestination, aSupportsTransferring);
-    data->mCloneData->BorrowFromClonedMessageDataForBackgroundChild(aMessage);
+    data->mCloneData->BorrowFromClonedMessageDataForBackgroundChild(
+        aMessage.data().get_ClonedMessageData());
   } else {
-    MOZ_ASSERT(aMessage.type() == MessageData::TRefMessageData);
-    data->mRefDataId = aMessage.get_RefMessageData().uuid();
+    MOZ_ASSERT(aMessage.data().type() == MessageDataType::TRefMessageData);
+    data->mRefDataId.emplace(aMessage.data().get_RefMessageData().uuid());
   }
 
   return data.forget();
@@ -191,16 +201,18 @@ bool SharedMessageBody::FromSharedToMessagesParent(
 
   for (auto& data : aData) {
     MessageData* message = aArray.AppendElement(mozilla::fallible);
+    message->agentClusterId() = data->mAgentClusterId;
 
     if (data->mCloneData) {
       ClonedMessageData clonedData;
       data->mCloneData->BuildClonedMessageDataForBackgroundParent(aManager,
                                                                   clonedData);
-      *message = clonedData;
+      message->data() = clonedData;
       continue;
     }
 
-    *message = RefMessageData(data->mRefDataId);
+    MOZ_ASSERT(data->mRefDataId.isSome());
+    message->data() = RefMessageData(data->mRefDataId.value());
   }
 
   return true;
@@ -211,15 +223,17 @@ already_AddRefed<SharedMessageBody>
 SharedMessageBody::FromMessageToSharedParent(
     MessageData& aMessage,
     StructuredCloneHolder::TransferringSupport aSupportsTransferring) {
-  RefPtr<SharedMessageBody> data = new SharedMessageBody(aSupportsTransferring);
+  RefPtr<SharedMessageBody> data =
+      new SharedMessageBody(aSupportsTransferring, aMessage.agentClusterId());
 
-  if (aMessage.type() == MessageData::TClonedMessageData) {
+  if (aMessage.data().type() == MessageDataType::TClonedMessageData) {
     data->mCloneData = MakeUnique<ipc::StructuredCloneData>(
         JS::StructuredCloneScope::UnknownDestination, aSupportsTransferring);
-    data->mCloneData->StealFromClonedMessageDataForBackgroundParent(aMessage);
+    data->mCloneData->StealFromClonedMessageDataForBackgroundParent(
+        aMessage.data().get_ClonedMessageData());
   } else {
-    MOZ_ASSERT(aMessage.type() == MessageData::TRefMessageData);
-    data->mRefDataId = aMessage.get_RefMessageData().uuid();
+    MOZ_ASSERT(aMessage.data().type() == MessageDataType::TRefMessageData);
+    data->mRefDataId.emplace(aMessage.data().get_RefMessageData().uuid());
   }
 
   return data.forget();

dom/ipc/SharedMessageBody.h

@@ -8,6 +8,7 @@
 #define mozilla_dom_SharedMessageBody_h
 
 #include "mozilla/dom/ipc/StructuredCloneData.h"
+#include "mozilla/Maybe.h"
 
 namespace mozilla {
 
@@ -25,8 +26,9 @@ class SharedMessageBody final {
  public:
   NS_INLINE_DECL_REFCOUNTING(SharedMessageBody)
 
-  explicit SharedMessageBody(
-      StructuredCloneHolder::TransferringSupport aSupportsTransferring);
+  SharedMessageBody(
+      StructuredCloneHolder::TransferringSupport aSupportsTransferring,
+      const Maybe<nsID>& aAgentClusterId);
 
   // Note that the populated MessageData borrows the underlying
   // JSStructuredCloneData from the SharedMessageBody, so the caller is
@@ -98,8 +100,10 @@ class SharedMessageBody final {
   UniquePtr<ipc::StructuredCloneData> mCloneData;
 
   RefPtr<RefMessageBody> mRefData;
-  nsID mRefDataId;
-  StructuredCloneHolder::TransferringSupport mSupportsTransferring;
+  Maybe<nsID> mRefDataId;
+
+  const StructuredCloneHolder::TransferringSupport mSupportsTransferring;
+  const Maybe<nsID> mAgentClusterId;
 };
 
 }  // namespace dom

dom/messagechannel/MessagePort.cpp

@@ -329,8 +329,17 @@ void MessagePort::PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
     return;
   }
 
-  RefPtr<SharedMessageBody> data =
-      new SharedMessageBody(StructuredCloneHolder::TransferringSupported);
+  Maybe<nsID> agentClusterId;
+  nsCOMPtr<nsIGlobalObject> global = GetOwnerGlobal();
+  if (global) {
+    Maybe<ClientInfo> clientInfo = global->GetClientInfo();
+    if (clientInfo) {
+      agentClusterId = clientInfo->AgentClusterId();
+    }
+  }
+
+  RefPtr<SharedMessageBody> data = new SharedMessageBody(
+      StructuredCloneHolder::TransferringSupported, agentClusterId);
 
   UniquePtr<AbstractTimelineMarker> start;
   UniquePtr<AbstractTimelineMarker> end;