| // content/common/gin_java_bridge.mojom.js is auto generated by mojom_bindings_generator.py, do not edit |
| |
| // Copyright 2014 The Chromium Authors |
| // 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 = 'content/common/gin_java_bridge.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('content.mojom'); |
| var origin_matcher$ = |
| mojo.internal.exposeNamespace('originMatcher.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'components/origin_matcher/origin_matcher.mojom', '../../components/origin_matcher/origin_matcher.mojom.js'); |
| } |
| var values$ = |
| mojo.internal.exposeNamespace('mojoBase.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'mojo/public/mojom/base/values.mojom', '../../mojo/public/mojom/base/values.mojom.js'); |
| } |
| |
| |
| var GinJavaBridgeError = {}; |
| GinJavaBridgeError.kGinJavaBridgeNoError = 0; |
| GinJavaBridgeError.kGinJavaBridgeUnknownObjectId = 1; |
| GinJavaBridgeError.kGinJavaBridgeObjectIsGone = 2; |
| GinJavaBridgeError.kGinJavaBridgeMethodNotFound = 3; |
| GinJavaBridgeError.kGinJavaBridgeAccessToObjectGetClassIsBlocked = 4; |
| GinJavaBridgeError.kGinJavaBridgeJavaExceptionRaised = 5; |
| GinJavaBridgeError.kGinJavaBridgeNonAssignableTypes = 6; |
| GinJavaBridgeError.kGinJavaBridgeRenderFrameDeleted = 7; |
| GinJavaBridgeError.MIN_VALUE = 0; |
| GinJavaBridgeError.MAX_VALUE = 7; |
| |
| GinJavaBridgeError.isKnownEnumValue = function(value) { |
| switch (value) { |
| case 0: |
| case 1: |
| case 2: |
| case 3: |
| case 4: |
| case 5: |
| case 6: |
| case 7: |
| return true; |
| } |
| return false; |
| }; |
| |
| GinJavaBridgeError.toKnownEnumValue = function(value) { |
| return value; |
| }; |
| |
| GinJavaBridgeError.validate = function(enumValue) { |
| const isExtensible = false; |
| if (isExtensible || this.isKnownEnumValue(enumValue)) |
| return validator.validationError.NONE; |
| |
| return validator.validationError.UNKNOWN_ENUM_VALUE; |
| }; |
| |
| function GinJavaBridge_AddNamedObject_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridge_AddNamedObject_Params.prototype.initDefaults_ = function() { |
| this.name = null; |
| this.objectId = 0; |
| this.originMatcher = null; |
| }; |
| GinJavaBridge_AddNamedObject_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridge_AddNamedObject_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: 32} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate GinJavaBridge_AddNamedObject_Params.name |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| |
| // validate GinJavaBridge_AddNamedObject_Params.originMatcher |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 16, origin_matcher$.OriginMatcher, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| GinJavaBridge_AddNamedObject_Params.encodedSize = codec.kStructHeaderSize + 24; |
| |
| GinJavaBridge_AddNamedObject_Params.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridge_AddNamedObject_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.name = |
| decoder.decodeStruct(codec.String); |
| val.objectId = |
| decoder.decodeStruct(codec.Int32); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| val.originMatcher = |
| decoder.decodeStructPointer(origin_matcher$.OriginMatcher); |
| return val; |
| }; |
| |
| GinJavaBridge_AddNamedObject_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridge_AddNamedObject_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.name); |
| encoder.encodeStruct(codec.Int32, val.objectId); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.encodeStructPointer(origin_matcher$.OriginMatcher, val.originMatcher); |
| }; |
| function GinJavaBridge_RemoveNamedObject_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridge_RemoveNamedObject_Params.prototype.initDefaults_ = function() { |
| this.name = null; |
| }; |
| GinJavaBridge_RemoveNamedObject_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridge_RemoveNamedObject_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 GinJavaBridge_RemoveNamedObject_Params.name |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| GinJavaBridge_RemoveNamedObject_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| GinJavaBridge_RemoveNamedObject_Params.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridge_RemoveNamedObject_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.name = |
| decoder.decodeStruct(codec.String); |
| return val; |
| }; |
| |
| GinJavaBridge_RemoveNamedObject_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridge_RemoveNamedObject_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.name); |
| }; |
| function GinJavaBridge_SetHost_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridge_SetHost_Params.prototype.initDefaults_ = function() { |
| this.host = new GinJavaBridgeHostPtr(); |
| }; |
| GinJavaBridge_SetHost_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridge_SetHost_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 GinJavaBridge_SetHost_Params.host |
| err = messageValidator.validateInterface(offset + codec.kStructHeaderSize + 0, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| GinJavaBridge_SetHost_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| GinJavaBridge_SetHost_Params.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridge_SetHost_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.host = |
| decoder.decodeStruct(new codec.Interface(GinJavaBridgeHostPtr)); |
| return val; |
| }; |
| |
| GinJavaBridge_SetHost_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridge_SetHost_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(new codec.Interface(GinJavaBridgeHostPtr), val.host); |
| }; |
| function GinJavaBridgeRemoteObject_GetMethods_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridgeRemoteObject_GetMethods_Params.prototype.initDefaults_ = function() { |
| }; |
| GinJavaBridgeRemoteObject_GetMethods_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridgeRemoteObject_GetMethods_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; |
| }; |
| |
| GinJavaBridgeRemoteObject_GetMethods_Params.encodedSize = codec.kStructHeaderSize + 0; |
| |
| GinJavaBridgeRemoteObject_GetMethods_Params.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridgeRemoteObject_GetMethods_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| return val; |
| }; |
| |
| GinJavaBridgeRemoteObject_GetMethods_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridgeRemoteObject_GetMethods_Params.encodedSize); |
| encoder.writeUint32(0); |
| }; |
| function GinJavaBridgeRemoteObject_GetMethods_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridgeRemoteObject_GetMethods_ResponseParams.prototype.initDefaults_ = function() { |
| this.methodNames = null; |
| }; |
| GinJavaBridgeRemoteObject_GetMethods_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridgeRemoteObject_GetMethods_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 GinJavaBridgeRemoteObject_GetMethods_ResponseParams.methodNames |
| err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 0, 8, codec.String, false, [0, 0], 0); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| GinJavaBridgeRemoteObject_GetMethods_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| GinJavaBridgeRemoteObject_GetMethods_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridgeRemoteObject_GetMethods_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.methodNames = |
| decoder.decodeArrayPointer(codec.String); |
| return val; |
| }; |
| |
| GinJavaBridgeRemoteObject_GetMethods_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridgeRemoteObject_GetMethods_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeArrayPointer(codec.String, val.methodNames); |
| }; |
| function GinJavaBridgeRemoteObject_HasMethod_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridgeRemoteObject_HasMethod_Params.prototype.initDefaults_ = function() { |
| this.methodName = null; |
| }; |
| GinJavaBridgeRemoteObject_HasMethod_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridgeRemoteObject_HasMethod_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 GinJavaBridgeRemoteObject_HasMethod_Params.methodName |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| GinJavaBridgeRemoteObject_HasMethod_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| GinJavaBridgeRemoteObject_HasMethod_Params.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridgeRemoteObject_HasMethod_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.methodName = |
| decoder.decodeStruct(codec.String); |
| return val; |
| }; |
| |
| GinJavaBridgeRemoteObject_HasMethod_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridgeRemoteObject_HasMethod_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.methodName); |
| }; |
| function GinJavaBridgeRemoteObject_HasMethod_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridgeRemoteObject_HasMethod_ResponseParams.prototype.initDefaults_ = function() { |
| this.result = false; |
| }; |
| GinJavaBridgeRemoteObject_HasMethod_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridgeRemoteObject_HasMethod_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; |
| |
| |
| return validator.validationError.NONE; |
| }; |
| |
| GinJavaBridgeRemoteObject_HasMethod_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| GinJavaBridgeRemoteObject_HasMethod_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridgeRemoteObject_HasMethod_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| packed = decoder.readUint8(); |
| val.result = (packed >> 0) & 1 ? true : false; |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| return val; |
| }; |
| |
| GinJavaBridgeRemoteObject_HasMethod_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridgeRemoteObject_HasMethod_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| packed = 0; |
| packed |= (val.result & 1) << 0 |
| encoder.writeUint8(packed); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| }; |
| function GinJavaBridgeRemoteObject_InvokeMethod_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridgeRemoteObject_InvokeMethod_Params.prototype.initDefaults_ = function() { |
| this.methodName = null; |
| this.arguments = null; |
| }; |
| GinJavaBridgeRemoteObject_InvokeMethod_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridgeRemoteObject_InvokeMethod_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: 24} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate GinJavaBridgeRemoteObject_InvokeMethod_Params.methodName |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate GinJavaBridgeRemoteObject_InvokeMethod_Params.arguments |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 8, values$.ListValue, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| GinJavaBridgeRemoteObject_InvokeMethod_Params.encodedSize = codec.kStructHeaderSize + 16; |
| |
| GinJavaBridgeRemoteObject_InvokeMethod_Params.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridgeRemoteObject_InvokeMethod_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.methodName = |
| decoder.decodeStruct(codec.String); |
| val.arguments = |
| decoder.decodeStructPointer(values$.ListValue); |
| return val; |
| }; |
| |
| GinJavaBridgeRemoteObject_InvokeMethod_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridgeRemoteObject_InvokeMethod_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.methodName); |
| encoder.encodeStructPointer(values$.ListValue, val.arguments); |
| }; |
| function GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams.prototype.initDefaults_ = function() { |
| this.errorCode = 0; |
| this.result = null; |
| }; |
| GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridgeRemoteObject_InvokeMethod_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 GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams.errorCode |
| err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 0, GinJavaBridgeError); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams.result |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 8, values$.ListValue, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams.encodedSize = codec.kStructHeaderSize + 16; |
| |
| GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.errorCode = |
| decoder.decodeStruct(new codec.Enum(GinJavaBridgeError)); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| val.result = |
| decoder.decodeStructPointer(values$.ListValue); |
| return val; |
| }; |
| |
| GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.Int32, val.errorCode); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.encodeStructPointer(values$.ListValue, val.result); |
| }; |
| function GinJavaBridgeHost_GetObject_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridgeHost_GetObject_Params.prototype.initDefaults_ = function() { |
| this.objectId = 0; |
| this.receiver = new bindings.InterfaceRequest(); |
| }; |
| GinJavaBridgeHost_GetObject_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridgeHost_GetObject_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 GinJavaBridgeHost_GetObject_Params.receiver |
| err = messageValidator.validateInterfaceRequest(offset + codec.kStructHeaderSize + 4, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| GinJavaBridgeHost_GetObject_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| GinJavaBridgeHost_GetObject_Params.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridgeHost_GetObject_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.objectId = |
| decoder.decodeStruct(codec.Int32); |
| val.receiver = |
| decoder.decodeStruct(codec.InterfaceRequest); |
| return val; |
| }; |
| |
| GinJavaBridgeHost_GetObject_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridgeHost_GetObject_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.Int32, val.objectId); |
| encoder.encodeStruct(codec.InterfaceRequest, val.receiver); |
| }; |
| function GinJavaBridgeHost_ObjectWrapperDeleted_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| GinJavaBridgeHost_ObjectWrapperDeleted_Params.prototype.initDefaults_ = function() { |
| this.objectId = 0; |
| }; |
| GinJavaBridgeHost_ObjectWrapperDeleted_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| GinJavaBridgeHost_ObjectWrapperDeleted_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; |
| |
| |
| return validator.validationError.NONE; |
| }; |
| |
| GinJavaBridgeHost_ObjectWrapperDeleted_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| GinJavaBridgeHost_ObjectWrapperDeleted_Params.decode = function(decoder) { |
| var packed; |
| var val = new GinJavaBridgeHost_ObjectWrapperDeleted_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.objectId = |
| decoder.decodeStruct(codec.Int32); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| return val; |
| }; |
| |
| GinJavaBridgeHost_ObjectWrapperDeleted_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(GinJavaBridgeHost_ObjectWrapperDeleted_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.Int32, val.objectId); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| }; |
| var kGinJavaBridge_AddNamedObject_Name = 0; |
| var kGinJavaBridge_RemoveNamedObject_Name = 1; |
| var kGinJavaBridge_SetHost_Name = 2; |
| |
| function GinJavaBridgePtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(GinJavaBridge, |
| handleOrPtrInfo); |
| } |
| |
| function GinJavaBridgeAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| GinJavaBridge, associatedInterfacePtrInfo); |
| } |
| |
| GinJavaBridgeAssociatedPtr.prototype = |
| Object.create(GinJavaBridgePtr.prototype); |
| GinJavaBridgeAssociatedPtr.prototype.constructor = |
| GinJavaBridgeAssociatedPtr; |
| |
| function GinJavaBridgeProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| GinJavaBridgePtr.prototype.addNamedObject = function() { |
| return GinJavaBridgeProxy.prototype.addNamedObject |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| GinJavaBridgeProxy.prototype.addNamedObject = function(name, objectId, originMatcher) { |
| var params_ = new GinJavaBridge_AddNamedObject_Params(); |
| params_.name = name; |
| params_.objectId = objectId; |
| params_.originMatcher = originMatcher; |
| var builder = new codec.MessageV0Builder( |
| kGinJavaBridge_AddNamedObject_Name, |
| codec.align(GinJavaBridge_AddNamedObject_Params.encodedSize)); |
| builder.encodeStruct(GinJavaBridge_AddNamedObject_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.accept(message); |
| }; |
| GinJavaBridgePtr.prototype.removeNamedObject = function() { |
| return GinJavaBridgeProxy.prototype.removeNamedObject |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| GinJavaBridgeProxy.prototype.removeNamedObject = function(name) { |
| var params_ = new GinJavaBridge_RemoveNamedObject_Params(); |
| params_.name = name; |
| var builder = new codec.MessageV0Builder( |
| kGinJavaBridge_RemoveNamedObject_Name, |
| codec.align(GinJavaBridge_RemoveNamedObject_Params.encodedSize)); |
| builder.encodeStruct(GinJavaBridge_RemoveNamedObject_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.accept(message); |
| }; |
| GinJavaBridgePtr.prototype.setHost = function() { |
| return GinJavaBridgeProxy.prototype.setHost |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| GinJavaBridgeProxy.prototype.setHost = function(host) { |
| var params_ = new GinJavaBridge_SetHost_Params(); |
| params_.host = host; |
| var builder = new codec.MessageV0Builder( |
| kGinJavaBridge_SetHost_Name, |
| codec.align(GinJavaBridge_SetHost_Params.encodedSize)); |
| builder.encodeStruct(GinJavaBridge_SetHost_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.accept(message); |
| }; |
| |
| function GinJavaBridgeStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| GinJavaBridgeStub.prototype.addNamedObject = function(name, objectId, originMatcher) { |
| return this.delegate_ && this.delegate_.addNamedObject && this.delegate_.addNamedObject(name, objectId, originMatcher); |
| } |
| GinJavaBridgeStub.prototype.removeNamedObject = function(name) { |
| return this.delegate_ && this.delegate_.removeNamedObject && this.delegate_.removeNamedObject(name); |
| } |
| GinJavaBridgeStub.prototype.setHost = function(host) { |
| return this.delegate_ && this.delegate_.setHost && this.delegate_.setHost(host); |
| } |
| |
| GinJavaBridgeStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kGinJavaBridge_AddNamedObject_Name: |
| var params = reader.decodeStruct(GinJavaBridge_AddNamedObject_Params); |
| this.addNamedObject(params.name, params.objectId, params.originMatcher); |
| return true; |
| case kGinJavaBridge_RemoveNamedObject_Name: |
| var params = reader.decodeStruct(GinJavaBridge_RemoveNamedObject_Params); |
| this.removeNamedObject(params.name); |
| return true; |
| case kGinJavaBridge_SetHost_Name: |
| var params = reader.decodeStruct(GinJavaBridge_SetHost_Params); |
| this.setHost(params.host); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| GinJavaBridgeStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| function validateGinJavaBridgeRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kGinJavaBridge_AddNamedObject_Name: |
| if (!message.expectsResponse() && !message.isResponse()) |
| paramsClass = GinJavaBridge_AddNamedObject_Params; |
| break; |
| case kGinJavaBridge_RemoveNamedObject_Name: |
| if (!message.expectsResponse() && !message.isResponse()) |
| paramsClass = GinJavaBridge_RemoveNamedObject_Params; |
| break; |
| case kGinJavaBridge_SetHost_Name: |
| if (!message.expectsResponse() && !message.isResponse()) |
| paramsClass = GinJavaBridge_SetHost_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateGinJavaBridgeResponse(messageValidator) { |
| return validator.validationError.NONE; |
| } |
| |
| var GinJavaBridge = { |
| name: 'content.mojom.GinJavaBridge', |
| kVersion: 0, |
| ptrClass: GinJavaBridgePtr, |
| proxyClass: GinJavaBridgeProxy, |
| stubClass: GinJavaBridgeStub, |
| validateRequest: validateGinJavaBridgeRequest, |
| validateResponse: null, |
| }; |
| GinJavaBridgeStub.prototype.validator = validateGinJavaBridgeRequest; |
| GinJavaBridgeProxy.prototype.validator = null; |
| var kGinJavaBridgeRemoteObject_GetMethods_Name = 0; |
| var kGinJavaBridgeRemoteObject_HasMethod_Name = 1; |
| var kGinJavaBridgeRemoteObject_InvokeMethod_Name = 2; |
| |
| function GinJavaBridgeRemoteObjectPtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(GinJavaBridgeRemoteObject, |
| handleOrPtrInfo); |
| } |
| |
| function GinJavaBridgeRemoteObjectAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| GinJavaBridgeRemoteObject, associatedInterfacePtrInfo); |
| } |
| |
| GinJavaBridgeRemoteObjectAssociatedPtr.prototype = |
| Object.create(GinJavaBridgeRemoteObjectPtr.prototype); |
| GinJavaBridgeRemoteObjectAssociatedPtr.prototype.constructor = |
| GinJavaBridgeRemoteObjectAssociatedPtr; |
| |
| function GinJavaBridgeRemoteObjectProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| GinJavaBridgeRemoteObjectPtr.prototype.getMethods = function() { |
| return GinJavaBridgeRemoteObjectProxy.prototype.getMethods |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| GinJavaBridgeRemoteObjectProxy.prototype.getMethods = function() { |
| var params_ = new GinJavaBridgeRemoteObject_GetMethods_Params(); |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kGinJavaBridgeRemoteObject_GetMethods_Name, |
| codec.align(GinJavaBridgeRemoteObject_GetMethods_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(GinJavaBridgeRemoteObject_GetMethods_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(GinJavaBridgeRemoteObject_GetMethods_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| GinJavaBridgeRemoteObjectPtr.prototype.hasMethod = function() { |
| return GinJavaBridgeRemoteObjectProxy.prototype.hasMethod |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| GinJavaBridgeRemoteObjectProxy.prototype.hasMethod = function(methodName) { |
| var params_ = new GinJavaBridgeRemoteObject_HasMethod_Params(); |
| params_.methodName = methodName; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kGinJavaBridgeRemoteObject_HasMethod_Name, |
| codec.align(GinJavaBridgeRemoteObject_HasMethod_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(GinJavaBridgeRemoteObject_HasMethod_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(GinJavaBridgeRemoteObject_HasMethod_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| GinJavaBridgeRemoteObjectPtr.prototype.invokeMethod = function() { |
| return GinJavaBridgeRemoteObjectProxy.prototype.invokeMethod |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| GinJavaBridgeRemoteObjectProxy.prototype.invokeMethod = function(methodName, arguments_) { |
| var params_ = new GinJavaBridgeRemoteObject_InvokeMethod_Params(); |
| params_.methodName = methodName; |
| params_.arguments = arguments_; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kGinJavaBridgeRemoteObject_InvokeMethod_Name, |
| codec.align(GinJavaBridgeRemoteObject_InvokeMethod_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(GinJavaBridgeRemoteObject_InvokeMethod_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function GinJavaBridgeRemoteObjectStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| GinJavaBridgeRemoteObjectStub.prototype.getMethods = function() { |
| return this.delegate_ && this.delegate_.getMethods && this.delegate_.getMethods(); |
| } |
| GinJavaBridgeRemoteObjectStub.prototype.hasMethod = function(methodName) { |
| return this.delegate_ && this.delegate_.hasMethod && this.delegate_.hasMethod(methodName); |
| } |
| GinJavaBridgeRemoteObjectStub.prototype.invokeMethod = function(methodName, arguments_) { |
| return this.delegate_ && this.delegate_.invokeMethod && this.delegate_.invokeMethod(methodName, arguments_); |
| } |
| |
| GinJavaBridgeRemoteObjectStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| GinJavaBridgeRemoteObjectStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kGinJavaBridgeRemoteObject_GetMethods_Name: |
| var params = reader.decodeStruct(GinJavaBridgeRemoteObject_GetMethods_Params); |
| this.getMethods().then(function(response) { |
| var responseParams = |
| new GinJavaBridgeRemoteObject_GetMethods_ResponseParams(); |
| responseParams.methodNames = response.methodNames; |
| var builder = new codec.MessageV1Builder( |
| kGinJavaBridgeRemoteObject_GetMethods_Name, |
| codec.align(GinJavaBridgeRemoteObject_GetMethods_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(GinJavaBridgeRemoteObject_GetMethods_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kGinJavaBridgeRemoteObject_HasMethod_Name: |
| var params = reader.decodeStruct(GinJavaBridgeRemoteObject_HasMethod_Params); |
| this.hasMethod(params.methodName).then(function(response) { |
| var responseParams = |
| new GinJavaBridgeRemoteObject_HasMethod_ResponseParams(); |
| responseParams.result = response.result; |
| var builder = new codec.MessageV1Builder( |
| kGinJavaBridgeRemoteObject_HasMethod_Name, |
| codec.align(GinJavaBridgeRemoteObject_HasMethod_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(GinJavaBridgeRemoteObject_HasMethod_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kGinJavaBridgeRemoteObject_InvokeMethod_Name: |
| var params = reader.decodeStruct(GinJavaBridgeRemoteObject_InvokeMethod_Params); |
| this.invokeMethod(params.methodName, params.arguments).then(function(response) { |
| var responseParams = |
| new GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams(); |
| responseParams.errorCode = response.errorCode; |
| responseParams.result = response.result; |
| var builder = new codec.MessageV1Builder( |
| kGinJavaBridgeRemoteObject_InvokeMethod_Name, |
| codec.align(GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateGinJavaBridgeRemoteObjectRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kGinJavaBridgeRemoteObject_GetMethods_Name: |
| if (message.expectsResponse()) |
| paramsClass = GinJavaBridgeRemoteObject_GetMethods_Params; |
| break; |
| case kGinJavaBridgeRemoteObject_HasMethod_Name: |
| if (message.expectsResponse()) |
| paramsClass = GinJavaBridgeRemoteObject_HasMethod_Params; |
| break; |
| case kGinJavaBridgeRemoteObject_InvokeMethod_Name: |
| if (message.expectsResponse()) |
| paramsClass = GinJavaBridgeRemoteObject_InvokeMethod_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateGinJavaBridgeRemoteObjectResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kGinJavaBridgeRemoteObject_GetMethods_Name: |
| if (message.isResponse()) |
| paramsClass = GinJavaBridgeRemoteObject_GetMethods_ResponseParams; |
| break; |
| case kGinJavaBridgeRemoteObject_HasMethod_Name: |
| if (message.isResponse()) |
| paramsClass = GinJavaBridgeRemoteObject_HasMethod_ResponseParams; |
| break; |
| case kGinJavaBridgeRemoteObject_InvokeMethod_Name: |
| if (message.isResponse()) |
| paramsClass = GinJavaBridgeRemoteObject_InvokeMethod_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var GinJavaBridgeRemoteObject = { |
| name: 'content.mojom.GinJavaBridgeRemoteObject', |
| kVersion: 0, |
| ptrClass: GinJavaBridgeRemoteObjectPtr, |
| proxyClass: GinJavaBridgeRemoteObjectProxy, |
| stubClass: GinJavaBridgeRemoteObjectStub, |
| validateRequest: validateGinJavaBridgeRemoteObjectRequest, |
| validateResponse: validateGinJavaBridgeRemoteObjectResponse, |
| }; |
| GinJavaBridgeRemoteObjectStub.prototype.validator = validateGinJavaBridgeRemoteObjectRequest; |
| GinJavaBridgeRemoteObjectProxy.prototype.validator = validateGinJavaBridgeRemoteObjectResponse; |
| var kGinJavaBridgeHost_GetObject_Name = 0; |
| var kGinJavaBridgeHost_ObjectWrapperDeleted_Name = 1; |
| |
| function GinJavaBridgeHostPtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(GinJavaBridgeHost, |
| handleOrPtrInfo); |
| } |
| |
| function GinJavaBridgeHostAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| GinJavaBridgeHost, associatedInterfacePtrInfo); |
| } |
| |
| GinJavaBridgeHostAssociatedPtr.prototype = |
| Object.create(GinJavaBridgeHostPtr.prototype); |
| GinJavaBridgeHostAssociatedPtr.prototype.constructor = |
| GinJavaBridgeHostAssociatedPtr; |
| |
| function GinJavaBridgeHostProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| GinJavaBridgeHostPtr.prototype.getObject = function() { |
| return GinJavaBridgeHostProxy.prototype.getObject |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| GinJavaBridgeHostProxy.prototype.getObject = function(objectId, receiver) { |
| var params_ = new GinJavaBridgeHost_GetObject_Params(); |
| params_.objectId = objectId; |
| params_.receiver = receiver; |
| var builder = new codec.MessageV0Builder( |
| kGinJavaBridgeHost_GetObject_Name, |
| codec.align(GinJavaBridgeHost_GetObject_Params.encodedSize)); |
| builder.encodeStruct(GinJavaBridgeHost_GetObject_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.accept(message); |
| }; |
| GinJavaBridgeHostPtr.prototype.objectWrapperDeleted = function() { |
| return GinJavaBridgeHostProxy.prototype.objectWrapperDeleted |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| GinJavaBridgeHostProxy.prototype.objectWrapperDeleted = function(objectId) { |
| var params_ = new GinJavaBridgeHost_ObjectWrapperDeleted_Params(); |
| params_.objectId = objectId; |
| var builder = new codec.MessageV0Builder( |
| kGinJavaBridgeHost_ObjectWrapperDeleted_Name, |
| codec.align(GinJavaBridgeHost_ObjectWrapperDeleted_Params.encodedSize)); |
| builder.encodeStruct(GinJavaBridgeHost_ObjectWrapperDeleted_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.accept(message); |
| }; |
| |
| function GinJavaBridgeHostStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| GinJavaBridgeHostStub.prototype.getObject = function(objectId, receiver) { |
| return this.delegate_ && this.delegate_.getObject && this.delegate_.getObject(objectId, receiver); |
| } |
| GinJavaBridgeHostStub.prototype.objectWrapperDeleted = function(objectId) { |
| return this.delegate_ && this.delegate_.objectWrapperDeleted && this.delegate_.objectWrapperDeleted(objectId); |
| } |
| |
| GinJavaBridgeHostStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kGinJavaBridgeHost_GetObject_Name: |
| var params = reader.decodeStruct(GinJavaBridgeHost_GetObject_Params); |
| this.getObject(params.objectId, params.receiver); |
| return true; |
| case kGinJavaBridgeHost_ObjectWrapperDeleted_Name: |
| var params = reader.decodeStruct(GinJavaBridgeHost_ObjectWrapperDeleted_Params); |
| this.objectWrapperDeleted(params.objectId); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| GinJavaBridgeHostStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| function validateGinJavaBridgeHostRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kGinJavaBridgeHost_GetObject_Name: |
| if (!message.expectsResponse() && !message.isResponse()) |
| paramsClass = GinJavaBridgeHost_GetObject_Params; |
| break; |
| case kGinJavaBridgeHost_ObjectWrapperDeleted_Name: |
| if (!message.expectsResponse() && !message.isResponse()) |
| paramsClass = GinJavaBridgeHost_ObjectWrapperDeleted_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateGinJavaBridgeHostResponse(messageValidator) { |
| return validator.validationError.NONE; |
| } |
| |
| var GinJavaBridgeHost = { |
| name: 'content.mojom.GinJavaBridgeHost', |
| kVersion: 0, |
| ptrClass: GinJavaBridgeHostPtr, |
| proxyClass: GinJavaBridgeHostProxy, |
| stubClass: GinJavaBridgeHostStub, |
| validateRequest: validateGinJavaBridgeHostRequest, |
| validateResponse: null, |
| }; |
| GinJavaBridgeHostStub.prototype.validator = validateGinJavaBridgeHostRequest; |
| GinJavaBridgeHostProxy.prototype.validator = null; |
| exports.GinJavaBridgeError = GinJavaBridgeError; |
| exports.GinJavaBridge = GinJavaBridge; |
| exports.GinJavaBridgePtr = GinJavaBridgePtr; |
| exports.GinJavaBridgeAssociatedPtr = GinJavaBridgeAssociatedPtr; |
| exports.GinJavaBridgeRemoteObject = GinJavaBridgeRemoteObject; |
| exports.GinJavaBridgeRemoteObjectPtr = GinJavaBridgeRemoteObjectPtr; |
| exports.GinJavaBridgeRemoteObjectAssociatedPtr = GinJavaBridgeRemoteObjectAssociatedPtr; |
| exports.GinJavaBridgeHost = GinJavaBridgeHost; |
| exports.GinJavaBridgeHostPtr = GinJavaBridgeHostPtr; |
| exports.GinJavaBridgeHostAssociatedPtr = GinJavaBridgeHostAssociatedPtr; |
| })(); |
