| // components/autofill/core/common/mojom/test_autofill_types.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 = 'components/autofill/core/common/mojom/test_autofill_types.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('autofill.mojom'); |
| var autofill_types$ = |
| mojo.internal.exposeNamespace('autofill.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'components/autofill/core/common/mojom/autofill_types.mojom', 'autofill_types.mojom.js'); |
| } |
| |
| |
| |
| function TypeTraitsTest_PassSection_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassSection_Params.prototype.initDefaults_ = function() { |
| this.s = null; |
| }; |
| TypeTraitsTest_PassSection_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassSection_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 TypeTraitsTest_PassSection_Params.s |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.Section, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassSection_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassSection_Params.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassSection_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.s = |
| decoder.decodeStructPointer(autofill_types$.Section); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassSection_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassSection_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.Section, val.s); |
| }; |
| function TypeTraitsTest_PassSection_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassSection_ResponseParams.prototype.initDefaults_ = function() { |
| this.passed = null; |
| }; |
| TypeTraitsTest_PassSection_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassSection_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 TypeTraitsTest_PassSection_ResponseParams.passed |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.Section, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassSection_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassSection_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassSection_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.passed = |
| decoder.decodeStructPointer(autofill_types$.Section); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassSection_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassSection_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.Section, val.passed); |
| }; |
| function TypeTraitsTest_PassFormData_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassFormData_Params.prototype.initDefaults_ = function() { |
| this.s = null; |
| }; |
| TypeTraitsTest_PassFormData_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassFormData_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 TypeTraitsTest_PassFormData_Params.s |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.FormData, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassFormData_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassFormData_Params.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassFormData_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.s = |
| decoder.decodeStructPointer(autofill_types$.FormData); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassFormData_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassFormData_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.FormData, val.s); |
| }; |
| function TypeTraitsTest_PassFormData_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassFormData_ResponseParams.prototype.initDefaults_ = function() { |
| this.passed = null; |
| }; |
| TypeTraitsTest_PassFormData_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassFormData_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 TypeTraitsTest_PassFormData_ResponseParams.passed |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.FormData, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassFormData_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassFormData_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassFormData_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.passed = |
| decoder.decodeStructPointer(autofill_types$.FormData); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassFormData_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassFormData_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.FormData, val.passed); |
| }; |
| function TypeTraitsTest_PassFormFieldData_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassFormFieldData_Params.prototype.initDefaults_ = function() { |
| this.s = null; |
| }; |
| TypeTraitsTest_PassFormFieldData_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassFormFieldData_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 TypeTraitsTest_PassFormFieldData_Params.s |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.FormFieldData, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassFormFieldData_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassFormFieldData_Params.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassFormFieldData_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.s = |
| decoder.decodeStructPointer(autofill_types$.FormFieldData); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassFormFieldData_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassFormFieldData_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.FormFieldData, val.s); |
| }; |
| function TypeTraitsTest_PassFormFieldData_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassFormFieldData_ResponseParams.prototype.initDefaults_ = function() { |
| this.passed = null; |
| }; |
| TypeTraitsTest_PassFormFieldData_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassFormFieldData_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 TypeTraitsTest_PassFormFieldData_ResponseParams.passed |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.FormFieldData, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassFormFieldData_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassFormFieldData_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassFormFieldData_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.passed = |
| decoder.decodeStructPointer(autofill_types$.FormFieldData); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassFormFieldData_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassFormFieldData_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.FormFieldData, val.passed); |
| }; |
| function TypeTraitsTest_PassFormDataPredictions_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassFormDataPredictions_Params.prototype.initDefaults_ = function() { |
| this.s = null; |
| }; |
| TypeTraitsTest_PassFormDataPredictions_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassFormDataPredictions_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 TypeTraitsTest_PassFormDataPredictions_Params.s |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.FormDataPredictions, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassFormDataPredictions_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassFormDataPredictions_Params.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassFormDataPredictions_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.s = |
| decoder.decodeStructPointer(autofill_types$.FormDataPredictions); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassFormDataPredictions_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassFormDataPredictions_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.FormDataPredictions, val.s); |
| }; |
| function TypeTraitsTest_PassFormDataPredictions_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassFormDataPredictions_ResponseParams.prototype.initDefaults_ = function() { |
| this.passed = null; |
| }; |
| TypeTraitsTest_PassFormDataPredictions_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassFormDataPredictions_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 TypeTraitsTest_PassFormDataPredictions_ResponseParams.passed |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.FormDataPredictions, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassFormDataPredictions_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassFormDataPredictions_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassFormDataPredictions_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.passed = |
| decoder.decodeStructPointer(autofill_types$.FormDataPredictions); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassFormDataPredictions_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassFormDataPredictions_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.FormDataPredictions, val.passed); |
| }; |
| function TypeTraitsTest_PassFormFieldDataPredictions_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassFormFieldDataPredictions_Params.prototype.initDefaults_ = function() { |
| this.s = null; |
| }; |
| TypeTraitsTest_PassFormFieldDataPredictions_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassFormFieldDataPredictions_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 TypeTraitsTest_PassFormFieldDataPredictions_Params.s |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.FormFieldDataPredictions, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassFormFieldDataPredictions_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassFormFieldDataPredictions_Params.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassFormFieldDataPredictions_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.s = |
| decoder.decodeStructPointer(autofill_types$.FormFieldDataPredictions); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassFormFieldDataPredictions_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassFormFieldDataPredictions_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.FormFieldDataPredictions, val.s); |
| }; |
| function TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams.prototype.initDefaults_ = function() { |
| this.passed = null; |
| }; |
| TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassFormFieldDataPredictions_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 TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams.passed |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.FormFieldDataPredictions, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.passed = |
| decoder.decodeStructPointer(autofill_types$.FormFieldDataPredictions); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.FormFieldDataPredictions, val.passed); |
| }; |
| function TypeTraitsTest_PassPasswordFormFillData_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassPasswordFormFillData_Params.prototype.initDefaults_ = function() { |
| this.s = null; |
| }; |
| TypeTraitsTest_PassPasswordFormFillData_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassPasswordFormFillData_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 TypeTraitsTest_PassPasswordFormFillData_Params.s |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.PasswordFormFillData, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassPasswordFormFillData_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassPasswordFormFillData_Params.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassPasswordFormFillData_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.s = |
| decoder.decodeStructPointer(autofill_types$.PasswordFormFillData); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassPasswordFormFillData_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassPasswordFormFillData_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.PasswordFormFillData, val.s); |
| }; |
| function TypeTraitsTest_PassPasswordFormFillData_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassPasswordFormFillData_ResponseParams.prototype.initDefaults_ = function() { |
| this.passed = null; |
| }; |
| TypeTraitsTest_PassPasswordFormFillData_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassPasswordFormFillData_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 TypeTraitsTest_PassPasswordFormFillData_ResponseParams.passed |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.PasswordFormFillData, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassPasswordFormFillData_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassPasswordFormFillData_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassPasswordFormFillData_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.passed = |
| decoder.decodeStructPointer(autofill_types$.PasswordFormFillData); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassPasswordFormFillData_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassPasswordFormFillData_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.PasswordFormFillData, val.passed); |
| }; |
| function TypeTraitsTest_PassPasswordFormGenerationData_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassPasswordFormGenerationData_Params.prototype.initDefaults_ = function() { |
| this.s = null; |
| }; |
| TypeTraitsTest_PassPasswordFormGenerationData_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassPasswordFormGenerationData_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 TypeTraitsTest_PassPasswordFormGenerationData_Params.s |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.PasswordFormGenerationData, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassPasswordFormGenerationData_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassPasswordFormGenerationData_Params.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassPasswordFormGenerationData_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.s = |
| decoder.decodeStructPointer(autofill_types$.PasswordFormGenerationData); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassPasswordFormGenerationData_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassPasswordFormGenerationData_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.PasswordFormGenerationData, val.s); |
| }; |
| function TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams.prototype.initDefaults_ = function() { |
| this.passed = null; |
| }; |
| TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassPasswordFormGenerationData_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 TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams.passed |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.PasswordFormGenerationData, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.passed = |
| decoder.decodeStructPointer(autofill_types$.PasswordFormGenerationData); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.PasswordFormGenerationData, val.passed); |
| }; |
| function TypeTraitsTest_PassPasswordGenerationUIData_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassPasswordGenerationUIData_Params.prototype.initDefaults_ = function() { |
| this.s = null; |
| }; |
| TypeTraitsTest_PassPasswordGenerationUIData_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassPasswordGenerationUIData_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 TypeTraitsTest_PassPasswordGenerationUIData_Params.s |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.PasswordGenerationUIData, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassPasswordGenerationUIData_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassPasswordGenerationUIData_Params.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassPasswordGenerationUIData_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.s = |
| decoder.decodeStructPointer(autofill_types$.PasswordGenerationUIData); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassPasswordGenerationUIData_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassPasswordGenerationUIData_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.PasswordGenerationUIData, val.s); |
| }; |
| function TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams.prototype.initDefaults_ = function() { |
| this.passed = null; |
| }; |
| TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassPasswordGenerationUIData_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 TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams.passed |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.PasswordGenerationUIData, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.passed = |
| decoder.decodeStructPointer(autofill_types$.PasswordGenerationUIData); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.PasswordGenerationUIData, val.passed); |
| }; |
| function TypeTraitsTest_PassPasswordSuggestionRequest_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassPasswordSuggestionRequest_Params.prototype.initDefaults_ = function() { |
| this.s = null; |
| }; |
| TypeTraitsTest_PassPasswordSuggestionRequest_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassPasswordSuggestionRequest_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 TypeTraitsTest_PassPasswordSuggestionRequest_Params.s |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.PasswordSuggestionRequest, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassPasswordSuggestionRequest_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassPasswordSuggestionRequest_Params.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassPasswordSuggestionRequest_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.s = |
| decoder.decodeStructPointer(autofill_types$.PasswordSuggestionRequest); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassPasswordSuggestionRequest_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassPasswordSuggestionRequest_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.PasswordSuggestionRequest, val.s); |
| }; |
| function TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams.prototype.initDefaults_ = function() { |
| this.passed = null; |
| }; |
| TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| TypeTraitsTest_PassPasswordSuggestionRequest_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 TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams.passed |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, autofill_types$.PasswordSuggestionRequest, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.passed = |
| decoder.decodeStructPointer(autofill_types$.PasswordSuggestionRequest); |
| return val; |
| }; |
| |
| TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(autofill_types$.PasswordSuggestionRequest, val.passed); |
| }; |
| var kTypeTraitsTest_PassSection_Name = 0; |
| var kTypeTraitsTest_PassFormData_Name = 1; |
| var kTypeTraitsTest_PassFormFieldData_Name = 2; |
| var kTypeTraitsTest_PassFormDataPredictions_Name = 3; |
| var kTypeTraitsTest_PassFormFieldDataPredictions_Name = 4; |
| var kTypeTraitsTest_PassPasswordFormFillData_Name = 5; |
| var kTypeTraitsTest_PassPasswordFormGenerationData_Name = 6; |
| var kTypeTraitsTest_PassPasswordGenerationUIData_Name = 7; |
| var kTypeTraitsTest_PassPasswordSuggestionRequest_Name = 8; |
| |
| function TypeTraitsTestPtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(TypeTraitsTest, |
| handleOrPtrInfo); |
| } |
| |
| function TypeTraitsTestAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| TypeTraitsTest, associatedInterfacePtrInfo); |
| } |
| |
| TypeTraitsTestAssociatedPtr.prototype = |
| Object.create(TypeTraitsTestPtr.prototype); |
| TypeTraitsTestAssociatedPtr.prototype.constructor = |
| TypeTraitsTestAssociatedPtr; |
| |
| function TypeTraitsTestProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| TypeTraitsTestPtr.prototype.passSection = function() { |
| return TypeTraitsTestProxy.prototype.passSection |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| TypeTraitsTestProxy.prototype.passSection = function(s) { |
| var params_ = new TypeTraitsTest_PassSection_Params(); |
| params_.s = s; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassSection_Name, |
| codec.align(TypeTraitsTest_PassSection_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(TypeTraitsTest_PassSection_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(TypeTraitsTest_PassSection_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| TypeTraitsTestPtr.prototype.passFormData = function() { |
| return TypeTraitsTestProxy.prototype.passFormData |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| TypeTraitsTestProxy.prototype.passFormData = function(s) { |
| var params_ = new TypeTraitsTest_PassFormData_Params(); |
| params_.s = s; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassFormData_Name, |
| codec.align(TypeTraitsTest_PassFormData_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(TypeTraitsTest_PassFormData_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(TypeTraitsTest_PassFormData_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| TypeTraitsTestPtr.prototype.passFormFieldData = function() { |
| return TypeTraitsTestProxy.prototype.passFormFieldData |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| TypeTraitsTestProxy.prototype.passFormFieldData = function(s) { |
| var params_ = new TypeTraitsTest_PassFormFieldData_Params(); |
| params_.s = s; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassFormFieldData_Name, |
| codec.align(TypeTraitsTest_PassFormFieldData_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(TypeTraitsTest_PassFormFieldData_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(TypeTraitsTest_PassFormFieldData_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| TypeTraitsTestPtr.prototype.passFormDataPredictions = function() { |
| return TypeTraitsTestProxy.prototype.passFormDataPredictions |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| TypeTraitsTestProxy.prototype.passFormDataPredictions = function(s) { |
| var params_ = new TypeTraitsTest_PassFormDataPredictions_Params(); |
| params_.s = s; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassFormDataPredictions_Name, |
| codec.align(TypeTraitsTest_PassFormDataPredictions_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(TypeTraitsTest_PassFormDataPredictions_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(TypeTraitsTest_PassFormDataPredictions_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| TypeTraitsTestPtr.prototype.passFormFieldDataPredictions = function() { |
| return TypeTraitsTestProxy.prototype.passFormFieldDataPredictions |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| TypeTraitsTestProxy.prototype.passFormFieldDataPredictions = function(s) { |
| var params_ = new TypeTraitsTest_PassFormFieldDataPredictions_Params(); |
| params_.s = s; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassFormFieldDataPredictions_Name, |
| codec.align(TypeTraitsTest_PassFormFieldDataPredictions_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(TypeTraitsTest_PassFormFieldDataPredictions_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| TypeTraitsTestPtr.prototype.passPasswordFormFillData = function() { |
| return TypeTraitsTestProxy.prototype.passPasswordFormFillData |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| TypeTraitsTestProxy.prototype.passPasswordFormFillData = function(s) { |
| var params_ = new TypeTraitsTest_PassPasswordFormFillData_Params(); |
| params_.s = s; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassPasswordFormFillData_Name, |
| codec.align(TypeTraitsTest_PassPasswordFormFillData_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(TypeTraitsTest_PassPasswordFormFillData_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(TypeTraitsTest_PassPasswordFormFillData_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| TypeTraitsTestPtr.prototype.passPasswordFormGenerationData = function() { |
| return TypeTraitsTestProxy.prototype.passPasswordFormGenerationData |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| TypeTraitsTestProxy.prototype.passPasswordFormGenerationData = function(s) { |
| var params_ = new TypeTraitsTest_PassPasswordFormGenerationData_Params(); |
| params_.s = s; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassPasswordFormGenerationData_Name, |
| codec.align(TypeTraitsTest_PassPasswordFormGenerationData_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(TypeTraitsTest_PassPasswordFormGenerationData_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| TypeTraitsTestPtr.prototype.passPasswordGenerationUIData = function() { |
| return TypeTraitsTestProxy.prototype.passPasswordGenerationUIData |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| TypeTraitsTestProxy.prototype.passPasswordGenerationUIData = function(s) { |
| var params_ = new TypeTraitsTest_PassPasswordGenerationUIData_Params(); |
| params_.s = s; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassPasswordGenerationUIData_Name, |
| codec.align(TypeTraitsTest_PassPasswordGenerationUIData_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(TypeTraitsTest_PassPasswordGenerationUIData_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| TypeTraitsTestPtr.prototype.passPasswordSuggestionRequest = function() { |
| return TypeTraitsTestProxy.prototype.passPasswordSuggestionRequest |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| TypeTraitsTestProxy.prototype.passPasswordSuggestionRequest = function(s) { |
| var params_ = new TypeTraitsTest_PassPasswordSuggestionRequest_Params(); |
| params_.s = s; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassPasswordSuggestionRequest_Name, |
| codec.align(TypeTraitsTest_PassPasswordSuggestionRequest_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(TypeTraitsTest_PassPasswordSuggestionRequest_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function TypeTraitsTestStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| TypeTraitsTestStub.prototype.passSection = function(s) { |
| return this.delegate_ && this.delegate_.passSection && this.delegate_.passSection(s); |
| } |
| TypeTraitsTestStub.prototype.passFormData = function(s) { |
| return this.delegate_ && this.delegate_.passFormData && this.delegate_.passFormData(s); |
| } |
| TypeTraitsTestStub.prototype.passFormFieldData = function(s) { |
| return this.delegate_ && this.delegate_.passFormFieldData && this.delegate_.passFormFieldData(s); |
| } |
| TypeTraitsTestStub.prototype.passFormDataPredictions = function(s) { |
| return this.delegate_ && this.delegate_.passFormDataPredictions && this.delegate_.passFormDataPredictions(s); |
| } |
| TypeTraitsTestStub.prototype.passFormFieldDataPredictions = function(s) { |
| return this.delegate_ && this.delegate_.passFormFieldDataPredictions && this.delegate_.passFormFieldDataPredictions(s); |
| } |
| TypeTraitsTestStub.prototype.passPasswordFormFillData = function(s) { |
| return this.delegate_ && this.delegate_.passPasswordFormFillData && this.delegate_.passPasswordFormFillData(s); |
| } |
| TypeTraitsTestStub.prototype.passPasswordFormGenerationData = function(s) { |
| return this.delegate_ && this.delegate_.passPasswordFormGenerationData && this.delegate_.passPasswordFormGenerationData(s); |
| } |
| TypeTraitsTestStub.prototype.passPasswordGenerationUIData = function(s) { |
| return this.delegate_ && this.delegate_.passPasswordGenerationUIData && this.delegate_.passPasswordGenerationUIData(s); |
| } |
| TypeTraitsTestStub.prototype.passPasswordSuggestionRequest = function(s) { |
| return this.delegate_ && this.delegate_.passPasswordSuggestionRequest && this.delegate_.passPasswordSuggestionRequest(s); |
| } |
| |
| TypeTraitsTestStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| TypeTraitsTestStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kTypeTraitsTest_PassSection_Name: |
| var params = reader.decodeStruct(TypeTraitsTest_PassSection_Params); |
| this.passSection(params.s).then(function(response) { |
| var responseParams = |
| new TypeTraitsTest_PassSection_ResponseParams(); |
| responseParams.passed = response.passed; |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassSection_Name, |
| codec.align(TypeTraitsTest_PassSection_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(TypeTraitsTest_PassSection_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kTypeTraitsTest_PassFormData_Name: |
| var params = reader.decodeStruct(TypeTraitsTest_PassFormData_Params); |
| this.passFormData(params.s).then(function(response) { |
| var responseParams = |
| new TypeTraitsTest_PassFormData_ResponseParams(); |
| responseParams.passed = response.passed; |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassFormData_Name, |
| codec.align(TypeTraitsTest_PassFormData_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(TypeTraitsTest_PassFormData_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kTypeTraitsTest_PassFormFieldData_Name: |
| var params = reader.decodeStruct(TypeTraitsTest_PassFormFieldData_Params); |
| this.passFormFieldData(params.s).then(function(response) { |
| var responseParams = |
| new TypeTraitsTest_PassFormFieldData_ResponseParams(); |
| responseParams.passed = response.passed; |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassFormFieldData_Name, |
| codec.align(TypeTraitsTest_PassFormFieldData_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(TypeTraitsTest_PassFormFieldData_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kTypeTraitsTest_PassFormDataPredictions_Name: |
| var params = reader.decodeStruct(TypeTraitsTest_PassFormDataPredictions_Params); |
| this.passFormDataPredictions(params.s).then(function(response) { |
| var responseParams = |
| new TypeTraitsTest_PassFormDataPredictions_ResponseParams(); |
| responseParams.passed = response.passed; |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassFormDataPredictions_Name, |
| codec.align(TypeTraitsTest_PassFormDataPredictions_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(TypeTraitsTest_PassFormDataPredictions_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kTypeTraitsTest_PassFormFieldDataPredictions_Name: |
| var params = reader.decodeStruct(TypeTraitsTest_PassFormFieldDataPredictions_Params); |
| this.passFormFieldDataPredictions(params.s).then(function(response) { |
| var responseParams = |
| new TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams(); |
| responseParams.passed = response.passed; |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassFormFieldDataPredictions_Name, |
| codec.align(TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kTypeTraitsTest_PassPasswordFormFillData_Name: |
| var params = reader.decodeStruct(TypeTraitsTest_PassPasswordFormFillData_Params); |
| this.passPasswordFormFillData(params.s).then(function(response) { |
| var responseParams = |
| new TypeTraitsTest_PassPasswordFormFillData_ResponseParams(); |
| responseParams.passed = response.passed; |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassPasswordFormFillData_Name, |
| codec.align(TypeTraitsTest_PassPasswordFormFillData_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(TypeTraitsTest_PassPasswordFormFillData_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kTypeTraitsTest_PassPasswordFormGenerationData_Name: |
| var params = reader.decodeStruct(TypeTraitsTest_PassPasswordFormGenerationData_Params); |
| this.passPasswordFormGenerationData(params.s).then(function(response) { |
| var responseParams = |
| new TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams(); |
| responseParams.passed = response.passed; |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassPasswordFormGenerationData_Name, |
| codec.align(TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kTypeTraitsTest_PassPasswordGenerationUIData_Name: |
| var params = reader.decodeStruct(TypeTraitsTest_PassPasswordGenerationUIData_Params); |
| this.passPasswordGenerationUIData(params.s).then(function(response) { |
| var responseParams = |
| new TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams(); |
| responseParams.passed = response.passed; |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassPasswordGenerationUIData_Name, |
| codec.align(TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kTypeTraitsTest_PassPasswordSuggestionRequest_Name: |
| var params = reader.decodeStruct(TypeTraitsTest_PassPasswordSuggestionRequest_Params); |
| this.passPasswordSuggestionRequest(params.s).then(function(response) { |
| var responseParams = |
| new TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams(); |
| responseParams.passed = response.passed; |
| var builder = new codec.MessageV1Builder( |
| kTypeTraitsTest_PassPasswordSuggestionRequest_Name, |
| codec.align(TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateTypeTraitsTestRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kTypeTraitsTest_PassSection_Name: |
| if (message.expectsResponse()) |
| paramsClass = TypeTraitsTest_PassSection_Params; |
| break; |
| case kTypeTraitsTest_PassFormData_Name: |
| if (message.expectsResponse()) |
| paramsClass = TypeTraitsTest_PassFormData_Params; |
| break; |
| case kTypeTraitsTest_PassFormFieldData_Name: |
| if (message.expectsResponse()) |
| paramsClass = TypeTraitsTest_PassFormFieldData_Params; |
| break; |
| case kTypeTraitsTest_PassFormDataPredictions_Name: |
| if (message.expectsResponse()) |
| paramsClass = TypeTraitsTest_PassFormDataPredictions_Params; |
| break; |
| case kTypeTraitsTest_PassFormFieldDataPredictions_Name: |
| if (message.expectsResponse()) |
| paramsClass = TypeTraitsTest_PassFormFieldDataPredictions_Params; |
| break; |
| case kTypeTraitsTest_PassPasswordFormFillData_Name: |
| if (message.expectsResponse()) |
| paramsClass = TypeTraitsTest_PassPasswordFormFillData_Params; |
| break; |
| case kTypeTraitsTest_PassPasswordFormGenerationData_Name: |
| if (message.expectsResponse()) |
| paramsClass = TypeTraitsTest_PassPasswordFormGenerationData_Params; |
| break; |
| case kTypeTraitsTest_PassPasswordGenerationUIData_Name: |
| if (message.expectsResponse()) |
| paramsClass = TypeTraitsTest_PassPasswordGenerationUIData_Params; |
| break; |
| case kTypeTraitsTest_PassPasswordSuggestionRequest_Name: |
| if (message.expectsResponse()) |
| paramsClass = TypeTraitsTest_PassPasswordSuggestionRequest_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateTypeTraitsTestResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kTypeTraitsTest_PassSection_Name: |
| if (message.isResponse()) |
| paramsClass = TypeTraitsTest_PassSection_ResponseParams; |
| break; |
| case kTypeTraitsTest_PassFormData_Name: |
| if (message.isResponse()) |
| paramsClass = TypeTraitsTest_PassFormData_ResponseParams; |
| break; |
| case kTypeTraitsTest_PassFormFieldData_Name: |
| if (message.isResponse()) |
| paramsClass = TypeTraitsTest_PassFormFieldData_ResponseParams; |
| break; |
| case kTypeTraitsTest_PassFormDataPredictions_Name: |
| if (message.isResponse()) |
| paramsClass = TypeTraitsTest_PassFormDataPredictions_ResponseParams; |
| break; |
| case kTypeTraitsTest_PassFormFieldDataPredictions_Name: |
| if (message.isResponse()) |
| paramsClass = TypeTraitsTest_PassFormFieldDataPredictions_ResponseParams; |
| break; |
| case kTypeTraitsTest_PassPasswordFormFillData_Name: |
| if (message.isResponse()) |
| paramsClass = TypeTraitsTest_PassPasswordFormFillData_ResponseParams; |
| break; |
| case kTypeTraitsTest_PassPasswordFormGenerationData_Name: |
| if (message.isResponse()) |
| paramsClass = TypeTraitsTest_PassPasswordFormGenerationData_ResponseParams; |
| break; |
| case kTypeTraitsTest_PassPasswordGenerationUIData_Name: |
| if (message.isResponse()) |
| paramsClass = TypeTraitsTest_PassPasswordGenerationUIData_ResponseParams; |
| break; |
| case kTypeTraitsTest_PassPasswordSuggestionRequest_Name: |
| if (message.isResponse()) |
| paramsClass = TypeTraitsTest_PassPasswordSuggestionRequest_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var TypeTraitsTest = { |
| name: 'autofill.mojom.TypeTraitsTest', |
| kVersion: 0, |
| ptrClass: TypeTraitsTestPtr, |
| proxyClass: TypeTraitsTestProxy, |
| stubClass: TypeTraitsTestStub, |
| validateRequest: validateTypeTraitsTestRequest, |
| validateResponse: validateTypeTraitsTestResponse, |
| }; |
| TypeTraitsTestStub.prototype.validator = validateTypeTraitsTestRequest; |
| TypeTraitsTestProxy.prototype.validator = validateTypeTraitsTestResponse; |
| exports.TypeTraitsTest = TypeTraitsTest; |
| exports.TypeTraitsTestPtr = TypeTraitsTestPtr; |
| exports.TypeTraitsTestAssociatedPtr = TypeTraitsTestAssociatedPtr; |
| })(); |
