gecko-dev/dom/ipc/DOMTypes.ipdlh

/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
/* 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/. */

include "mozilla/GfxMessageUtils.h";
include "mozilla/layers/LayersMessageUtils.h";

include IPCBlob;
include IPCStream;
include ProtocolTypes;

using struct mozilla::void_t
  from "ipc/IPCMessageUtils.h";

using struct mozilla::SerializedStructuredCloneBuffer
  from "ipc/IPCMessageUtils.h";

using LayoutDeviceIntRect from "Units.h";
using DesktopIntRect from "Units.h";
using DesktopToLayoutDeviceScale from "Units.h";
using CSSToLayoutDeviceScale from "Units.h";
using CSSRect from "Units.h";
using CSSSize from "Units.h";
using mozilla::LayoutDeviceIntPoint from "Units.h";
using hal::ScreenOrientation from "mozilla/HalScreenConfiguration.h";
using mozilla::gfx::SurfaceFormat from "mozilla/gfx/Types.h";
using refcounted class nsIPrincipal from "mozilla/dom/PermissionMessageUtils.h";
using refcounted class mozilla::dom::BrowsingContext from "mozilla/dom/BrowsingContext.h";
using refcounted class nsIURI from "mozilla/ipc/URIUtils.h";
using refcounted class nsIContentSecurityPolicy from "mozilla/dom/CSPMessageUtils.h";

namespace mozilla {
namespace dom {

struct MessagePortIdentifier
{
  nsID uuid;
  nsID destinationUuid;
  uint32_t sequenceId;
  bool neutered;
};

/**
 * Cross-process representation for postMessage() style payloads where Blobs may
 * be referenced/"cloned" and (optionally) messageports transferred.  Use
 * StructuredCloneData in your code to convert between this wire representation
 * and the StructuredCloneData StructuredCloneHolder-subclass.
 */
struct ClonedMessageData
{
  SerializedStructuredCloneBuffer data;
  IPCBlob[] blobs;
  IPCStream[] inputStreams;
  MessagePortIdentifier[] identfiers;
};

union IPCDataTransferData
{
  nsString;  // text
  Shmem;     // images using Shmem
  IPCBlob;   // files
};

struct IPCDataTransferImage
{
  uint32_t width;
  uint32_t height;
  uint32_t stride;
  SurfaceFormat format;
};

struct IPCDataTransferItem
{
  nsCString flavor;
  // The image details are only used when transferring images.
  IPCDataTransferImage imageDetails;
  IPCDataTransferData data;
};

struct IPCDataTransfer
{
  IPCDataTransferItem[] items;
};

struct ScreenDetails {
  LayoutDeviceIntRect rect;
  DesktopIntRect rectDisplayPix;
  LayoutDeviceIntRect availRect;
  DesktopIntRect availRectDisplayPix;
  int32_t pixelDepth;
  int32_t colorDepth;
  DesktopToLayoutDeviceScale contentsScaleFactor;
  CSSToLayoutDeviceScale defaultCSSScaleFactor;
  float dpi;
};

struct DimensionInfo
{
  CSSRect rect;
  CSSSize size;
  ScreenOrientation orientation;
  LayoutDeviceIntPoint clientOffset;
  LayoutDeviceIntPoint chromeOffset;
};

struct FrameScriptInfo
{
  nsString url;
  bool runInGlobalScope;
};

/**
 * The information required to complete a window creation request.
 */
struct CreatedWindowInfo
{
  nsresult rv;
  bool windowOpened;
  FrameScriptInfo[] frameScripts;
  nsCString urlToLoad;
  uint32_t maxTouchPoints;
  DimensionInfo dimensions;
  bool hasSiblings;
};


/**
 * PerformanceInfo is used to pass performance info stored
 * in WorkerPrivate and DocGroup instances, as well as
 * memory-related information.
 *
 * Each (host, pid, windowId) is unique to a given DocGroup or
 * Worker, and we collect the number of dispatches per Dispatch
 * category and total execution duration as well as the current
 * Zone JS Heap usage.
 *
 * This IPDL struct reflects the data collected in Performance counters,
 * in addition of some memory usage information.
 *
 * see xpcom/threads/PerformanceCounter.h
 */

struct MediaMemoryInfo {
  uint64_t audioSize;
  uint64_t videoSize;
  uint64_t resourcesSize;
};

struct PerformanceMemoryInfo {
  MediaMemoryInfo media;
  uint64_t domDom;
  uint64_t domStyle;
  uint64_t domOther;
  uint64_t GCHeapUsage;
};

struct CategoryDispatch
{
  // DispatchCategory value
  uint16_t category;
  // Number of dispatch
  uint16_t count;
};

struct PerformanceInfo
{
  // Host of the document, if any
  nsCString host;
  // process id
  uint32_t pid;
  // window id
  uint64_t windowId;
  // Execution time in microseconds
  uint64_t duration;
  // Counter ID (unique across processes)
  uint64_t counterId;
  // True if the data is collected in a worker
  bool isWorker;
  // True if the document window is the top window
  bool isTopLevel;
  // Memory
  PerformanceMemoryInfo memory;
  // Counters per category. For workers, a single entry
  CategoryDispatch[] items;
};


struct WindowGlobalInit
{
  nsIPrincipal principal;
  BrowsingContext browsingContext;
  uint64_t innerWindowId;
  uint64_t outerWindowId;
};

struct DocShellLoadStateInit
{
  nsIURI Referrer;
  nsIURI URI;
  nsIURI OriginalURI;
  nsIURI ResultPrincipalURI;
  bool ResultPrincipalURIIsSome;
  nsIPrincipal TriggeringPrincipal;
  bool KeepResultPrincipalURIIfSet;
  bool LoadReplace;
  bool InheritPrincipal;
  bool PrincipalIsExplicit;
  nsIPrincipal PrincipalToInherit;
  bool ForceAllowDataURI;
  bool OriginalFrameSrc;
  bool SendReferrer;
  uint32_t ReferrerPolicy;
  uint32_t LoadType;
  nsString Target;
  nsIURI BaseURI;
  uint32_t LoadFlags;
  bool FirstParty;
  nsCString TypeHint;
  nsString FileName;
  bool IsFromProcessingFrameAttributes;
  // The Content Security Policy of the load, that is, the CSP of the entity
  // responsible for causing the load to occur. Most likely this is the CSP
  // of the document that started the load. In case the entity starting the
  // load did not use a CSP, then Csp can be null. Please note that this is
  // also the CSP that will be applied to the load in case the load
  // encounters a server side redirect.
  nsIContentSecurityPolicy Csp;
  // Fields missing due to lack of need or serialization
  // nsCOMPtr<nsISHEntry> mSHEntry;
  // nsCOMPtr<nsIDocShell> mSourceDocShell;
  // bool mIsSrcDocLoad; // useless without sourcedocshell
  // nsString mSrcdocData; // useless without sourcedocshell
  // nsIInputStream PostDataStream; // will be used after IPC transaction
  // nsIInputStream HeadersStream; // will be used after IPC transaction
  // nsIChannel pendingRedirectedChannel; // sent through other mechanism
};

} // namespace dom
} // namespace mozilla