| // components/services/unzip/public/mojom/unzipper.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/services/unzip/public/mojom/unzipper.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('unzip.mojom'); |
| var directory$ = |
| mojo.internal.exposeNamespace('storage.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'components/services/storage/public/mojom/filesystem/directory.mojom', '../../../storage/public/mojom/filesystem/directory.mojom.js'); |
| } |
| var file_path$ = |
| mojo.internal.exposeNamespace('mojoBase.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'mojo/public/mojom/base/file_path.mojom', '../../../../../mojo/public/mojom/base/file_path.mojom.js'); |
| } |
| var read_only_file$ = |
| mojo.internal.exposeNamespace('mojoBase.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'mojo/public/mojom/base/read_only_file.mojom', '../../../../../mojo/public/mojom/base/read_only_file.mojom.js'); |
| } |
| var sandbox$ = |
| mojo.internal.exposeNamespace('sandbox.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'sandbox/policy/mojom/sandbox.mojom', '../../../../../sandbox/policy/mojom/sandbox.mojom.js'); |
| } |
| |
| |
| |
| function UnzipOptions(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| UnzipOptions.prototype.initDefaults_ = function() { |
| this.encoding = null; |
| this.password = null; |
| }; |
| UnzipOptions.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| UnzipOptions.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 UnzipOptions.encoding |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate UnzipOptions.password |
| err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 8, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| UnzipOptions.encodedSize = codec.kStructHeaderSize + 16; |
| |
| UnzipOptions.decode = function(decoder) { |
| var packed; |
| var val = new UnzipOptions(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.encoding = |
| decoder.decodeStruct(codec.String); |
| val.password = |
| decoder.decodeStruct(codec.String); |
| return val; |
| }; |
| |
| UnzipOptions.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(UnzipOptions.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.String, val.encoding); |
| encoder.encodeStruct(codec.String, val.password); |
| }; |
| function Info(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| Info.prototype.initDefaults_ = function() { |
| this.sizeIsValid = false; |
| this.isEncrypted = false; |
| this.usesAesEncryption = false; |
| this.size = 0; |
| }; |
| Info.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| Info.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; |
| |
| |
| |
| |
| |
| return validator.validationError.NONE; |
| }; |
| |
| Info.encodedSize = codec.kStructHeaderSize + 16; |
| |
| Info.decode = function(decoder) { |
| var packed; |
| var val = new Info(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| packed = decoder.readUint8(); |
| val.sizeIsValid = (packed >> 0) & 1 ? true : false; |
| val.isEncrypted = (packed >> 1) & 1 ? true : false; |
| val.usesAesEncryption = (packed >> 2) & 1 ? true : false; |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| val.size = |
| decoder.decodeStruct(codec.Uint64); |
| return val; |
| }; |
| |
| Info.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(Info.encodedSize); |
| encoder.writeUint32(0); |
| packed = 0; |
| packed |= (val.sizeIsValid & 1) << 0 |
| packed |= (val.isEncrypted & 1) << 1 |
| packed |= (val.usesAesEncryption & 1) << 2 |
| encoder.writeUint8(packed); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.encodeStruct(codec.Uint64, val.size); |
| }; |
| function UnzipFilter_ShouldUnzipFile_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| UnzipFilter_ShouldUnzipFile_Params.prototype.initDefaults_ = function() { |
| this.path = null; |
| }; |
| UnzipFilter_ShouldUnzipFile_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| UnzipFilter_ShouldUnzipFile_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 UnzipFilter_ShouldUnzipFile_Params.path |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, file_path$.FilePath, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| UnzipFilter_ShouldUnzipFile_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| UnzipFilter_ShouldUnzipFile_Params.decode = function(decoder) { |
| var packed; |
| var val = new UnzipFilter_ShouldUnzipFile_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.path = |
| decoder.decodeStructPointer(file_path$.FilePath); |
| return val; |
| }; |
| |
| UnzipFilter_ShouldUnzipFile_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(UnzipFilter_ShouldUnzipFile_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(file_path$.FilePath, val.path); |
| }; |
| function UnzipFilter_ShouldUnzipFile_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| UnzipFilter_ShouldUnzipFile_ResponseParams.prototype.initDefaults_ = function() { |
| this.result = false; |
| }; |
| UnzipFilter_ShouldUnzipFile_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| UnzipFilter_ShouldUnzipFile_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; |
| }; |
| |
| UnzipFilter_ShouldUnzipFile_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| UnzipFilter_ShouldUnzipFile_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new UnzipFilter_ShouldUnzipFile_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; |
| }; |
| |
| UnzipFilter_ShouldUnzipFile_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(UnzipFilter_ShouldUnzipFile_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 UnzipListener_OnProgress_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| UnzipListener_OnProgress_Params.prototype.initDefaults_ = function() { |
| this.bytes = 0; |
| }; |
| UnzipListener_OnProgress_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| UnzipListener_OnProgress_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; |
| }; |
| |
| UnzipListener_OnProgress_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| UnzipListener_OnProgress_Params.decode = function(decoder) { |
| var packed; |
| var val = new UnzipListener_OnProgress_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.bytes = |
| decoder.decodeStruct(codec.Uint64); |
| return val; |
| }; |
| |
| UnzipListener_OnProgress_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(UnzipListener_OnProgress_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.Uint64, val.bytes); |
| }; |
| function Unzipper_Unzip_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| Unzipper_Unzip_Params.prototype.initDefaults_ = function() { |
| this.zipFile = null; |
| this.outputDir = new directory$.DirectoryPtr(); |
| this.options = null; |
| this.filter = new UnzipFilterPtr(); |
| this.listener = new UnzipListenerPtr(); |
| }; |
| Unzipper_Unzip_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| Unzipper_Unzip_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: 48} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate Unzipper_Unzip_Params.zipFile |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, read_only_file$.ReadOnlyFile, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate Unzipper_Unzip_Params.outputDir |
| err = messageValidator.validateInterface(offset + codec.kStructHeaderSize + 8, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate Unzipper_Unzip_Params.options |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 16, UnzipOptions, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate Unzipper_Unzip_Params.filter |
| err = messageValidator.validateInterface(offset + codec.kStructHeaderSize + 24, true); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate Unzipper_Unzip_Params.listener |
| err = messageValidator.validateInterface(offset + codec.kStructHeaderSize + 32, true); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| Unzipper_Unzip_Params.encodedSize = codec.kStructHeaderSize + 40; |
| |
| Unzipper_Unzip_Params.decode = function(decoder) { |
| var packed; |
| var val = new Unzipper_Unzip_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.zipFile = |
| decoder.decodeStructPointer(read_only_file$.ReadOnlyFile); |
| val.outputDir = |
| decoder.decodeStruct(new codec.Interface(directory$.DirectoryPtr)); |
| val.options = |
| decoder.decodeStructPointer(UnzipOptions); |
| val.filter = |
| decoder.decodeStruct(new codec.NullableInterface(UnzipFilterPtr)); |
| val.listener = |
| decoder.decodeStruct(new codec.NullableInterface(UnzipListenerPtr)); |
| return val; |
| }; |
| |
| Unzipper_Unzip_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(Unzipper_Unzip_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(read_only_file$.ReadOnlyFile, val.zipFile); |
| encoder.encodeStruct(new codec.Interface(directory$.DirectoryPtr), val.outputDir); |
| encoder.encodeStructPointer(UnzipOptions, val.options); |
| encoder.encodeStruct(new codec.NullableInterface(UnzipFilterPtr), val.filter); |
| encoder.encodeStruct(new codec.NullableInterface(UnzipListenerPtr), val.listener); |
| }; |
| function Unzipper_Unzip_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| Unzipper_Unzip_ResponseParams.prototype.initDefaults_ = function() { |
| this.result = false; |
| }; |
| Unzipper_Unzip_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| Unzipper_Unzip_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; |
| }; |
| |
| Unzipper_Unzip_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| Unzipper_Unzip_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new Unzipper_Unzip_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; |
| }; |
| |
| Unzipper_Unzip_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(Unzipper_Unzip_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 Unzipper_DetectEncoding_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| Unzipper_DetectEncoding_Params.prototype.initDefaults_ = function() { |
| this.zipFile = null; |
| }; |
| Unzipper_DetectEncoding_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| Unzipper_DetectEncoding_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 Unzipper_DetectEncoding_Params.zipFile |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, read_only_file$.ReadOnlyFile, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| Unzipper_DetectEncoding_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| Unzipper_DetectEncoding_Params.decode = function(decoder) { |
| var packed; |
| var val = new Unzipper_DetectEncoding_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.zipFile = |
| decoder.decodeStructPointer(read_only_file$.ReadOnlyFile); |
| return val; |
| }; |
| |
| Unzipper_DetectEncoding_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(Unzipper_DetectEncoding_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(read_only_file$.ReadOnlyFile, val.zipFile); |
| }; |
| function Unzipper_DetectEncoding_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| Unzipper_DetectEncoding_ResponseParams.prototype.initDefaults_ = function() { |
| this.encoding = 0; |
| }; |
| Unzipper_DetectEncoding_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| Unzipper_DetectEncoding_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; |
| }; |
| |
| Unzipper_DetectEncoding_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| Unzipper_DetectEncoding_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new Unzipper_DetectEncoding_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.encoding = |
| decoder.decodeStruct(codec.Int32); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| return val; |
| }; |
| |
| Unzipper_DetectEncoding_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(Unzipper_DetectEncoding_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.Int32, val.encoding); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| }; |
| function Unzipper_GetExtractedInfo_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| Unzipper_GetExtractedInfo_Params.prototype.initDefaults_ = function() { |
| this.zipFile = null; |
| }; |
| Unzipper_GetExtractedInfo_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| Unzipper_GetExtractedInfo_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 Unzipper_GetExtractedInfo_Params.zipFile |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, read_only_file$.ReadOnlyFile, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| Unzipper_GetExtractedInfo_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| Unzipper_GetExtractedInfo_Params.decode = function(decoder) { |
| var packed; |
| var val = new Unzipper_GetExtractedInfo_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.zipFile = |
| decoder.decodeStructPointer(read_only_file$.ReadOnlyFile); |
| return val; |
| }; |
| |
| Unzipper_GetExtractedInfo_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(Unzipper_GetExtractedInfo_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(read_only_file$.ReadOnlyFile, val.zipFile); |
| }; |
| function Unzipper_GetExtractedInfo_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| Unzipper_GetExtractedInfo_ResponseParams.prototype.initDefaults_ = function() { |
| this.info = null; |
| }; |
| Unzipper_GetExtractedInfo_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| Unzipper_GetExtractedInfo_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 Unzipper_GetExtractedInfo_ResponseParams.info |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, Info, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| Unzipper_GetExtractedInfo_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| Unzipper_GetExtractedInfo_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new Unzipper_GetExtractedInfo_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.info = |
| decoder.decodeStructPointer(Info); |
| return val; |
| }; |
| |
| Unzipper_GetExtractedInfo_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(Unzipper_GetExtractedInfo_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(Info, val.info); |
| }; |
| var kUnzipFilter_ShouldUnzipFile_Name = 0; |
| |
| function UnzipFilterPtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(UnzipFilter, |
| handleOrPtrInfo); |
| } |
| |
| function UnzipFilterAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| UnzipFilter, associatedInterfacePtrInfo); |
| } |
| |
| UnzipFilterAssociatedPtr.prototype = |
| Object.create(UnzipFilterPtr.prototype); |
| UnzipFilterAssociatedPtr.prototype.constructor = |
| UnzipFilterAssociatedPtr; |
| |
| function UnzipFilterProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| UnzipFilterPtr.prototype.shouldUnzipFile = function() { |
| return UnzipFilterProxy.prototype.shouldUnzipFile |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| UnzipFilterProxy.prototype.shouldUnzipFile = function(path) { |
| var params_ = new UnzipFilter_ShouldUnzipFile_Params(); |
| params_.path = path; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kUnzipFilter_ShouldUnzipFile_Name, |
| codec.align(UnzipFilter_ShouldUnzipFile_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(UnzipFilter_ShouldUnzipFile_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(UnzipFilter_ShouldUnzipFile_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function UnzipFilterStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| UnzipFilterStub.prototype.shouldUnzipFile = function(path) { |
| return this.delegate_ && this.delegate_.shouldUnzipFile && this.delegate_.shouldUnzipFile(path); |
| } |
| |
| UnzipFilterStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| UnzipFilterStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kUnzipFilter_ShouldUnzipFile_Name: |
| var params = reader.decodeStruct(UnzipFilter_ShouldUnzipFile_Params); |
| this.shouldUnzipFile(params.path).then(function(response) { |
| var responseParams = |
| new UnzipFilter_ShouldUnzipFile_ResponseParams(); |
| responseParams.result = response.result; |
| var builder = new codec.MessageV1Builder( |
| kUnzipFilter_ShouldUnzipFile_Name, |
| codec.align(UnzipFilter_ShouldUnzipFile_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(UnzipFilter_ShouldUnzipFile_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateUnzipFilterRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kUnzipFilter_ShouldUnzipFile_Name: |
| if (message.expectsResponse()) |
| paramsClass = UnzipFilter_ShouldUnzipFile_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateUnzipFilterResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kUnzipFilter_ShouldUnzipFile_Name: |
| if (message.isResponse()) |
| paramsClass = UnzipFilter_ShouldUnzipFile_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var UnzipFilter = { |
| name: 'unzip.mojom.UnzipFilter', |
| kVersion: 0, |
| ptrClass: UnzipFilterPtr, |
| proxyClass: UnzipFilterProxy, |
| stubClass: UnzipFilterStub, |
| validateRequest: validateUnzipFilterRequest, |
| validateResponse: validateUnzipFilterResponse, |
| }; |
| UnzipFilterStub.prototype.validator = validateUnzipFilterRequest; |
| UnzipFilterProxy.prototype.validator = validateUnzipFilterResponse; |
| var kUnzipListener_OnProgress_Name = 0; |
| |
| function UnzipListenerPtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(UnzipListener, |
| handleOrPtrInfo); |
| } |
| |
| function UnzipListenerAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| UnzipListener, associatedInterfacePtrInfo); |
| } |
| |
| UnzipListenerAssociatedPtr.prototype = |
| Object.create(UnzipListenerPtr.prototype); |
| UnzipListenerAssociatedPtr.prototype.constructor = |
| UnzipListenerAssociatedPtr; |
| |
| function UnzipListenerProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| UnzipListenerPtr.prototype.onProgress = function() { |
| return UnzipListenerProxy.prototype.onProgress |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| UnzipListenerProxy.prototype.onProgress = function(bytes) { |
| var params_ = new UnzipListener_OnProgress_Params(); |
| params_.bytes = bytes; |
| var builder = new codec.MessageV0Builder( |
| kUnzipListener_OnProgress_Name, |
| codec.align(UnzipListener_OnProgress_Params.encodedSize)); |
| builder.encodeStruct(UnzipListener_OnProgress_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.accept(message); |
| }; |
| |
| function UnzipListenerStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| UnzipListenerStub.prototype.onProgress = function(bytes) { |
| return this.delegate_ && this.delegate_.onProgress && this.delegate_.onProgress(bytes); |
| } |
| |
| UnzipListenerStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kUnzipListener_OnProgress_Name: |
| var params = reader.decodeStruct(UnzipListener_OnProgress_Params); |
| this.onProgress(params.bytes); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| UnzipListenerStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| function validateUnzipListenerRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kUnzipListener_OnProgress_Name: |
| if (!message.expectsResponse() && !message.isResponse()) |
| paramsClass = UnzipListener_OnProgress_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateUnzipListenerResponse(messageValidator) { |
| return validator.validationError.NONE; |
| } |
| |
| var UnzipListener = { |
| name: 'unzip.mojom.UnzipListener', |
| kVersion: 0, |
| ptrClass: UnzipListenerPtr, |
| proxyClass: UnzipListenerProxy, |
| stubClass: UnzipListenerStub, |
| validateRequest: validateUnzipListenerRequest, |
| validateResponse: null, |
| }; |
| UnzipListenerStub.prototype.validator = validateUnzipListenerRequest; |
| UnzipListenerProxy.prototype.validator = null; |
| var kUnzipper_Unzip_Name = 0; |
| var kUnzipper_DetectEncoding_Name = 1; |
| var kUnzipper_GetExtractedInfo_Name = 2; |
| |
| function UnzipperPtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(Unzipper, |
| handleOrPtrInfo); |
| } |
| |
| function UnzipperAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| Unzipper, associatedInterfacePtrInfo); |
| } |
| |
| UnzipperAssociatedPtr.prototype = |
| Object.create(UnzipperPtr.prototype); |
| UnzipperAssociatedPtr.prototype.constructor = |
| UnzipperAssociatedPtr; |
| |
| function UnzipperProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| UnzipperPtr.prototype.unzip = function() { |
| return UnzipperProxy.prototype.unzip |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| UnzipperProxy.prototype.unzip = function(zipFile, outputDir, options, filter, listener) { |
| var params_ = new Unzipper_Unzip_Params(); |
| params_.zipFile = zipFile; |
| params_.outputDir = outputDir; |
| params_.options = options; |
| params_.filter = filter; |
| params_.listener = listener; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kUnzipper_Unzip_Name, |
| codec.align(Unzipper_Unzip_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(Unzipper_Unzip_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(Unzipper_Unzip_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| UnzipperPtr.prototype.detectEncoding = function() { |
| return UnzipperProxy.prototype.detectEncoding |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| UnzipperProxy.prototype.detectEncoding = function(zipFile) { |
| var params_ = new Unzipper_DetectEncoding_Params(); |
| params_.zipFile = zipFile; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kUnzipper_DetectEncoding_Name, |
| codec.align(Unzipper_DetectEncoding_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(Unzipper_DetectEncoding_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(Unzipper_DetectEncoding_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| UnzipperPtr.prototype.getExtractedInfo = function() { |
| return UnzipperProxy.prototype.getExtractedInfo |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| UnzipperProxy.prototype.getExtractedInfo = function(zipFile) { |
| var params_ = new Unzipper_GetExtractedInfo_Params(); |
| params_.zipFile = zipFile; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kUnzipper_GetExtractedInfo_Name, |
| codec.align(Unzipper_GetExtractedInfo_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(Unzipper_GetExtractedInfo_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(Unzipper_GetExtractedInfo_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function UnzipperStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| UnzipperStub.prototype.unzip = function(zipFile, outputDir, options, filter, listener) { |
| return this.delegate_ && this.delegate_.unzip && this.delegate_.unzip(zipFile, outputDir, options, filter, listener); |
| } |
| UnzipperStub.prototype.detectEncoding = function(zipFile) { |
| return this.delegate_ && this.delegate_.detectEncoding && this.delegate_.detectEncoding(zipFile); |
| } |
| UnzipperStub.prototype.getExtractedInfo = function(zipFile) { |
| return this.delegate_ && this.delegate_.getExtractedInfo && this.delegate_.getExtractedInfo(zipFile); |
| } |
| |
| UnzipperStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| UnzipperStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kUnzipper_Unzip_Name: |
| var params = reader.decodeStruct(Unzipper_Unzip_Params); |
| this.unzip(params.zipFile, params.outputDir, params.options, params.filter, params.listener).then(function(response) { |
| var responseParams = |
| new Unzipper_Unzip_ResponseParams(); |
| responseParams.result = response.result; |
| var builder = new codec.MessageV1Builder( |
| kUnzipper_Unzip_Name, |
| codec.align(Unzipper_Unzip_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(Unzipper_Unzip_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kUnzipper_DetectEncoding_Name: |
| var params = reader.decodeStruct(Unzipper_DetectEncoding_Params); |
| this.detectEncoding(params.zipFile).then(function(response) { |
| var responseParams = |
| new Unzipper_DetectEncoding_ResponseParams(); |
| responseParams.encoding = response.encoding; |
| var builder = new codec.MessageV1Builder( |
| kUnzipper_DetectEncoding_Name, |
| codec.align(Unzipper_DetectEncoding_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(Unzipper_DetectEncoding_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kUnzipper_GetExtractedInfo_Name: |
| var params = reader.decodeStruct(Unzipper_GetExtractedInfo_Params); |
| this.getExtractedInfo(params.zipFile).then(function(response) { |
| var responseParams = |
| new Unzipper_GetExtractedInfo_ResponseParams(); |
| responseParams.info = response.info; |
| var builder = new codec.MessageV1Builder( |
| kUnzipper_GetExtractedInfo_Name, |
| codec.align(Unzipper_GetExtractedInfo_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(Unzipper_GetExtractedInfo_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateUnzipperRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kUnzipper_Unzip_Name: |
| if (message.expectsResponse()) |
| paramsClass = Unzipper_Unzip_Params; |
| break; |
| case kUnzipper_DetectEncoding_Name: |
| if (message.expectsResponse()) |
| paramsClass = Unzipper_DetectEncoding_Params; |
| break; |
| case kUnzipper_GetExtractedInfo_Name: |
| if (message.expectsResponse()) |
| paramsClass = Unzipper_GetExtractedInfo_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateUnzipperResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kUnzipper_Unzip_Name: |
| if (message.isResponse()) |
| paramsClass = Unzipper_Unzip_ResponseParams; |
| break; |
| case kUnzipper_DetectEncoding_Name: |
| if (message.isResponse()) |
| paramsClass = Unzipper_DetectEncoding_ResponseParams; |
| break; |
| case kUnzipper_GetExtractedInfo_Name: |
| if (message.isResponse()) |
| paramsClass = Unzipper_GetExtractedInfo_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var Unzipper = { |
| name: 'unzip.mojom.Unzipper', |
| kVersion: 0, |
| ptrClass: UnzipperPtr, |
| proxyClass: UnzipperProxy, |
| stubClass: UnzipperStub, |
| validateRequest: validateUnzipperRequest, |
| validateResponse: validateUnzipperResponse, |
| }; |
| UnzipperStub.prototype.validator = validateUnzipperRequest; |
| UnzipperProxy.prototype.validator = validateUnzipperResponse; |
| exports.UnzipOptions = UnzipOptions; |
| exports.Info = Info; |
| exports.UnzipFilter = UnzipFilter; |
| exports.UnzipFilterPtr = UnzipFilterPtr; |
| exports.UnzipFilterAssociatedPtr = UnzipFilterAssociatedPtr; |
| exports.UnzipListener = UnzipListener; |
| exports.UnzipListenerPtr = UnzipListenerPtr; |
| exports.UnzipListenerAssociatedPtr = UnzipListenerAssociatedPtr; |
| exports.Unzipper = Unzipper; |
| exports.UnzipperPtr = UnzipperPtr; |
| exports.UnzipperAssociatedPtr = UnzipperAssociatedPtr; |
| })(); |
