author Georg Fritzsche <>
Wed, 15 Feb 2017 10:37:17 +0100
changeset 389723 3a90f1f64d8d8cb6fa4aae7e0a322e69671636ae
parent 377995 ed89028b70a9ab00e118a847dc7f836cda135a55
child 389746 21a0091e7a82839b91bc780aa1156efb5302d7a5
permissions -rw-r--r--
Bug 1339749 - Refactor Telemetry IPC code. r=chutten

/* -*- Mode: C++; tab-width: 8; 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 */

include GraphicsMessages;
include MemoryReportTypes;
include protocol PCompositorBridge;
include protocol PImageBridge;
include protocol PVRManager;
include protocol PVsyncBridge;
include protocol PUiCompositorController;
include protocol PVideoDecoderManager;

using base::ProcessId from "base/process.h";
using mozilla::TimeDuration from "mozilla/TimeStamp.h";
using mozilla::CSSToLayoutDeviceScale from "Units.h";
using mozilla::gfx::IntSize from "mozilla/gfx/2D.h";
using mozilla::layers::CompositorOptions from "mozilla/layers/CompositorOptions.h";
using mozilla::Telemetry::Accumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::ScalarAction from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedScalarAction from "mozilla/TelemetryComms.h";

namespace mozilla {
namespace gfx {

union GfxPrefValue {

struct GfxPrefSetting {
  int32_t index;
  GfxPrefValue value;

struct LayerTreeIdMapping {
  uint64_t layersId;
  ProcessId ownerId;

sync protocol PGPU
  // Sent by the UI process to initiate core settings.
  async Init(GfxPrefSetting[] prefs,
             GfxVarUpdate[] vars,
             DevicePrefs devicePrefs);

  async InitVsyncBridge(Endpoint<PVsyncBridgeParent> endpoint);
  async InitImageBridge(Endpoint<PImageBridgeParent> endpoint);
  async InitVRManager(Endpoint<PVRManagerParent> endpoint);
  async InitUiCompositorController(Endpoint<PUiCompositorControllerParent> endpoint);

  // Called to update a gfx preference or variable.
  async UpdatePref(GfxPrefSetting pref);
  async UpdateVar(GfxVarUpdate var);

  // Create a new top-level compositor.
  async NewWidgetCompositor(Endpoint<PCompositorBridgeParent> endpoint,
                            CSSToLayoutDeviceScale scale,
                            TimeDuration vsyncRate,
                            CompositorOptions options,
                            bool useExternalSurface,
                            IntSize surfaceSize);

  // Create a new content-process compositor bridge.
  async NewContentCompositorBridge(Endpoint<PCompositorBridgeParent> endpoint);
  async NewContentImageBridge(Endpoint<PImageBridgeParent> endpoint);
  async NewContentVRManager(Endpoint<PVRManagerParent> endpoint);
  async NewContentVideoDecoderManager(Endpoint<PVideoDecoderManagerParent> endpoint);

  // Called to notify the GPU process of who owns a layersId.
  sync AddLayerTreeIdMapping(LayerTreeIdMapping[] mapping);
  async RemoveLayerTreeIdMapping(LayerTreeIdMapping mapping);

  // Request the current DeviceStatus from the GPU process. This blocks until
  // one is available (i.e., Init has completed).
  sync GetDeviceStatus() returns (GPUDeviceData status);

  // Have a message be broadcasted to the GPU process by the GPU process
  // observer service.
  async NotifyGpuObservers(nsCString aTopic);

  async RequestMemoryReport(uint32_t generation,
                            bool anonymize,
                            bool minimizeMemoryUsage,
                            MaybeFileDesc DMDFile);

  // Sent when the GPU process has initialized devices. This occurs once, after
  // Init().
  async InitComplete(GPUDeviceData data);

  // Sent when APZ detects checkerboarding and apz checkerboard reporting is enabled.
  async ReportCheckerboard(uint32_t severity, nsCString log);

  // Graphics errors, analogous to PContent::GraphicsError
  async GraphicsError(nsCString aError);

  async InitCrashReporter(Shmem shmem);

  // Have a message be broadcasted to the UI process by the UI process
  // observer service.
  async NotifyUiObservers(nsCString aTopic);

  // Messages for reporting telemetry to the UI process.
  async AccumulateChildHistograms(Accumulation[] accumulations);
  async AccumulateChildKeyedHistograms(KeyedAccumulation[] accumulations);
  async UpdateChildScalars(ScalarAction[] actions);
  async UpdateChildKeyedScalars(KeyedScalarAction[] actions);

  async NotifyDeviceReset();

  async AddMemoryReport(MemoryReport aReport);
  async FinishMemoryReport(uint32_t aGeneration);

} // namespace gfx
} // namespace mozilla