gecko-dev/netwerk/ipc/PSocketProcess.ipdl

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 protocol PDNSRequest;
include protocol PSocketProcessBridge;
include protocol PProfiler;
include protocol PWebrtcTCPSocket;
include protocol PHttpTransaction;
include protocol PHttpConnectionMgr;
include protocol PFileDescriptorSet;
include protocol PChildToParentStream;
include protocol PParentToChildStream;
include protocol PInputChannelThrottleQueue;
include protocol PBackground;
include protocol PAltService;
include protocol PAltSvcTransaction;
include protocol PTRRService;
include protocol PProxyConfigLookup;
include protocol PNativeDNSResolverOverride;
include protocol PRemoteLazyInputStream;

#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
include protocol PSandboxTesting;
#endif

include MemoryReportTypes;
include NeckoChannelParams;
include PrefsTypes;
include PSMIPCTypes;

using mozilla::dom::NativeThreadId from "mozilla/dom/NativeThreadId.h";
using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
using mozilla::Telemetry::HistogramAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedHistogramAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::ScalarAction from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedScalarAction from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::ChildEventData from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::DiscardedData from "mozilla/TelemetryComms.h";
using base::ProcessId from "base/process.h";
using mozilla::OriginAttributes from "mozilla/ipc/BackgroundUtils.h";
using PRTime from "prtime.h";
[RefCounted] using class nsIURI from "mozilla/ipc/URIUtils.h";
using struct nsID from "nsID.h";
using mozilla::net::SocketInfo from "mozilla/net/DashboardTypes.h";
using mozilla::net::DNSCacheEntries from "mozilla/net/DashboardTypes.h";
using mozilla::net::HttpRetParams from "mozilla/net/DashboardTypes.h";

namespace mozilla {
namespace net {

struct HttpHandlerInitArgs {
  nsCString mLegacyAppName;
  nsCString mLegacyAppVersion;
  nsCString mPlatform;
  nsCString mOscpu;
  nsCString mMisc;
  nsCString mProduct;
  nsCString mProductSub;
  nsCString mAppName;
  nsCString mAppVersion;
  nsCString mCompatFirefox;
  nsCString mCompatDevice;
  nsCString mDeviceModelId;
};

struct SocketDataArgs
{
  uint64_t totalSent;
  uint64_t totalRecv;
  SocketInfo[] info;
};

struct SocketPorcessInitAttributes {
  bool mOffline;
  bool mConnectivity;
  bool mInitSandbox;
  FileDescriptor? mSandboxBroker;
};

sync protocol PSocketProcess
{
  manages PDNSRequest;
  manages PWebrtcTCPSocket;
  manages PFileDescriptorSet;
  manages PHttpTransaction;
  manages PHttpConnectionMgr;
  manages PChildToParentStream;
  manages PParentToChildStream;
  manages PInputChannelThrottleQueue;
  manages PAltService;
  manages PAltSvcTransaction;
  manages PTRRService;
  manages PProxyConfigLookup;
  manages PNativeDNSResolverOverride;
  manages PRemoteLazyInputStream;

parent:
  async InitCrashReporter(NativeThreadId threadId);
  async AddMemoryReport(MemoryReport aReport);
  // Messages for sending telemetry to parent process.
  async AccumulateChildHistograms(HistogramAccumulation[] accumulations);
  async AccumulateChildKeyedHistograms(KeyedHistogramAccumulation[] accumulations);
  async UpdateChildScalars(ScalarAction[] actions);
  async UpdateChildKeyedScalars(KeyedScalarAction[] actions);
  async RecordChildEvents(ChildEventData[] events);
  async RecordDiscardedData(DiscardedData data);

  /* tabId is only required for web-proxy support, which isn't always needed */
  async PWebrtcTCPSocket(TabId? tabId);
  async PChildToParentStream();
  async ObserveHttpActivity(HttpActivityArgs aActivityArgs,
                            uint32_t aActivityType,
                            uint32_t aActivitySubtype,
                            PRTime   aTimestamp,
                            uint64_t aExtraSizeData,
                            nsCString aExtraStringData);
  async InitBackground(Endpoint<PBackgroundParent> aEndpoint);
  async PAltService();
  sync GetTLSClientCert(nsCString aHostName,
                        OriginAttributes aOriginAttributes,
                        int32_t aPort,
                        uint32_t aProviderFlags,
                        uint32_t aProviderTlsFlags,
                        ByteArray aServerCert,
                        ByteArray? aClientCert,
                        ByteArray[] aCollectedCANames)
    returns (bool aSucceeded, ByteArray aOutCert, ByteArray aOutKey, ByteArray[] aBuiltChain);
  async PProxyConfigLookup(nsIURI aUri, uint32_t aFlags);
  async CachePushCheck(nsIURI aPushedURL,
                       OriginAttributes aOriginAttributes,
                       nsCString aRequestString)
    returns (bool aAccepted);
  async ODoHServiceActivated(bool aActivated);

child:
  async Init(SocketPorcessInitAttributes aAttributes);
  async PreferenceUpdate(Pref pref);
  async RequestMemoryReport(uint32_t generation,
                            bool anonymize,
                            bool minimizeMemoryUsage,
                            FileDescriptor? DMDFile)
      returns (uint32_t aGeneration);
  async SetOffline(bool offline);
  async SetConnectivity(bool connectivity);
  async InitLinuxSandbox(FileDescriptor? sandboxBroker);
  async InitSocketProcessBridgeParent(ProcessId processId, Endpoint<PSocketProcessBridgeParent> endpoint);
  async InitProfiler(Endpoint<PProfilerChild> aEndpoint);
#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
  async InitSandboxTesting(Endpoint<PSandboxTestingChild> aEndpoint);
#endif
  // test-only
  async SocketProcessTelemetryPing();

  async PHttpTransaction();
  async PParentToChildStream();
  async PHttpConnectionMgr(HttpHandlerInitArgs aArgs);
  async UpdateDeviceModelId(nsCString aModelId);

  async OnHttpActivityDistributorActivated(bool aIsActivated);
  async PInputChannelThrottleQueue(uint32_t meanBytesPerSecond,
                                   uint32_t maxBytesPerSecond);
  async PAltSvcTransaction(HttpConnectionInfoCloneArgs aConnInfo,
                           uint32_t aCaps);
  async ClearSessionCache();
  async PTRRService(bool aCaptiveIsPassed,
                    bool aParentalControlEnabled,
                    nsCString[] aDNSSuffixList);
  async PNativeDNSResolverOverride();
  async NotifyObserver(nsCString aTopic, nsString aData);

  async PRemoteLazyInputStream(nsID aID, uint64_t aSize);

  async GetSocketData()
    returns (SocketDataArgs data);
  async GetDNSCacheEntries()
    returns (DNSCacheEntries[] entries);
   async GetHttpConnectionData()
    returns (HttpRetParams[] params);

both:
  async PFileDescriptorSet(FileDescriptor fd);
  async PDNSRequest(nsCString hostName, nsCString trrServer, uint16_t type,
                    OriginAttributes originAttributes, uint32_t flags);
};

} // namespace net
} // namespace mozilla