| // 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. |
| |
| 'use strict'; |
| |
| (function() { |
| var mojomId = 'services/service_manager/tests/connect/connect.test-mojom'; |
| if (mojo.internal.isMojomLoaded(mojomId)) { |
| console.warn('The following mojom is loaded multiple times: ' + mojomId); |
| return; |
| } |
| mojo.internal.markMojomLoaded(mojomId); |
| var bindings = mojo; |
| var associatedBindings = mojo; |
| var codec = mojo.internal; |
| var validator = mojo.internal; |
| |
| var exports = mojo.internal.exposeNamespace('serviceManager.test.mojom'); |
| var token$ = |
| mojo.internal.exposeNamespace('mojoBase.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'mojo/public/mojom/base/token.mojom', '../../../../mojo/public/mojom/base/token.mojom.js'); |
| } |
| var connector$ = |
| mojo.internal.exposeNamespace('serviceManager.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'services/service_manager/public/mojom/connector.mojom', '../../public/mojom/connector.mojom.js'); |
| } |
| var service_filter$ = |
| mojo.internal.exposeNamespace('serviceManager.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'services/service_manager/public/mojom/service_filter.mojom', '../../public/mojom/service_filter.mojom.js'); |
| } |
| |
| |
| |
| function ConnectionState(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| ConnectionState.prototype.initDefaults_ = function() { |
| this.connectionRemoteName = null; |
| this.connectionRemoteInstanceGroup = null; |
| this.initializeLocalName = null; |
| this.initializeLocalInstanceGroup = null; |
| }; |
| ConnectionState.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| ConnectionState.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 40} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate ConnectionState.connectionRemoteName |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate ConnectionState.connectionRemoteInstanceGroup |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 8, token$.Token, true); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate ConnectionState.initializeLocalName |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 16, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate ConnectionState.initializeLocalInstanceGroup |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 24, token$.Token, true); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| ConnectionState.encodedSize = codec.kStructHeaderSize + 32; |
| |
| ConnectionState.decode = function(decoder) { |
| var packed; |
| var val = new ConnectionState(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.connectionRemoteName = decoder.decodeStruct(codec.String); |
| val.connectionRemoteInstanceGroup = decoder.decodeStructPointer(token$.Token); |
| val.initializeLocalName = decoder.decodeStruct(codec.String); |
| val.initializeLocalInstanceGroup = decoder.decodeStructPointer(token$.Token); |
| return val; |
| }; |
| |
| ConnectionState.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(ConnectionState.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.connectionRemoteName); |
| encoder.encodeStructPointer(token$.Token, val.connectionRemoteInstanceGroup); |
| encoder.encodeStruct(codec.String, val.initializeLocalName); |
| encoder.encodeStructPointer(token$.Token, val.initializeLocalInstanceGroup); |
| }; |
| function ConnectTestService_GetTitle_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| ConnectTestService_GetTitle_Params.prototype.initDefaults_ = function() { |
| }; |
| ConnectTestService_GetTitle_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| ConnectTestService_GetTitle_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 8} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| ConnectTestService_GetTitle_Params.encodedSize = codec.kStructHeaderSize + 0; |
| |
| ConnectTestService_GetTitle_Params.decode = function(decoder) { |
| var packed; |
| var val = new ConnectTestService_GetTitle_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| return val; |
| }; |
| |
| ConnectTestService_GetTitle_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(ConnectTestService_GetTitle_Params.encodedSize); |
| encoder.writeUint32(0); |
| }; |
| function ConnectTestService_GetTitle_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| ConnectTestService_GetTitle_ResponseParams.prototype.initDefaults_ = function() { |
| this.title = null; |
| }; |
| ConnectTestService_GetTitle_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| ConnectTestService_GetTitle_ResponseParams.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 16} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate ConnectTestService_GetTitle_ResponseParams.title |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| ConnectTestService_GetTitle_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| ConnectTestService_GetTitle_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new ConnectTestService_GetTitle_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.title = decoder.decodeStruct(codec.String); |
| return val; |
| }; |
| |
| ConnectTestService_GetTitle_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(ConnectTestService_GetTitle_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.title); |
| }; |
| function ConnectTestService_GetInstanceId_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| ConnectTestService_GetInstanceId_Params.prototype.initDefaults_ = function() { |
| }; |
| ConnectTestService_GetInstanceId_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| ConnectTestService_GetInstanceId_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 8} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| ConnectTestService_GetInstanceId_Params.encodedSize = codec.kStructHeaderSize + 0; |
| |
| ConnectTestService_GetInstanceId_Params.decode = function(decoder) { |
| var packed; |
| var val = new ConnectTestService_GetInstanceId_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| return val; |
| }; |
| |
| ConnectTestService_GetInstanceId_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(ConnectTestService_GetInstanceId_Params.encodedSize); |
| encoder.writeUint32(0); |
| }; |
| function ConnectTestService_GetInstanceId_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| ConnectTestService_GetInstanceId_ResponseParams.prototype.initDefaults_ = function() { |
| this.instanceId = null; |
| }; |
| ConnectTestService_GetInstanceId_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| ConnectTestService_GetInstanceId_ResponseParams.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 16} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate ConnectTestService_GetInstanceId_ResponseParams.instanceId |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, token$.Token, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| ConnectTestService_GetInstanceId_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| ConnectTestService_GetInstanceId_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new ConnectTestService_GetInstanceId_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.instanceId = decoder.decodeStructPointer(token$.Token); |
| return val; |
| }; |
| |
| ConnectTestService_GetInstanceId_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(ConnectTestService_GetInstanceId_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(token$.Token, val.instanceId); |
| }; |
| function ClassInterface_Ping_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| ClassInterface_Ping_Params.prototype.initDefaults_ = function() { |
| }; |
| ClassInterface_Ping_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| ClassInterface_Ping_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 8} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| ClassInterface_Ping_Params.encodedSize = codec.kStructHeaderSize + 0; |
| |
| ClassInterface_Ping_Params.decode = function(decoder) { |
| var packed; |
| var val = new ClassInterface_Ping_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| return val; |
| }; |
| |
| ClassInterface_Ping_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(ClassInterface_Ping_Params.encodedSize); |
| encoder.writeUint32(0); |
| }; |
| function ClassInterface_Ping_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| ClassInterface_Ping_ResponseParams.prototype.initDefaults_ = function() { |
| this.response = null; |
| }; |
| ClassInterface_Ping_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| ClassInterface_Ping_ResponseParams.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 16} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate ClassInterface_Ping_ResponseParams.response |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| ClassInterface_Ping_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| ClassInterface_Ping_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new ClassInterface_Ping_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.response = decoder.decodeStruct(codec.String); |
| return val; |
| }; |
| |
| ClassInterface_Ping_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(ClassInterface_Ping_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.response); |
| }; |
| function StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params.prototype.initDefaults_ = function() { |
| }; |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 8} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params.encodedSize = codec.kStructHeaderSize + 0; |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params.decode = function(decoder) { |
| var packed; |
| var val = new StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| return val; |
| }; |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params.encodedSize); |
| encoder.writeUint32(0); |
| }; |
| function StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams.prototype.initDefaults_ = function() { |
| this.title = null; |
| }; |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 16} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams.title |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.title = decoder.decodeStruct(codec.String); |
| return val; |
| }; |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.title); |
| }; |
| function StandaloneApp_ConnectToClassInterface_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| StandaloneApp_ConnectToClassInterface_Params.prototype.initDefaults_ = function() { |
| }; |
| StandaloneApp_ConnectToClassInterface_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| StandaloneApp_ConnectToClassInterface_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 8} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| StandaloneApp_ConnectToClassInterface_Params.encodedSize = codec.kStructHeaderSize + 0; |
| |
| StandaloneApp_ConnectToClassInterface_Params.decode = function(decoder) { |
| var packed; |
| var val = new StandaloneApp_ConnectToClassInterface_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| return val; |
| }; |
| |
| StandaloneApp_ConnectToClassInterface_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(StandaloneApp_ConnectToClassInterface_Params.encodedSize); |
| encoder.writeUint32(0); |
| }; |
| function StandaloneApp_ConnectToClassInterface_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| StandaloneApp_ConnectToClassInterface_ResponseParams.prototype.initDefaults_ = function() { |
| this.classInterfaceResponse = null; |
| this.title = null; |
| }; |
| StandaloneApp_ConnectToClassInterface_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| StandaloneApp_ConnectToClassInterface_ResponseParams.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 24} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate StandaloneApp_ConnectToClassInterface_ResponseParams.classInterfaceResponse |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate StandaloneApp_ConnectToClassInterface_ResponseParams.title |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 8, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| StandaloneApp_ConnectToClassInterface_ResponseParams.encodedSize = codec.kStructHeaderSize + 16; |
| |
| StandaloneApp_ConnectToClassInterface_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new StandaloneApp_ConnectToClassInterface_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.classInterfaceResponse = decoder.decodeStruct(codec.String); |
| val.title = decoder.decodeStruct(codec.String); |
| return val; |
| }; |
| |
| StandaloneApp_ConnectToClassInterface_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(StandaloneApp_ConnectToClassInterface_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.classInterfaceResponse); |
| encoder.encodeStruct(codec.String, val.title); |
| }; |
| function IdentityTest_ConnectToClassAppWithFilter_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| IdentityTest_ConnectToClassAppWithFilter_Params.prototype.initDefaults_ = function() { |
| this.filter = null; |
| }; |
| IdentityTest_ConnectToClassAppWithFilter_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| IdentityTest_ConnectToClassAppWithFilter_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 16} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate IdentityTest_ConnectToClassAppWithFilter_Params.filter |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, service_filter$.ServiceFilter, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| IdentityTest_ConnectToClassAppWithFilter_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| IdentityTest_ConnectToClassAppWithFilter_Params.decode = function(decoder) { |
| var packed; |
| var val = new IdentityTest_ConnectToClassAppWithFilter_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.filter = decoder.decodeStructPointer(service_filter$.ServiceFilter); |
| return val; |
| }; |
| |
| IdentityTest_ConnectToClassAppWithFilter_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(IdentityTest_ConnectToClassAppWithFilter_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(service_filter$.ServiceFilter, val.filter); |
| }; |
| function IdentityTest_ConnectToClassAppWithFilter_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParams.prototype.initDefaults_ = function() { |
| this.connectionResult = 0; |
| this.identity = null; |
| }; |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParams.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 24} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| |
| // validate IdentityTest_ConnectToClassAppWithFilter_ResponseParams.identity |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 8, connector$.Identity, true); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParams.encodedSize = codec.kStructHeaderSize + 16; |
| |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new IdentityTest_ConnectToClassAppWithFilter_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.connectionResult = decoder.decodeStruct(codec.Int32); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| val.identity = decoder.decodeStructPointer(connector$.Identity); |
| return val; |
| }; |
| |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(IdentityTest_ConnectToClassAppWithFilter_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.Int32, val.connectionResult); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.encodeStructPointer(connector$.Identity, val.identity); |
| }; |
| function ExposedInterface_ConnectionAccepted_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| ExposedInterface_ConnectionAccepted_Params.prototype.initDefaults_ = function() { |
| this.state = null; |
| }; |
| ExposedInterface_ConnectionAccepted_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| ExposedInterface_ConnectionAccepted_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 16} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate ExposedInterface_ConnectionAccepted_Params.state |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, ConnectionState, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| ExposedInterface_ConnectionAccepted_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| ExposedInterface_ConnectionAccepted_Params.decode = function(decoder) { |
| var packed; |
| var val = new ExposedInterface_ConnectionAccepted_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.state = decoder.decodeStructPointer(ConnectionState); |
| return val; |
| }; |
| |
| ExposedInterface_ConnectionAccepted_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(ExposedInterface_ConnectionAccepted_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(ConnectionState, val.state); |
| }; |
| function BlockedInterface_GetTitleBlocked_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| BlockedInterface_GetTitleBlocked_Params.prototype.initDefaults_ = function() { |
| }; |
| BlockedInterface_GetTitleBlocked_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| BlockedInterface_GetTitleBlocked_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 8} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| BlockedInterface_GetTitleBlocked_Params.encodedSize = codec.kStructHeaderSize + 0; |
| |
| BlockedInterface_GetTitleBlocked_Params.decode = function(decoder) { |
| var packed; |
| var val = new BlockedInterface_GetTitleBlocked_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| return val; |
| }; |
| |
| BlockedInterface_GetTitleBlocked_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(BlockedInterface_GetTitleBlocked_Params.encodedSize); |
| encoder.writeUint32(0); |
| }; |
| function BlockedInterface_GetTitleBlocked_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| BlockedInterface_GetTitleBlocked_ResponseParams.prototype.initDefaults_ = function() { |
| this.blockedTitle = null; |
| }; |
| BlockedInterface_GetTitleBlocked_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| BlockedInterface_GetTitleBlocked_ResponseParams.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 16} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate BlockedInterface_GetTitleBlocked_ResponseParams.blockedTitle |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| BlockedInterface_GetTitleBlocked_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| BlockedInterface_GetTitleBlocked_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new BlockedInterface_GetTitleBlocked_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.blockedTitle = decoder.decodeStruct(codec.String); |
| return val; |
| }; |
| |
| BlockedInterface_GetTitleBlocked_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(BlockedInterface_GetTitleBlocked_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.blockedTitle); |
| }; |
| function AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params.prototype.initDefaults_ = function() { |
| }; |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 8} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params.encodedSize = codec.kStructHeaderSize + 0; |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params.decode = function(decoder) { |
| var packed; |
| var val = new AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| return val; |
| }; |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params.encodedSize); |
| encoder.writeUint32(0); |
| }; |
| function AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams.prototype.initDefaults_ = function() { |
| this.title = null; |
| }; |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 16} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams.title |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.title = decoder.decodeStruct(codec.String); |
| return val; |
| }; |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.title); |
| }; |
| var kConnectTestService_GetTitle_Name = 2081447423; |
| var kConnectTestService_GetInstanceId_Name = 120166458; |
| |
| function ConnectTestServicePtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(ConnectTestService, |
| handleOrPtrInfo); |
| } |
| |
| function ConnectTestServiceAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| ConnectTestService, associatedInterfacePtrInfo); |
| } |
| |
| ConnectTestServiceAssociatedPtr.prototype = |
| Object.create(ConnectTestServicePtr.prototype); |
| ConnectTestServiceAssociatedPtr.prototype.constructor = |
| ConnectTestServiceAssociatedPtr; |
| |
| function ConnectTestServiceProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| ConnectTestServicePtr.prototype.getTitle = function() { |
| return ConnectTestServiceProxy.prototype.getTitle |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| ConnectTestServiceProxy.prototype.getTitle = function() { |
| var params_ = new ConnectTestService_GetTitle_Params(); |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kConnectTestService_GetTitle_Name, |
| codec.align(ConnectTestService_GetTitle_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(ConnectTestService_GetTitle_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(ConnectTestService_GetTitle_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| ConnectTestServicePtr.prototype.getInstanceId = function() { |
| return ConnectTestServiceProxy.prototype.getInstanceId |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| ConnectTestServiceProxy.prototype.getInstanceId = function() { |
| var params_ = new ConnectTestService_GetInstanceId_Params(); |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kConnectTestService_GetInstanceId_Name, |
| codec.align(ConnectTestService_GetInstanceId_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(ConnectTestService_GetInstanceId_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(ConnectTestService_GetInstanceId_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function ConnectTestServiceStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| ConnectTestServiceStub.prototype.getTitle = function() { |
| return this.delegate_ && this.delegate_.getTitle && this.delegate_.getTitle(); |
| } |
| ConnectTestServiceStub.prototype.getInstanceId = function() { |
| return this.delegate_ && this.delegate_.getInstanceId && this.delegate_.getInstanceId(); |
| } |
| |
| ConnectTestServiceStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| ConnectTestServiceStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kConnectTestService_GetTitle_Name: |
| var params = reader.decodeStruct(ConnectTestService_GetTitle_Params); |
| this.getTitle().then(function(response) { |
| var responseParams = |
| new ConnectTestService_GetTitle_ResponseParams(); |
| responseParams.title = response.title; |
| var builder = new codec.MessageV1Builder( |
| kConnectTestService_GetTitle_Name, |
| codec.align(ConnectTestService_GetTitle_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(ConnectTestService_GetTitle_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kConnectTestService_GetInstanceId_Name: |
| var params = reader.decodeStruct(ConnectTestService_GetInstanceId_Params); |
| this.getInstanceId().then(function(response) { |
| var responseParams = |
| new ConnectTestService_GetInstanceId_ResponseParams(); |
| responseParams.instanceId = response.instanceId; |
| var builder = new codec.MessageV1Builder( |
| kConnectTestService_GetInstanceId_Name, |
| codec.align(ConnectTestService_GetInstanceId_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(ConnectTestService_GetInstanceId_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateConnectTestServiceRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kConnectTestService_GetTitle_Name: |
| if (message.expectsResponse()) |
| paramsClass = ConnectTestService_GetTitle_Params; |
| break; |
| case kConnectTestService_GetInstanceId_Name: |
| if (message.expectsResponse()) |
| paramsClass = ConnectTestService_GetInstanceId_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateConnectTestServiceResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kConnectTestService_GetTitle_Name: |
| if (message.isResponse()) |
| paramsClass = ConnectTestService_GetTitle_ResponseParams; |
| break; |
| case kConnectTestService_GetInstanceId_Name: |
| if (message.isResponse()) |
| paramsClass = ConnectTestService_GetInstanceId_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var ConnectTestService = { |
| name: 'service_manager.test.mojom.ConnectTestService', |
| kVersion: 0, |
| ptrClass: ConnectTestServicePtr, |
| proxyClass: ConnectTestServiceProxy, |
| stubClass: ConnectTestServiceStub, |
| validateRequest: validateConnectTestServiceRequest, |
| validateResponse: validateConnectTestServiceResponse, |
| }; |
| ConnectTestServiceStub.prototype.validator = validateConnectTestServiceRequest; |
| ConnectTestServiceProxy.prototype.validator = validateConnectTestServiceResponse; |
| var kClassInterface_Ping_Name = 546811448; |
| |
| function ClassInterfacePtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(ClassInterface, |
| handleOrPtrInfo); |
| } |
| |
| function ClassInterfaceAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| ClassInterface, associatedInterfacePtrInfo); |
| } |
| |
| ClassInterfaceAssociatedPtr.prototype = |
| Object.create(ClassInterfacePtr.prototype); |
| ClassInterfaceAssociatedPtr.prototype.constructor = |
| ClassInterfaceAssociatedPtr; |
| |
| function ClassInterfaceProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| ClassInterfacePtr.prototype.ping = function() { |
| return ClassInterfaceProxy.prototype.ping |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| ClassInterfaceProxy.prototype.ping = function() { |
| var params_ = new ClassInterface_Ping_Params(); |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kClassInterface_Ping_Name, |
| codec.align(ClassInterface_Ping_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(ClassInterface_Ping_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(ClassInterface_Ping_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function ClassInterfaceStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| ClassInterfaceStub.prototype.ping = function() { |
| return this.delegate_ && this.delegate_.ping && this.delegate_.ping(); |
| } |
| |
| ClassInterfaceStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| ClassInterfaceStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kClassInterface_Ping_Name: |
| var params = reader.decodeStruct(ClassInterface_Ping_Params); |
| this.ping().then(function(response) { |
| var responseParams = |
| new ClassInterface_Ping_ResponseParams(); |
| responseParams.response = response.response; |
| var builder = new codec.MessageV1Builder( |
| kClassInterface_Ping_Name, |
| codec.align(ClassInterface_Ping_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(ClassInterface_Ping_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateClassInterfaceRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kClassInterface_Ping_Name: |
| if (message.expectsResponse()) |
| paramsClass = ClassInterface_Ping_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateClassInterfaceResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kClassInterface_Ping_Name: |
| if (message.isResponse()) |
| paramsClass = ClassInterface_Ping_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var ClassInterface = { |
| name: 'service_manager.test.mojom.ClassInterface', |
| kVersion: 0, |
| ptrClass: ClassInterfacePtr, |
| proxyClass: ClassInterfaceProxy, |
| stubClass: ClassInterfaceStub, |
| validateRequest: validateClassInterfaceRequest, |
| validateResponse: validateClassInterfaceResponse, |
| }; |
| ClassInterfaceStub.prototype.validator = validateClassInterfaceRequest; |
| ClassInterfaceProxy.prototype.validator = validateClassInterfaceResponse; |
| var kStandaloneApp_ConnectToAllowedAppInBlockedPackage_Name = 256485500; |
| var kStandaloneApp_ConnectToClassInterface_Name = 1043124556; |
| |
| function StandaloneAppPtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(StandaloneApp, |
| handleOrPtrInfo); |
| } |
| |
| function StandaloneAppAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| StandaloneApp, associatedInterfacePtrInfo); |
| } |
| |
| StandaloneAppAssociatedPtr.prototype = |
| Object.create(StandaloneAppPtr.prototype); |
| StandaloneAppAssociatedPtr.prototype.constructor = |
| StandaloneAppAssociatedPtr; |
| |
| function StandaloneAppProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| StandaloneAppPtr.prototype.connectToAllowedAppInBlockedPackage = function() { |
| return StandaloneAppProxy.prototype.connectToAllowedAppInBlockedPackage |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| StandaloneAppProxy.prototype.connectToAllowedAppInBlockedPackage = function() { |
| var params_ = new StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params(); |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kStandaloneApp_ConnectToAllowedAppInBlockedPackage_Name, |
| codec.align(StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| StandaloneAppPtr.prototype.connectToClassInterface = function() { |
| return StandaloneAppProxy.prototype.connectToClassInterface |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| StandaloneAppProxy.prototype.connectToClassInterface = function() { |
| var params_ = new StandaloneApp_ConnectToClassInterface_Params(); |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kStandaloneApp_ConnectToClassInterface_Name, |
| codec.align(StandaloneApp_ConnectToClassInterface_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(StandaloneApp_ConnectToClassInterface_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(StandaloneApp_ConnectToClassInterface_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function StandaloneAppStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| StandaloneAppStub.prototype.connectToAllowedAppInBlockedPackage = function() { |
| return this.delegate_ && this.delegate_.connectToAllowedAppInBlockedPackage && this.delegate_.connectToAllowedAppInBlockedPackage(); |
| } |
| StandaloneAppStub.prototype.connectToClassInterface = function() { |
| return this.delegate_ && this.delegate_.connectToClassInterface && this.delegate_.connectToClassInterface(); |
| } |
| |
| StandaloneAppStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| StandaloneAppStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kStandaloneApp_ConnectToAllowedAppInBlockedPackage_Name: |
| var params = reader.decodeStruct(StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params); |
| this.connectToAllowedAppInBlockedPackage().then(function(response) { |
| var responseParams = |
| new StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams(); |
| responseParams.title = response.title; |
| var builder = new codec.MessageV1Builder( |
| kStandaloneApp_ConnectToAllowedAppInBlockedPackage_Name, |
| codec.align(StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kStandaloneApp_ConnectToClassInterface_Name: |
| var params = reader.decodeStruct(StandaloneApp_ConnectToClassInterface_Params); |
| this.connectToClassInterface().then(function(response) { |
| var responseParams = |
| new StandaloneApp_ConnectToClassInterface_ResponseParams(); |
| responseParams.classInterfaceResponse = response.classInterfaceResponse; |
| responseParams.title = response.title; |
| var builder = new codec.MessageV1Builder( |
| kStandaloneApp_ConnectToClassInterface_Name, |
| codec.align(StandaloneApp_ConnectToClassInterface_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(StandaloneApp_ConnectToClassInterface_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateStandaloneAppRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kStandaloneApp_ConnectToAllowedAppInBlockedPackage_Name: |
| if (message.expectsResponse()) |
| paramsClass = StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params; |
| break; |
| case kStandaloneApp_ConnectToClassInterface_Name: |
| if (message.expectsResponse()) |
| paramsClass = StandaloneApp_ConnectToClassInterface_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateStandaloneAppResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kStandaloneApp_ConnectToAllowedAppInBlockedPackage_Name: |
| if (message.isResponse()) |
| paramsClass = StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams; |
| break; |
| case kStandaloneApp_ConnectToClassInterface_Name: |
| if (message.isResponse()) |
| paramsClass = StandaloneApp_ConnectToClassInterface_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var StandaloneApp = { |
| name: 'service_manager.test.mojom.StandaloneApp', |
| kVersion: 0, |
| ptrClass: StandaloneAppPtr, |
| proxyClass: StandaloneAppProxy, |
| stubClass: StandaloneAppStub, |
| validateRequest: validateStandaloneAppRequest, |
| validateResponse: validateStandaloneAppResponse, |
| }; |
| StandaloneAppStub.prototype.validator = validateStandaloneAppRequest; |
| StandaloneAppProxy.prototype.validator = validateStandaloneAppResponse; |
| var kIdentityTest_ConnectToClassAppWithFilter_Name = 337990069; |
| |
| function IdentityTestPtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(IdentityTest, |
| handleOrPtrInfo); |
| } |
| |
| function IdentityTestAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| IdentityTest, associatedInterfacePtrInfo); |
| } |
| |
| IdentityTestAssociatedPtr.prototype = |
| Object.create(IdentityTestPtr.prototype); |
| IdentityTestAssociatedPtr.prototype.constructor = |
| IdentityTestAssociatedPtr; |
| |
| function IdentityTestProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| IdentityTestPtr.prototype.connectToClassAppWithFilter = function() { |
| return IdentityTestProxy.prototype.connectToClassAppWithFilter |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| IdentityTestProxy.prototype.connectToClassAppWithFilter = function(filter) { |
| var params_ = new IdentityTest_ConnectToClassAppWithFilter_Params(); |
| params_.filter = filter; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kIdentityTest_ConnectToClassAppWithFilter_Name, |
| codec.align(IdentityTest_ConnectToClassAppWithFilter_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(IdentityTest_ConnectToClassAppWithFilter_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(IdentityTest_ConnectToClassAppWithFilter_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function IdentityTestStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| IdentityTestStub.prototype.connectToClassAppWithFilter = function(filter) { |
| return this.delegate_ && this.delegate_.connectToClassAppWithFilter && this.delegate_.connectToClassAppWithFilter(filter); |
| } |
| |
| IdentityTestStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| IdentityTestStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kIdentityTest_ConnectToClassAppWithFilter_Name: |
| var params = reader.decodeStruct(IdentityTest_ConnectToClassAppWithFilter_Params); |
| this.connectToClassAppWithFilter(params.filter).then(function(response) { |
| var responseParams = |
| new IdentityTest_ConnectToClassAppWithFilter_ResponseParams(); |
| responseParams.connectionResult = response.connectionResult; |
| responseParams.identity = response.identity; |
| var builder = new codec.MessageV1Builder( |
| kIdentityTest_ConnectToClassAppWithFilter_Name, |
| codec.align(IdentityTest_ConnectToClassAppWithFilter_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(IdentityTest_ConnectToClassAppWithFilter_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateIdentityTestRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kIdentityTest_ConnectToClassAppWithFilter_Name: |
| if (message.expectsResponse()) |
| paramsClass = IdentityTest_ConnectToClassAppWithFilter_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateIdentityTestResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kIdentityTest_ConnectToClassAppWithFilter_Name: |
| if (message.isResponse()) |
| paramsClass = IdentityTest_ConnectToClassAppWithFilter_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var IdentityTest = { |
| name: 'service_manager.test.mojom.IdentityTest', |
| kVersion: 0, |
| ptrClass: IdentityTestPtr, |
| proxyClass: IdentityTestProxy, |
| stubClass: IdentityTestStub, |
| validateRequest: validateIdentityTestRequest, |
| validateResponse: validateIdentityTestResponse, |
| }; |
| IdentityTestStub.prototype.validator = validateIdentityTestRequest; |
| IdentityTestProxy.prototype.validator = validateIdentityTestResponse; |
| var kExposedInterface_ConnectionAccepted_Name = 1654975624; |
| |
| function ExposedInterfacePtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(ExposedInterface, |
| handleOrPtrInfo); |
| } |
| |
| function ExposedInterfaceAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| ExposedInterface, associatedInterfacePtrInfo); |
| } |
| |
| ExposedInterfaceAssociatedPtr.prototype = |
| Object.create(ExposedInterfacePtr.prototype); |
| ExposedInterfaceAssociatedPtr.prototype.constructor = |
| ExposedInterfaceAssociatedPtr; |
| |
| function ExposedInterfaceProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| ExposedInterfacePtr.prototype.connectionAccepted = function() { |
| return ExposedInterfaceProxy.prototype.connectionAccepted |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| ExposedInterfaceProxy.prototype.connectionAccepted = function(state) { |
| var params_ = new ExposedInterface_ConnectionAccepted_Params(); |
| params_.state = state; |
| var builder = new codec.MessageV0Builder( |
| kExposedInterface_ConnectionAccepted_Name, |
| codec.align(ExposedInterface_ConnectionAccepted_Params.encodedSize)); |
| builder.encodeStruct(ExposedInterface_ConnectionAccepted_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.accept(message); |
| }; |
| |
| function ExposedInterfaceStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| ExposedInterfaceStub.prototype.connectionAccepted = function(state) { |
| return this.delegate_ && this.delegate_.connectionAccepted && this.delegate_.connectionAccepted(state); |
| } |
| |
| ExposedInterfaceStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kExposedInterface_ConnectionAccepted_Name: |
| var params = reader.decodeStruct(ExposedInterface_ConnectionAccepted_Params); |
| this.connectionAccepted(params.state); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| ExposedInterfaceStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| function validateExposedInterfaceRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kExposedInterface_ConnectionAccepted_Name: |
| if (!message.expectsResponse() && !message.isResponse()) |
| paramsClass = ExposedInterface_ConnectionAccepted_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateExposedInterfaceResponse(messageValidator) { |
| return validator.validationError.NONE; |
| } |
| |
| var ExposedInterface = { |
| name: 'service_manager.test.mojom.ExposedInterface', |
| kVersion: 0, |
| ptrClass: ExposedInterfacePtr, |
| proxyClass: ExposedInterfaceProxy, |
| stubClass: ExposedInterfaceStub, |
| validateRequest: validateExposedInterfaceRequest, |
| validateResponse: null, |
| }; |
| ExposedInterfaceStub.prototype.validator = validateExposedInterfaceRequest; |
| ExposedInterfaceProxy.prototype.validator = null; |
| var kBlockedInterface_GetTitleBlocked_Name = 267186413; |
| |
| function BlockedInterfacePtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(BlockedInterface, |
| handleOrPtrInfo); |
| } |
| |
| function BlockedInterfaceAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| BlockedInterface, associatedInterfacePtrInfo); |
| } |
| |
| BlockedInterfaceAssociatedPtr.prototype = |
| Object.create(BlockedInterfacePtr.prototype); |
| BlockedInterfaceAssociatedPtr.prototype.constructor = |
| BlockedInterfaceAssociatedPtr; |
| |
| function BlockedInterfaceProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| BlockedInterfacePtr.prototype.getTitleBlocked = function() { |
| return BlockedInterfaceProxy.prototype.getTitleBlocked |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| BlockedInterfaceProxy.prototype.getTitleBlocked = function() { |
| var params_ = new BlockedInterface_GetTitleBlocked_Params(); |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kBlockedInterface_GetTitleBlocked_Name, |
| codec.align(BlockedInterface_GetTitleBlocked_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(BlockedInterface_GetTitleBlocked_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(BlockedInterface_GetTitleBlocked_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function BlockedInterfaceStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| BlockedInterfaceStub.prototype.getTitleBlocked = function() { |
| return this.delegate_ && this.delegate_.getTitleBlocked && this.delegate_.getTitleBlocked(); |
| } |
| |
| BlockedInterfaceStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| BlockedInterfaceStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kBlockedInterface_GetTitleBlocked_Name: |
| var params = reader.decodeStruct(BlockedInterface_GetTitleBlocked_Params); |
| this.getTitleBlocked().then(function(response) { |
| var responseParams = |
| new BlockedInterface_GetTitleBlocked_ResponseParams(); |
| responseParams.blockedTitle = response.blockedTitle; |
| var builder = new codec.MessageV1Builder( |
| kBlockedInterface_GetTitleBlocked_Name, |
| codec.align(BlockedInterface_GetTitleBlocked_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(BlockedInterface_GetTitleBlocked_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateBlockedInterfaceRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kBlockedInterface_GetTitleBlocked_Name: |
| if (message.expectsResponse()) |
| paramsClass = BlockedInterface_GetTitleBlocked_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateBlockedInterfaceResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kBlockedInterface_GetTitleBlocked_Name: |
| if (message.isResponse()) |
| paramsClass = BlockedInterface_GetTitleBlocked_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var BlockedInterface = { |
| name: 'service_manager.test.mojom.BlockedInterface', |
| kVersion: 0, |
| ptrClass: BlockedInterfacePtr, |
| proxyClass: BlockedInterfaceProxy, |
| stubClass: BlockedInterfaceStub, |
| validateRequest: validateBlockedInterfaceRequest, |
| validateResponse: validateBlockedInterfaceResponse, |
| }; |
| BlockedInterfaceStub.prototype.validator = validateBlockedInterfaceRequest; |
| BlockedInterfaceProxy.prototype.validator = validateBlockedInterfaceResponse; |
| var kAlwaysAllowedInterface_GetTitleAlwaysAllowed_Name = 590487407; |
| |
| function AlwaysAllowedInterfacePtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(AlwaysAllowedInterface, |
| handleOrPtrInfo); |
| } |
| |
| function AlwaysAllowedInterfaceAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| AlwaysAllowedInterface, associatedInterfacePtrInfo); |
| } |
| |
| AlwaysAllowedInterfaceAssociatedPtr.prototype = |
| Object.create(AlwaysAllowedInterfacePtr.prototype); |
| AlwaysAllowedInterfaceAssociatedPtr.prototype.constructor = |
| AlwaysAllowedInterfaceAssociatedPtr; |
| |
| function AlwaysAllowedInterfaceProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| AlwaysAllowedInterfacePtr.prototype.getTitleAlwaysAllowed = function() { |
| return AlwaysAllowedInterfaceProxy.prototype.getTitleAlwaysAllowed |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| AlwaysAllowedInterfaceProxy.prototype.getTitleAlwaysAllowed = function() { |
| var params_ = new AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params(); |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kAlwaysAllowedInterface_GetTitleAlwaysAllowed_Name, |
| codec.align(AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function AlwaysAllowedInterfaceStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| AlwaysAllowedInterfaceStub.prototype.getTitleAlwaysAllowed = function() { |
| return this.delegate_ && this.delegate_.getTitleAlwaysAllowed && this.delegate_.getTitleAlwaysAllowed(); |
| } |
| |
| AlwaysAllowedInterfaceStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| AlwaysAllowedInterfaceStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kAlwaysAllowedInterface_GetTitleAlwaysAllowed_Name: |
| var params = reader.decodeStruct(AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params); |
| this.getTitleAlwaysAllowed().then(function(response) { |
| var responseParams = |
| new AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams(); |
| responseParams.title = response.title; |
| var builder = new codec.MessageV1Builder( |
| kAlwaysAllowedInterface_GetTitleAlwaysAllowed_Name, |
| codec.align(AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateAlwaysAllowedInterfaceRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kAlwaysAllowedInterface_GetTitleAlwaysAllowed_Name: |
| if (message.expectsResponse()) |
| paramsClass = AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateAlwaysAllowedInterfaceResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kAlwaysAllowedInterface_GetTitleAlwaysAllowed_Name: |
| if (message.isResponse()) |
| paramsClass = AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var AlwaysAllowedInterface = { |
| name: 'service_manager.test.mojom.AlwaysAllowedInterface', |
| kVersion: 0, |
| ptrClass: AlwaysAllowedInterfacePtr, |
| proxyClass: AlwaysAllowedInterfaceProxy, |
| stubClass: AlwaysAllowedInterfaceStub, |
| validateRequest: validateAlwaysAllowedInterfaceRequest, |
| validateResponse: validateAlwaysAllowedInterfaceResponse, |
| }; |
| AlwaysAllowedInterfaceStub.prototype.validator = validateAlwaysAllowedInterfaceRequest; |
| AlwaysAllowedInterfaceProxy.prototype.validator = validateAlwaysAllowedInterfaceResponse; |
| exports.ConnectionState = ConnectionState; |
| exports.ConnectTestService = ConnectTestService; |
| exports.ConnectTestServicePtr = ConnectTestServicePtr; |
| exports.ConnectTestServiceAssociatedPtr = ConnectTestServiceAssociatedPtr; |
| exports.ClassInterface = ClassInterface; |
| exports.ClassInterfacePtr = ClassInterfacePtr; |
| exports.ClassInterfaceAssociatedPtr = ClassInterfaceAssociatedPtr; |
| exports.StandaloneApp = StandaloneApp; |
| exports.StandaloneAppPtr = StandaloneAppPtr; |
| exports.StandaloneAppAssociatedPtr = StandaloneAppAssociatedPtr; |
| exports.IdentityTest = IdentityTest; |
| exports.IdentityTestPtr = IdentityTestPtr; |
| exports.IdentityTestAssociatedPtr = IdentityTestAssociatedPtr; |
| exports.ExposedInterface = ExposedInterface; |
| exports.ExposedInterfacePtr = ExposedInterfacePtr; |
| exports.ExposedInterfaceAssociatedPtr = ExposedInterfaceAssociatedPtr; |
| exports.BlockedInterface = BlockedInterface; |
| exports.BlockedInterfacePtr = BlockedInterfacePtr; |
| exports.BlockedInterfaceAssociatedPtr = BlockedInterfaceAssociatedPtr; |
| exports.AlwaysAllowedInterface = AlwaysAllowedInterface; |
| exports.AlwaysAllowedInterfacePtr = AlwaysAllowedInterfacePtr; |
| exports.AlwaysAllowedInterfaceAssociatedPtr = AlwaysAllowedInterfaceAssociatedPtr; |
| })(); |
