blob: 9d364ca84cb4caabe47ebc944c2b4df72b7cd923 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
library process_mojom;
import 'dart:async';
import 'package:mojo/bindings.dart' as bindings;
import 'package:mojo/core.dart' as core;
import 'package:mojo/mojo/bindings/types/service_describer.mojom.dart' as service_describer;
import 'package:mojo_services/mojo/files/file.mojom.dart' as file_mojom;
import 'package:mojo_services/mojo/files/types.mojom.dart' as types_mojom;
class _ProcessSpawnParams extends bindings.Struct {
static const List<bindings.StructDataHeader> kVersions = const [
const bindings.StructDataHeader(64, 0)
];
List<int> path = null;
List<List<int>> argv = null;
List<List<int>> envp = null;
Object stdinFile = null;
Object stdoutFile = null;
Object stderrFile = null;
Object processController = null;
_ProcessSpawnParams() : super(kVersions.last.size);
static _ProcessSpawnParams deserialize(bindings.Message message) {
var decoder = new bindings.Decoder(message);
var result = decode(decoder);
if (decoder.excessHandles != null) {
decoder.excessHandles.forEach((h) => h.close());
}
return result;
}
static _ProcessSpawnParams decode(bindings.Decoder decoder0) {
if (decoder0 == null) {
return null;
}
_ProcessSpawnParams result = new _ProcessSpawnParams();
var mainDataHeader = decoder0.decodeStructDataHeader();
if (mainDataHeader.version <= kVersions.last.version) {
// Scan in reverse order to optimize for more recent versions.
for (int i = kVersions.length - 1; i >= 0; --i) {
if (mainDataHeader.version >= kVersions[i].version) {
if (mainDataHeader.size == kVersions[i].size) {
// Found a match.
break;
}
throw new bindings.MojoCodecError(
'Header size doesn\'t correspond to known version size.');
}
}
} else if (mainDataHeader.size < kVersions.last.size) {
throw new bindings.MojoCodecError(
'Message newer than the last known version cannot be shorter than '
'required by the last known version.');
}
if (mainDataHeader.version >= 0) {
result.path = decoder0.decodeUint8Array(8, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
}
if (mainDataHeader.version >= 0) {
var decoder1 = decoder0.decodePointer(16, true);
if (decoder1 == null) {
result.argv = null;
} else {
var si1 = decoder1.decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength);
result.argv = new List<List<int>>(si1.numElements);
for (int i1 = 0; i1 < si1.numElements; ++i1) {
result.argv[i1] = decoder1.decodeUint8Array(bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
}
}
}
if (mainDataHeader.version >= 0) {
var decoder1 = decoder0.decodePointer(24, true);
if (decoder1 == null) {
result.envp = null;
} else {
var si1 = decoder1.decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength);
result.envp = new List<List<int>>(si1.numElements);
for (int i1 = 0; i1 < si1.numElements; ++i1) {
result.envp[i1] = decoder1.decodeUint8Array(bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
}
}
}
if (mainDataHeader.version >= 0) {
result.stdinFile = decoder0.decodeServiceInterface(32, true, file_mojom.FileProxy.newFromEndpoint);
}
if (mainDataHeader.version >= 0) {
result.stdoutFile = decoder0.decodeServiceInterface(40, true, file_mojom.FileProxy.newFromEndpoint);
}
if (mainDataHeader.version >= 0) {
result.stderrFile = decoder0.decodeServiceInterface(48, true, file_mojom.FileProxy.newFromEndpoint);
}
if (mainDataHeader.version >= 0) {
result.processController = decoder0.decodeInterfaceRequest(56, false, ProcessControllerStub.newFromEndpoint);
}
return result;
}
void encode(bindings.Encoder encoder) {
var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
try {
encoder0.encodeUint8Array(path, 8, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"path of struct _ProcessSpawnParams: $e";
rethrow;
}
try {
if (argv == null) {
encoder0.encodeNullPointer(16, true);
} else {
var encoder1 = encoder0.encodePointerArray(argv.length, 16, bindings.kUnspecifiedArrayLength);
for (int i0 = 0; i0 < argv.length; ++i0) {
encoder1.encodeUint8Array(argv[i0], bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
}
}
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"argv of struct _ProcessSpawnParams: $e";
rethrow;
}
try {
if (envp == null) {
encoder0.encodeNullPointer(24, true);
} else {
var encoder1 = encoder0.encodePointerArray(envp.length, 24, bindings.kUnspecifiedArrayLength);
for (int i0 = 0; i0 < envp.length; ++i0) {
encoder1.encodeUint8Array(envp[i0], bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
}
}
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"envp of struct _ProcessSpawnParams: $e";
rethrow;
}
try {
encoder0.encodeInterface(stdinFile, 32, true);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"stdinFile of struct _ProcessSpawnParams: $e";
rethrow;
}
try {
encoder0.encodeInterface(stdoutFile, 40, true);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"stdoutFile of struct _ProcessSpawnParams: $e";
rethrow;
}
try {
encoder0.encodeInterface(stderrFile, 48, true);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"stderrFile of struct _ProcessSpawnParams: $e";
rethrow;
}
try {
encoder0.encodeInterfaceRequest(processController, 56, false);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"processController of struct _ProcessSpawnParams: $e";
rethrow;
}
}
String toString() {
return "_ProcessSpawnParams("
"path: $path" ", "
"argv: $argv" ", "
"envp: $envp" ", "
"stdinFile: $stdinFile" ", "
"stdoutFile: $stdoutFile" ", "
"stderrFile: $stderrFile" ", "
"processController: $processController" ")";
}
Map toJson() {
throw new bindings.MojoCodecError(
'Object containing handles cannot be encoded to JSON.');
}
}
class ProcessSpawnResponseParams extends bindings.Struct {
static const List<bindings.StructDataHeader> kVersions = const [
const bindings.StructDataHeader(16, 0)
];
types_mojom.Error error = null;
ProcessSpawnResponseParams() : super(kVersions.last.size);
static ProcessSpawnResponseParams deserialize(bindings.Message message) {
var decoder = new bindings.Decoder(message);
var result = decode(decoder);
if (decoder.excessHandles != null) {
decoder.excessHandles.forEach((h) => h.close());
}
return result;
}
static ProcessSpawnResponseParams decode(bindings.Decoder decoder0) {
if (decoder0 == null) {
return null;
}
ProcessSpawnResponseParams result = new ProcessSpawnResponseParams();
var mainDataHeader = decoder0.decodeStructDataHeader();
if (mainDataHeader.version <= kVersions.last.version) {
// Scan in reverse order to optimize for more recent versions.
for (int i = kVersions.length - 1; i >= 0; --i) {
if (mainDataHeader.version >= kVersions[i].version) {
if (mainDataHeader.size == kVersions[i].size) {
// Found a match.
break;
}
throw new bindings.MojoCodecError(
'Header size doesn\'t correspond to known version size.');
}
}
} else if (mainDataHeader.size < kVersions.last.size) {
throw new bindings.MojoCodecError(
'Message newer than the last known version cannot be shorter than '
'required by the last known version.');
}
if (mainDataHeader.version >= 0) {
result.error = types_mojom.Error.decode(decoder0, 8);
if (result.error == null) {
throw new bindings.MojoCodecError(
'Trying to decode null union for non-nullable types_mojom.Error.');
}
}
return result;
}
void encode(bindings.Encoder encoder) {
var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
try {
encoder0.encodeEnum(error, 8);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"error of struct ProcessSpawnResponseParams: $e";
rethrow;
}
}
String toString() {
return "ProcessSpawnResponseParams("
"error: $error" ")";
}
Map toJson() {
Map map = new Map();
map["error"] = error;
return map;
}
}
class _ProcessSpawnWithTerminalParams extends bindings.Struct {
static const List<bindings.StructDataHeader> kVersions = const [
const bindings.StructDataHeader(48, 0)
];
List<int> path = null;
List<List<int>> argv = null;
List<List<int>> envp = null;
Object terminalFile = null;
Object processController = null;
_ProcessSpawnWithTerminalParams() : super(kVersions.last.size);
static _ProcessSpawnWithTerminalParams deserialize(bindings.Message message) {
var decoder = new bindings.Decoder(message);
var result = decode(decoder);
if (decoder.excessHandles != null) {
decoder.excessHandles.forEach((h) => h.close());
}
return result;
}
static _ProcessSpawnWithTerminalParams decode(bindings.Decoder decoder0) {
if (decoder0 == null) {
return null;
}
_ProcessSpawnWithTerminalParams result = new _ProcessSpawnWithTerminalParams();
var mainDataHeader = decoder0.decodeStructDataHeader();
if (mainDataHeader.version <= kVersions.last.version) {
// Scan in reverse order to optimize for more recent versions.
for (int i = kVersions.length - 1; i >= 0; --i) {
if (mainDataHeader.version >= kVersions[i].version) {
if (mainDataHeader.size == kVersions[i].size) {
// Found a match.
break;
}
throw new bindings.MojoCodecError(
'Header size doesn\'t correspond to known version size.');
}
}
} else if (mainDataHeader.size < kVersions.last.size) {
throw new bindings.MojoCodecError(
'Message newer than the last known version cannot be shorter than '
'required by the last known version.');
}
if (mainDataHeader.version >= 0) {
result.path = decoder0.decodeUint8Array(8, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
}
if (mainDataHeader.version >= 0) {
var decoder1 = decoder0.decodePointer(16, true);
if (decoder1 == null) {
result.argv = null;
} else {
var si1 = decoder1.decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength);
result.argv = new List<List<int>>(si1.numElements);
for (int i1 = 0; i1 < si1.numElements; ++i1) {
result.argv[i1] = decoder1.decodeUint8Array(bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
}
}
}
if (mainDataHeader.version >= 0) {
var decoder1 = decoder0.decodePointer(24, true);
if (decoder1 == null) {
result.envp = null;
} else {
var si1 = decoder1.decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength);
result.envp = new List<List<int>>(si1.numElements);
for (int i1 = 0; i1 < si1.numElements; ++i1) {
result.envp[i1] = decoder1.decodeUint8Array(bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
}
}
}
if (mainDataHeader.version >= 0) {
result.terminalFile = decoder0.decodeServiceInterface(32, false, file_mojom.FileProxy.newFromEndpoint);
}
if (mainDataHeader.version >= 0) {
result.processController = decoder0.decodeInterfaceRequest(40, false, ProcessControllerStub.newFromEndpoint);
}
return result;
}
void encode(bindings.Encoder encoder) {
var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
try {
encoder0.encodeUint8Array(path, 8, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"path of struct _ProcessSpawnWithTerminalParams: $e";
rethrow;
}
try {
if (argv == null) {
encoder0.encodeNullPointer(16, true);
} else {
var encoder1 = encoder0.encodePointerArray(argv.length, 16, bindings.kUnspecifiedArrayLength);
for (int i0 = 0; i0 < argv.length; ++i0) {
encoder1.encodeUint8Array(argv[i0], bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
}
}
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"argv of struct _ProcessSpawnWithTerminalParams: $e";
rethrow;
}
try {
if (envp == null) {
encoder0.encodeNullPointer(24, true);
} else {
var encoder1 = encoder0.encodePointerArray(envp.length, 24, bindings.kUnspecifiedArrayLength);
for (int i0 = 0; i0 < envp.length; ++i0) {
encoder1.encodeUint8Array(envp[i0], bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, bindings.kNothingNullable, bindings.kUnspecifiedArrayLength);
}
}
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"envp of struct _ProcessSpawnWithTerminalParams: $e";
rethrow;
}
try {
encoder0.encodeInterface(terminalFile, 32, false);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"terminalFile of struct _ProcessSpawnWithTerminalParams: $e";
rethrow;
}
try {
encoder0.encodeInterfaceRequest(processController, 40, false);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"processController of struct _ProcessSpawnWithTerminalParams: $e";
rethrow;
}
}
String toString() {
return "_ProcessSpawnWithTerminalParams("
"path: $path" ", "
"argv: $argv" ", "
"envp: $envp" ", "
"terminalFile: $terminalFile" ", "
"processController: $processController" ")";
}
Map toJson() {
throw new bindings.MojoCodecError(
'Object containing handles cannot be encoded to JSON.');
}
}
class ProcessSpawnWithTerminalResponseParams extends bindings.Struct {
static const List<bindings.StructDataHeader> kVersions = const [
const bindings.StructDataHeader(16, 0)
];
types_mojom.Error error = null;
ProcessSpawnWithTerminalResponseParams() : super(kVersions.last.size);
static ProcessSpawnWithTerminalResponseParams deserialize(bindings.Message message) {
var decoder = new bindings.Decoder(message);
var result = decode(decoder);
if (decoder.excessHandles != null) {
decoder.excessHandles.forEach((h) => h.close());
}
return result;
}
static ProcessSpawnWithTerminalResponseParams decode(bindings.Decoder decoder0) {
if (decoder0 == null) {
return null;
}
ProcessSpawnWithTerminalResponseParams result = new ProcessSpawnWithTerminalResponseParams();
var mainDataHeader = decoder0.decodeStructDataHeader();
if (mainDataHeader.version <= kVersions.last.version) {
// Scan in reverse order to optimize for more recent versions.
for (int i = kVersions.length - 1; i >= 0; --i) {
if (mainDataHeader.version >= kVersions[i].version) {
if (mainDataHeader.size == kVersions[i].size) {
// Found a match.
break;
}
throw new bindings.MojoCodecError(
'Header size doesn\'t correspond to known version size.');
}
}
} else if (mainDataHeader.size < kVersions.last.size) {
throw new bindings.MojoCodecError(
'Message newer than the last known version cannot be shorter than '
'required by the last known version.');
}
if (mainDataHeader.version >= 0) {
result.error = types_mojom.Error.decode(decoder0, 8);
if (result.error == null) {
throw new bindings.MojoCodecError(
'Trying to decode null union for non-nullable types_mojom.Error.');
}
}
return result;
}
void encode(bindings.Encoder encoder) {
var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
try {
encoder0.encodeEnum(error, 8);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"error of struct ProcessSpawnWithTerminalResponseParams: $e";
rethrow;
}
}
String toString() {
return "ProcessSpawnWithTerminalResponseParams("
"error: $error" ")";
}
Map toJson() {
Map map = new Map();
map["error"] = error;
return map;
}
}
class _ProcessControllerWaitParams extends bindings.Struct {
static const List<bindings.StructDataHeader> kVersions = const [
const bindings.StructDataHeader(8, 0)
];
_ProcessControllerWaitParams() : super(kVersions.last.size);
static _ProcessControllerWaitParams deserialize(bindings.Message message) {
var decoder = new bindings.Decoder(message);
var result = decode(decoder);
if (decoder.excessHandles != null) {
decoder.excessHandles.forEach((h) => h.close());
}
return result;
}
static _ProcessControllerWaitParams decode(bindings.Decoder decoder0) {
if (decoder0 == null) {
return null;
}
_ProcessControllerWaitParams result = new _ProcessControllerWaitParams();
var mainDataHeader = decoder0.decodeStructDataHeader();
if (mainDataHeader.version <= kVersions.last.version) {
// Scan in reverse order to optimize for more recent versions.
for (int i = kVersions.length - 1; i >= 0; --i) {
if (mainDataHeader.version >= kVersions[i].version) {
if (mainDataHeader.size == kVersions[i].size) {
// Found a match.
break;
}
throw new bindings.MojoCodecError(
'Header size doesn\'t correspond to known version size.');
}
}
} else if (mainDataHeader.size < kVersions.last.size) {
throw new bindings.MojoCodecError(
'Message newer than the last known version cannot be shorter than '
'required by the last known version.');
}
return result;
}
void encode(bindings.Encoder encoder) {
encoder.getStructEncoderAtOffset(kVersions.last);
}
String toString() {
return "_ProcessControllerWaitParams("")";
}
Map toJson() {
Map map = new Map();
return map;
}
}
class ProcessControllerWaitResponseParams extends bindings.Struct {
static const List<bindings.StructDataHeader> kVersions = const [
const bindings.StructDataHeader(16, 0)
];
types_mojom.Error error = null;
int exitStatus = 0;
ProcessControllerWaitResponseParams() : super(kVersions.last.size);
static ProcessControllerWaitResponseParams deserialize(bindings.Message message) {
var decoder = new bindings.Decoder(message);
var result = decode(decoder);
if (decoder.excessHandles != null) {
decoder.excessHandles.forEach((h) => h.close());
}
return result;
}
static ProcessControllerWaitResponseParams decode(bindings.Decoder decoder0) {
if (decoder0 == null) {
return null;
}
ProcessControllerWaitResponseParams result = new ProcessControllerWaitResponseParams();
var mainDataHeader = decoder0.decodeStructDataHeader();
if (mainDataHeader.version <= kVersions.last.version) {
// Scan in reverse order to optimize for more recent versions.
for (int i = kVersions.length - 1; i >= 0; --i) {
if (mainDataHeader.version >= kVersions[i].version) {
if (mainDataHeader.size == kVersions[i].size) {
// Found a match.
break;
}
throw new bindings.MojoCodecError(
'Header size doesn\'t correspond to known version size.');
}
}
} else if (mainDataHeader.size < kVersions.last.size) {
throw new bindings.MojoCodecError(
'Message newer than the last known version cannot be shorter than '
'required by the last known version.');
}
if (mainDataHeader.version >= 0) {
result.error = types_mojom.Error.decode(decoder0, 8);
if (result.error == null) {
throw new bindings.MojoCodecError(
'Trying to decode null union for non-nullable types_mojom.Error.');
}
}
if (mainDataHeader.version >= 0) {
result.exitStatus = decoder0.decodeInt32(12);
}
return result;
}
void encode(bindings.Encoder encoder) {
var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
try {
encoder0.encodeEnum(error, 8);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"error of struct ProcessControllerWaitResponseParams: $e";
rethrow;
}
try {
encoder0.encodeInt32(exitStatus, 12);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"exitStatus of struct ProcessControllerWaitResponseParams: $e";
rethrow;
}
}
String toString() {
return "ProcessControllerWaitResponseParams("
"error: $error" ", "
"exitStatus: $exitStatus" ")";
}
Map toJson() {
Map map = new Map();
map["error"] = error;
map["exitStatus"] = exitStatus;
return map;
}
}
class _ProcessControllerKillParams extends bindings.Struct {
static const List<bindings.StructDataHeader> kVersions = const [
const bindings.StructDataHeader(16, 0)
];
int signal = 0;
_ProcessControllerKillParams() : super(kVersions.last.size);
static _ProcessControllerKillParams deserialize(bindings.Message message) {
var decoder = new bindings.Decoder(message);
var result = decode(decoder);
if (decoder.excessHandles != null) {
decoder.excessHandles.forEach((h) => h.close());
}
return result;
}
static _ProcessControllerKillParams decode(bindings.Decoder decoder0) {
if (decoder0 == null) {
return null;
}
_ProcessControllerKillParams result = new _ProcessControllerKillParams();
var mainDataHeader = decoder0.decodeStructDataHeader();
if (mainDataHeader.version <= kVersions.last.version) {
// Scan in reverse order to optimize for more recent versions.
for (int i = kVersions.length - 1; i >= 0; --i) {
if (mainDataHeader.version >= kVersions[i].version) {
if (mainDataHeader.size == kVersions[i].size) {
// Found a match.
break;
}
throw new bindings.MojoCodecError(
'Header size doesn\'t correspond to known version size.');
}
}
} else if (mainDataHeader.size < kVersions.last.size) {
throw new bindings.MojoCodecError(
'Message newer than the last known version cannot be shorter than '
'required by the last known version.');
}
if (mainDataHeader.version >= 0) {
result.signal = decoder0.decodeInt32(8);
}
return result;
}
void encode(bindings.Encoder encoder) {
var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
try {
encoder0.encodeInt32(signal, 8);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"signal of struct _ProcessControllerKillParams: $e";
rethrow;
}
}
String toString() {
return "_ProcessControllerKillParams("
"signal: $signal" ")";
}
Map toJson() {
Map map = new Map();
map["signal"] = signal;
return map;
}
}
class ProcessControllerKillResponseParams extends bindings.Struct {
static const List<bindings.StructDataHeader> kVersions = const [
const bindings.StructDataHeader(16, 0)
];
types_mojom.Error error = null;
ProcessControllerKillResponseParams() : super(kVersions.last.size);
static ProcessControllerKillResponseParams deserialize(bindings.Message message) {
var decoder = new bindings.Decoder(message);
var result = decode(decoder);
if (decoder.excessHandles != null) {
decoder.excessHandles.forEach((h) => h.close());
}
return result;
}
static ProcessControllerKillResponseParams decode(bindings.Decoder decoder0) {
if (decoder0 == null) {
return null;
}
ProcessControllerKillResponseParams result = new ProcessControllerKillResponseParams();
var mainDataHeader = decoder0.decodeStructDataHeader();
if (mainDataHeader.version <= kVersions.last.version) {
// Scan in reverse order to optimize for more recent versions.
for (int i = kVersions.length - 1; i >= 0; --i) {
if (mainDataHeader.version >= kVersions[i].version) {
if (mainDataHeader.size == kVersions[i].size) {
// Found a match.
break;
}
throw new bindings.MojoCodecError(
'Header size doesn\'t correspond to known version size.');
}
}
} else if (mainDataHeader.size < kVersions.last.size) {
throw new bindings.MojoCodecError(
'Message newer than the last known version cannot be shorter than '
'required by the last known version.');
}
if (mainDataHeader.version >= 0) {
result.error = types_mojom.Error.decode(decoder0, 8);
if (result.error == null) {
throw new bindings.MojoCodecError(
'Trying to decode null union for non-nullable types_mojom.Error.');
}
}
return result;
}
void encode(bindings.Encoder encoder) {
var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
try {
encoder0.encodeEnum(error, 8);
} on bindings.MojoCodecError catch(e) {
e.message = "Error encountered while encoding field "
"error of struct ProcessControllerKillResponseParams: $e";
rethrow;
}
}
String toString() {
return "ProcessControllerKillResponseParams("
"error: $error" ")";
}
Map toJson() {
Map map = new Map();
map["error"] = error;
return map;
}
}
const int _processMethodSpawnName = 0;
const int _processMethodSpawnWithTerminalName = 1;
class _ProcessServiceDescription implements service_describer.ServiceDescription {
dynamic getTopLevelInterface([Function responseFactory]) =>
responseFactory(null);
dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
responseFactory(null);
dynamic getAllTypeDefinitions([Function responseFactory]) =>
responseFactory(null);
}
abstract class Process {
static const String serviceName = "native_support::Process";
dynamic spawn(List<int> path,List<List<int>> argv,List<List<int>> envp,Object stdinFile,Object stdoutFile,Object stderrFile,Object processController,[Function responseFactory = null]);
dynamic spawnWithTerminal(List<int> path,List<List<int>> argv,List<List<int>> envp,Object terminalFile,Object processController,[Function responseFactory = null]);
}
class _ProcessProxyControl
extends bindings.ProxyMessageHandler
implements bindings.ProxyControl {
_ProcessProxyControl.fromEndpoint(
core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
_ProcessProxyControl.fromHandle(
core.MojoHandle handle) : super.fromHandle(handle);
_ProcessProxyControl.unbound() : super.unbound();
service_describer.ServiceDescription get serviceDescription =>
new _ProcessServiceDescription();
String get serviceName => Process.serviceName;
void handleResponse(bindings.ServiceMessage message) {
switch (message.header.type) {
case _processMethodSpawnName:
var r = ProcessSpawnResponseParams.deserialize(
message.payload);
if (!message.header.hasRequestId) {
proxyError("Expected a message with a valid request Id.");
return;
}
Completer c = completerMap[message.header.requestId];
if (c == null) {
proxyError(
"Message had unknown request Id: ${message.header.requestId}");
return;
}
completerMap.remove(message.header.requestId);
if (c.isCompleted) {
proxyError("Response completer already completed");
return;
}
c.complete(r);
break;
case _processMethodSpawnWithTerminalName:
var r = ProcessSpawnWithTerminalResponseParams.deserialize(
message.payload);
if (!message.header.hasRequestId) {
proxyError("Expected a message with a valid request Id.");
return;
}
Completer c = completerMap[message.header.requestId];
if (c == null) {
proxyError(
"Message had unknown request Id: ${message.header.requestId}");
return;
}
completerMap.remove(message.header.requestId);
if (c.isCompleted) {
proxyError("Response completer already completed");
return;
}
c.complete(r);
break;
default:
proxyError("Unexpected message type: ${message.header.type}");
close(immediate: true);
break;
}
}
@override
String toString() {
var superString = super.toString();
return "_ProcessProxyControl($superString)";
}
}
class ProcessProxy
extends bindings.Proxy
implements Process {
ProcessProxy.fromEndpoint(
core.MojoMessagePipeEndpoint endpoint)
: super(new _ProcessProxyControl.fromEndpoint(endpoint));
ProcessProxy.fromHandle(core.MojoHandle handle)
: super(new _ProcessProxyControl.fromHandle(handle));
ProcessProxy.unbound()
: super(new _ProcessProxyControl.unbound());
static ProcessProxy newFromEndpoint(
core.MojoMessagePipeEndpoint endpoint) {
assert(endpoint.setDescription("For ProcessProxy"));
return new ProcessProxy.fromEndpoint(endpoint);
}
factory ProcessProxy.connectToService(
bindings.ServiceConnector s, String url, [String serviceName]) {
ProcessProxy p = new ProcessProxy.unbound();
s.connectToService(url, p, serviceName);
return p;
}
dynamic spawn(List<int> path,List<List<int>> argv,List<List<int>> envp,Object stdinFile,Object stdoutFile,Object stderrFile,Object processController,[Function responseFactory = null]) {
var params = new _ProcessSpawnParams();
params.path = path;
params.argv = argv;
params.envp = envp;
params.stdinFile = stdinFile;
params.stdoutFile = stdoutFile;
params.stderrFile = stderrFile;
params.processController = processController;
return ctrl.sendMessageWithRequestId(
params,
_processMethodSpawnName,
-1,
bindings.MessageHeader.kMessageExpectsResponse);
}
dynamic spawnWithTerminal(List<int> path,List<List<int>> argv,List<List<int>> envp,Object terminalFile,Object processController,[Function responseFactory = null]) {
var params = new _ProcessSpawnWithTerminalParams();
params.path = path;
params.argv = argv;
params.envp = envp;
params.terminalFile = terminalFile;
params.processController = processController;
return ctrl.sendMessageWithRequestId(
params,
_processMethodSpawnWithTerminalName,
-1,
bindings.MessageHeader.kMessageExpectsResponse);
}
}
class _ProcessStubControl
extends bindings.StubMessageHandler
implements bindings.StubControl<Process> {
Process _impl;
_ProcessStubControl.fromEndpoint(
core.MojoMessagePipeEndpoint endpoint, [Process impl])
: super.fromEndpoint(endpoint, autoBegin: impl != null) {
_impl = impl;
}
_ProcessStubControl.fromHandle(
core.MojoHandle handle, [Process impl])
: super.fromHandle(handle, autoBegin: impl != null) {
_impl = impl;
}
_ProcessStubControl.unbound([this._impl]) : super.unbound();
ProcessSpawnResponseParams _processSpawnResponseParamsFactory(types_mojom.Error error) {
var result = new ProcessSpawnResponseParams();
result.error = error;
return result;
}
ProcessSpawnWithTerminalResponseParams _processSpawnWithTerminalResponseParamsFactory(types_mojom.Error error) {
var result = new ProcessSpawnWithTerminalResponseParams();
result.error = error;
return result;
}
dynamic handleMessage(bindings.ServiceMessage message) {
if (bindings.ControlMessageHandler.isControlMessage(message)) {
return bindings.ControlMessageHandler.handleMessage(this,
0,
message);
}
if (_impl == null) {
throw new core.MojoApiError("$this has no implementation set");
}
switch (message.header.type) {
case _processMethodSpawnName:
var params = _ProcessSpawnParams.deserialize(
message.payload);
var response = _impl.spawn(params.path,params.argv,params.envp,params.stdinFile,params.stdoutFile,params.stderrFile,params.processController,_processSpawnResponseParamsFactory);
if (response is Future) {
return response.then((response) {
if (response != null) {
return buildResponseWithId(
response,
_processMethodSpawnName,
message.header.requestId,
bindings.MessageHeader.kMessageIsResponse);
}
});
} else if (response != null) {
return buildResponseWithId(
response,
_processMethodSpawnName,
message.header.requestId,
bindings.MessageHeader.kMessageIsResponse);
}
break;
case _processMethodSpawnWithTerminalName:
var params = _ProcessSpawnWithTerminalParams.deserialize(
message.payload);
var response = _impl.spawnWithTerminal(params.path,params.argv,params.envp,params.terminalFile,params.processController,_processSpawnWithTerminalResponseParamsFactory);
if (response is Future) {
return response.then((response) {
if (response != null) {
return buildResponseWithId(
response,
_processMethodSpawnWithTerminalName,
message.header.requestId,
bindings.MessageHeader.kMessageIsResponse);
}
});
} else if (response != null) {
return buildResponseWithId(
response,
_processMethodSpawnWithTerminalName,
message.header.requestId,
bindings.MessageHeader.kMessageIsResponse);
}
break;
default:
throw new bindings.MojoCodecError("Unexpected message name");
break;
}
return null;
}
Process get impl => _impl;
set impl(Process d) {
if (d == null) {
throw new core.MojoApiError("$this: Cannot set a null implementation");
}
if (isBound && (_impl == null)) {
beginHandlingEvents();
}
_impl = d;
}
@override
void bind(core.MojoMessagePipeEndpoint endpoint) {
super.bind(endpoint);
if (!isOpen && (_impl != null)) {
beginHandlingEvents();
}
}
@override
String toString() {
var superString = super.toString();
return "_ProcessStubControl($superString)";
}
int get version => 0;
static service_describer.ServiceDescription _cachedServiceDescription;
static service_describer.ServiceDescription get serviceDescription {
if (_cachedServiceDescription == null) {
_cachedServiceDescription = new _ProcessServiceDescription();
}
return _cachedServiceDescription;
}
}
class ProcessStub
extends bindings.Stub<Process>
implements Process {
ProcessStub.fromEndpoint(
core.MojoMessagePipeEndpoint endpoint, [Process impl])
: super(new _ProcessStubControl.fromEndpoint(endpoint, impl));
ProcessStub.fromHandle(
core.MojoHandle handle, [Process impl])
: super(new _ProcessStubControl.fromHandle(handle, impl));
ProcessStub.unbound([Process impl])
: super(new _ProcessStubControl.unbound(impl));
static ProcessStub newFromEndpoint(
core.MojoMessagePipeEndpoint endpoint) {
assert(endpoint.setDescription("For ProcessStub"));
return new ProcessStub.fromEndpoint(endpoint);
}
static service_describer.ServiceDescription get serviceDescription =>
_ProcessStubControl.serviceDescription;
dynamic spawn(List<int> path,List<List<int>> argv,List<List<int>> envp,Object stdinFile,Object stdoutFile,Object stderrFile,Object processController,[Function responseFactory = null]) {
return impl.spawn(path,argv,envp,stdinFile,stdoutFile,stderrFile,processController,responseFactory);
}
dynamic spawnWithTerminal(List<int> path,List<List<int>> argv,List<List<int>> envp,Object terminalFile,Object processController,[Function responseFactory = null]) {
return impl.spawnWithTerminal(path,argv,envp,terminalFile,processController,responseFactory);
}
}
const int _processControllerMethodWaitName = 0;
const int _processControllerMethodKillName = 1;
class _ProcessControllerServiceDescription implements service_describer.ServiceDescription {
dynamic getTopLevelInterface([Function responseFactory]) =>
responseFactory(null);
dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
responseFactory(null);
dynamic getAllTypeDefinitions([Function responseFactory]) =>
responseFactory(null);
}
abstract class ProcessController {
static const String serviceName = null;
dynamic wait([Function responseFactory = null]);
dynamic kill(int signal,[Function responseFactory = null]);
}
class _ProcessControllerProxyControl
extends bindings.ProxyMessageHandler
implements bindings.ProxyControl {
_ProcessControllerProxyControl.fromEndpoint(
core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
_ProcessControllerProxyControl.fromHandle(
core.MojoHandle handle) : super.fromHandle(handle);
_ProcessControllerProxyControl.unbound() : super.unbound();
service_describer.ServiceDescription get serviceDescription =>
new _ProcessControllerServiceDescription();
String get serviceName => ProcessController.serviceName;
void handleResponse(bindings.ServiceMessage message) {
switch (message.header.type) {
case _processControllerMethodWaitName:
var r = ProcessControllerWaitResponseParams.deserialize(
message.payload);
if (!message.header.hasRequestId) {
proxyError("Expected a message with a valid request Id.");
return;
}
Completer c = completerMap[message.header.requestId];
if (c == null) {
proxyError(
"Message had unknown request Id: ${message.header.requestId}");
return;
}
completerMap.remove(message.header.requestId);
if (c.isCompleted) {
proxyError("Response completer already completed");
return;
}
c.complete(r);
break;
case _processControllerMethodKillName:
var r = ProcessControllerKillResponseParams.deserialize(
message.payload);
if (!message.header.hasRequestId) {
proxyError("Expected a message with a valid request Id.");
return;
}
Completer c = completerMap[message.header.requestId];
if (c == null) {
proxyError(
"Message had unknown request Id: ${message.header.requestId}");
return;
}
completerMap.remove(message.header.requestId);
if (c.isCompleted) {
proxyError("Response completer already completed");
return;
}
c.complete(r);
break;
default:
proxyError("Unexpected message type: ${message.header.type}");
close(immediate: true);
break;
}
}
@override
String toString() {
var superString = super.toString();
return "_ProcessControllerProxyControl($superString)";
}
}
class ProcessControllerProxy
extends bindings.Proxy
implements ProcessController {
ProcessControllerProxy.fromEndpoint(
core.MojoMessagePipeEndpoint endpoint)
: super(new _ProcessControllerProxyControl.fromEndpoint(endpoint));
ProcessControllerProxy.fromHandle(core.MojoHandle handle)
: super(new _ProcessControllerProxyControl.fromHandle(handle));
ProcessControllerProxy.unbound()
: super(new _ProcessControllerProxyControl.unbound());
static ProcessControllerProxy newFromEndpoint(
core.MojoMessagePipeEndpoint endpoint) {
assert(endpoint.setDescription("For ProcessControllerProxy"));
return new ProcessControllerProxy.fromEndpoint(endpoint);
}
factory ProcessControllerProxy.connectToService(
bindings.ServiceConnector s, String url, [String serviceName]) {
ProcessControllerProxy p = new ProcessControllerProxy.unbound();
s.connectToService(url, p, serviceName);
return p;
}
dynamic wait([Function responseFactory = null]) {
var params = new _ProcessControllerWaitParams();
return ctrl.sendMessageWithRequestId(
params,
_processControllerMethodWaitName,
-1,
bindings.MessageHeader.kMessageExpectsResponse);
}
dynamic kill(int signal,[Function responseFactory = null]) {
var params = new _ProcessControllerKillParams();
params.signal = signal;
return ctrl.sendMessageWithRequestId(
params,
_processControllerMethodKillName,
-1,
bindings.MessageHeader.kMessageExpectsResponse);
}
}
class _ProcessControllerStubControl
extends bindings.StubMessageHandler
implements bindings.StubControl<ProcessController> {
ProcessController _impl;
_ProcessControllerStubControl.fromEndpoint(
core.MojoMessagePipeEndpoint endpoint, [ProcessController impl])
: super.fromEndpoint(endpoint, autoBegin: impl != null) {
_impl = impl;
}
_ProcessControllerStubControl.fromHandle(
core.MojoHandle handle, [ProcessController impl])
: super.fromHandle(handle, autoBegin: impl != null) {
_impl = impl;
}
_ProcessControllerStubControl.unbound([this._impl]) : super.unbound();
ProcessControllerWaitResponseParams _processControllerWaitResponseParamsFactory(types_mojom.Error error, int exitStatus) {
var result = new ProcessControllerWaitResponseParams();
result.error = error;
result.exitStatus = exitStatus;
return result;
}
ProcessControllerKillResponseParams _processControllerKillResponseParamsFactory(types_mojom.Error error) {
var result = new ProcessControllerKillResponseParams();
result.error = error;
return result;
}
dynamic handleMessage(bindings.ServiceMessage message) {
if (bindings.ControlMessageHandler.isControlMessage(message)) {
return bindings.ControlMessageHandler.handleMessage(this,
0,
message);
}
if (_impl == null) {
throw new core.MojoApiError("$this has no implementation set");
}
switch (message.header.type) {
case _processControllerMethodWaitName:
var response = _impl.wait(_processControllerWaitResponseParamsFactory);
if (response is Future) {
return response.then((response) {
if (response != null) {
return buildResponseWithId(
response,
_processControllerMethodWaitName,
message.header.requestId,
bindings.MessageHeader.kMessageIsResponse);
}
});
} else if (response != null) {
return buildResponseWithId(
response,
_processControllerMethodWaitName,
message.header.requestId,
bindings.MessageHeader.kMessageIsResponse);
}
break;
case _processControllerMethodKillName:
var params = _ProcessControllerKillParams.deserialize(
message.payload);
var response = _impl.kill(params.signal,_processControllerKillResponseParamsFactory);
if (response is Future) {
return response.then((response) {
if (response != null) {
return buildResponseWithId(
response,
_processControllerMethodKillName,
message.header.requestId,
bindings.MessageHeader.kMessageIsResponse);
}
});
} else if (response != null) {
return buildResponseWithId(
response,
_processControllerMethodKillName,
message.header.requestId,
bindings.MessageHeader.kMessageIsResponse);
}
break;
default:
throw new bindings.MojoCodecError("Unexpected message name");
break;
}
return null;
}
ProcessController get impl => _impl;
set impl(ProcessController d) {
if (d == null) {
throw new core.MojoApiError("$this: Cannot set a null implementation");
}
if (isBound && (_impl == null)) {
beginHandlingEvents();
}
_impl = d;
}
@override
void bind(core.MojoMessagePipeEndpoint endpoint) {
super.bind(endpoint);
if (!isOpen && (_impl != null)) {
beginHandlingEvents();
}
}
@override
String toString() {
var superString = super.toString();
return "_ProcessControllerStubControl($superString)";
}
int get version => 0;
static service_describer.ServiceDescription _cachedServiceDescription;
static service_describer.ServiceDescription get serviceDescription {
if (_cachedServiceDescription == null) {
_cachedServiceDescription = new _ProcessControllerServiceDescription();
}
return _cachedServiceDescription;
}
}
class ProcessControllerStub
extends bindings.Stub<ProcessController>
implements ProcessController {
ProcessControllerStub.fromEndpoint(
core.MojoMessagePipeEndpoint endpoint, [ProcessController impl])
: super(new _ProcessControllerStubControl.fromEndpoint(endpoint, impl));
ProcessControllerStub.fromHandle(
core.MojoHandle handle, [ProcessController impl])
: super(new _ProcessControllerStubControl.fromHandle(handle, impl));
ProcessControllerStub.unbound([ProcessController impl])
: super(new _ProcessControllerStubControl.unbound(impl));
static ProcessControllerStub newFromEndpoint(
core.MojoMessagePipeEndpoint endpoint) {
assert(endpoint.setDescription("For ProcessControllerStub"));
return new ProcessControllerStub.fromEndpoint(endpoint);
}
static service_describer.ServiceDescription get serviceDescription =>
_ProcessControllerStubControl.serviceDescription;
dynamic wait([Function responseFactory = null]) {
return impl.wait(responseFactory);
}
dynamic kill(int signal,[Function responseFactory = null]) {
return impl.kill(signal,responseFactory);
}
}