| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| 'use strict'; |
| |
| (function() { |
| var mojomId = 'third_party/blink/public/mojom/native_file_system/native_file_system_file_writer.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('blink.mojom'); |
| var blob$ = |
| mojo.internal.exposeNamespace('blink.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'third_party/blink/public/mojom/blob/blob.mojom', '../blob/blob.mojom.js'); |
| } |
| var native_file_system_error$ = |
| mojo.internal.exposeNamespace('blink.mojom'); |
| if (mojo.config.autoLoadMojomDeps) { |
| mojo.internal.loadMojomIfNecessary( |
| 'third_party/blink/public/mojom/native_file_system/native_file_system_error.mojom', 'native_file_system_error.mojom.js'); |
| } |
| |
| |
| |
| function NativeFileSystemFileWriter_Write_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| NativeFileSystemFileWriter_Write_Params.prototype.initDefaults_ = function() { |
| this.offset = 0; |
| this.data = new blob$.BlobPtr(); |
| }; |
| NativeFileSystemFileWriter_Write_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| NativeFileSystemFileWriter_Write_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 24} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| |
| // validate NativeFileSystemFileWriter_Write_Params.data |
| err = messageValidator.validateInterface(offset + codec.kStructHeaderSize + 8, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| NativeFileSystemFileWriter_Write_Params.encodedSize = codec.kStructHeaderSize + 16; |
| |
| NativeFileSystemFileWriter_Write_Params.decode = function(decoder) { |
| var packed; |
| var val = new NativeFileSystemFileWriter_Write_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.offset = decoder.decodeStruct(codec.Uint64); |
| val.data = decoder.decodeStruct(new codec.Interface(blob$.BlobPtr)); |
| return val; |
| }; |
| |
| NativeFileSystemFileWriter_Write_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(NativeFileSystemFileWriter_Write_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.Uint64, val.offset); |
| encoder.encodeStruct(new codec.Interface(blob$.BlobPtr), val.data); |
| }; |
| function NativeFileSystemFileWriter_Write_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| NativeFileSystemFileWriter_Write_ResponseParams.prototype.initDefaults_ = function() { |
| this.result = null; |
| this.bytesWritten = 0; |
| }; |
| NativeFileSystemFileWriter_Write_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| NativeFileSystemFileWriter_Write_ResponseParams.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 24} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate NativeFileSystemFileWriter_Write_ResponseParams.result |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, native_file_system_error$.NativeFileSystemError, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| return validator.validationError.NONE; |
| }; |
| |
| NativeFileSystemFileWriter_Write_ResponseParams.encodedSize = codec.kStructHeaderSize + 16; |
| |
| NativeFileSystemFileWriter_Write_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new NativeFileSystemFileWriter_Write_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.result = decoder.decodeStructPointer(native_file_system_error$.NativeFileSystemError); |
| val.bytesWritten = decoder.decodeStruct(codec.Uint64); |
| return val; |
| }; |
| |
| NativeFileSystemFileWriter_Write_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(NativeFileSystemFileWriter_Write_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(native_file_system_error$.NativeFileSystemError, val.result); |
| encoder.encodeStruct(codec.Uint64, val.bytesWritten); |
| }; |
| function NativeFileSystemFileWriter_WriteStream_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| NativeFileSystemFileWriter_WriteStream_Params.prototype.initDefaults_ = function() { |
| this.offset = 0; |
| this.stream = null; |
| }; |
| NativeFileSystemFileWriter_WriteStream_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| NativeFileSystemFileWriter_WriteStream_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 24} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| |
| // validate NativeFileSystemFileWriter_WriteStream_Params.stream |
| err = messageValidator.validateHandle(offset + codec.kStructHeaderSize + 8, false) |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| NativeFileSystemFileWriter_WriteStream_Params.encodedSize = codec.kStructHeaderSize + 16; |
| |
| NativeFileSystemFileWriter_WriteStream_Params.decode = function(decoder) { |
| var packed; |
| var val = new NativeFileSystemFileWriter_WriteStream_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.offset = decoder.decodeStruct(codec.Uint64); |
| val.stream = decoder.decodeStruct(codec.Handle); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| decoder.skip(1); |
| return val; |
| }; |
| |
| NativeFileSystemFileWriter_WriteStream_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(NativeFileSystemFileWriter_WriteStream_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.Uint64, val.offset); |
| encoder.encodeStruct(codec.Handle, val.stream); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| encoder.skip(1); |
| }; |
| function NativeFileSystemFileWriter_WriteStream_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| NativeFileSystemFileWriter_WriteStream_ResponseParams.prototype.initDefaults_ = function() { |
| this.result = null; |
| this.bytesWritten = 0; |
| }; |
| NativeFileSystemFileWriter_WriteStream_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| NativeFileSystemFileWriter_WriteStream_ResponseParams.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 24} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| // validate NativeFileSystemFileWriter_WriteStream_ResponseParams.result |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, native_file_system_error$.NativeFileSystemError, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| |
| return validator.validationError.NONE; |
| }; |
| |
| NativeFileSystemFileWriter_WriteStream_ResponseParams.encodedSize = codec.kStructHeaderSize + 16; |
| |
| NativeFileSystemFileWriter_WriteStream_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new NativeFileSystemFileWriter_WriteStream_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.result = decoder.decodeStructPointer(native_file_system_error$.NativeFileSystemError); |
| val.bytesWritten = decoder.decodeStruct(codec.Uint64); |
| return val; |
| }; |
| |
| NativeFileSystemFileWriter_WriteStream_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(NativeFileSystemFileWriter_WriteStream_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(native_file_system_error$.NativeFileSystemError, val.result); |
| encoder.encodeStruct(codec.Uint64, val.bytesWritten); |
| }; |
| function NativeFileSystemFileWriter_Truncate_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| NativeFileSystemFileWriter_Truncate_Params.prototype.initDefaults_ = function() { |
| this.length = 0; |
| }; |
| NativeFileSystemFileWriter_Truncate_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| NativeFileSystemFileWriter_Truncate_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; |
| }; |
| |
| NativeFileSystemFileWriter_Truncate_Params.encodedSize = codec.kStructHeaderSize + 8; |
| |
| NativeFileSystemFileWriter_Truncate_Params.decode = function(decoder) { |
| var packed; |
| var val = new NativeFileSystemFileWriter_Truncate_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.length = decoder.decodeStruct(codec.Uint64); |
| return val; |
| }; |
| |
| NativeFileSystemFileWriter_Truncate_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(NativeFileSystemFileWriter_Truncate_Params.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStruct(codec.Uint64, val.length); |
| }; |
| function NativeFileSystemFileWriter_Truncate_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| NativeFileSystemFileWriter_Truncate_ResponseParams.prototype.initDefaults_ = function() { |
| this.result = null; |
| }; |
| NativeFileSystemFileWriter_Truncate_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| NativeFileSystemFileWriter_Truncate_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 NativeFileSystemFileWriter_Truncate_ResponseParams.result |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, native_file_system_error$.NativeFileSystemError, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| NativeFileSystemFileWriter_Truncate_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| NativeFileSystemFileWriter_Truncate_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new NativeFileSystemFileWriter_Truncate_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.result = decoder.decodeStructPointer(native_file_system_error$.NativeFileSystemError); |
| return val; |
| }; |
| |
| NativeFileSystemFileWriter_Truncate_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(NativeFileSystemFileWriter_Truncate_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(native_file_system_error$.NativeFileSystemError, val.result); |
| }; |
| function NativeFileSystemFileWriter_Close_Params(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| NativeFileSystemFileWriter_Close_Params.prototype.initDefaults_ = function() { |
| }; |
| NativeFileSystemFileWriter_Close_Params.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| NativeFileSystemFileWriter_Close_Params.validate = function(messageValidator, offset) { |
| var err; |
| err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| var kVersionSizes = [ |
| {version: 0, numBytes: 8} |
| ]; |
| err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| NativeFileSystemFileWriter_Close_Params.encodedSize = codec.kStructHeaderSize + 0; |
| |
| NativeFileSystemFileWriter_Close_Params.decode = function(decoder) { |
| var packed; |
| var val = new NativeFileSystemFileWriter_Close_Params(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| return val; |
| }; |
| |
| NativeFileSystemFileWriter_Close_Params.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(NativeFileSystemFileWriter_Close_Params.encodedSize); |
| encoder.writeUint32(0); |
| }; |
| function NativeFileSystemFileWriter_Close_ResponseParams(values) { |
| this.initDefaults_(); |
| this.initFields_(values); |
| } |
| |
| |
| NativeFileSystemFileWriter_Close_ResponseParams.prototype.initDefaults_ = function() { |
| this.result = null; |
| }; |
| NativeFileSystemFileWriter_Close_ResponseParams.prototype.initFields_ = function(fields) { |
| for(var field in fields) { |
| if (this.hasOwnProperty(field)) |
| this[field] = fields[field]; |
| } |
| }; |
| |
| NativeFileSystemFileWriter_Close_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 NativeFileSystemFileWriter_Close_ResponseParams.result |
| err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, native_file_system_error$.NativeFileSystemError, false); |
| if (err !== validator.validationError.NONE) |
| return err; |
| |
| return validator.validationError.NONE; |
| }; |
| |
| NativeFileSystemFileWriter_Close_ResponseParams.encodedSize = codec.kStructHeaderSize + 8; |
| |
| NativeFileSystemFileWriter_Close_ResponseParams.decode = function(decoder) { |
| var packed; |
| var val = new NativeFileSystemFileWriter_Close_ResponseParams(); |
| var numberOfBytes = decoder.readUint32(); |
| var version = decoder.readUint32(); |
| val.result = decoder.decodeStructPointer(native_file_system_error$.NativeFileSystemError); |
| return val; |
| }; |
| |
| NativeFileSystemFileWriter_Close_ResponseParams.encode = function(encoder, val) { |
| var packed; |
| encoder.writeUint32(NativeFileSystemFileWriter_Close_ResponseParams.encodedSize); |
| encoder.writeUint32(0); |
| encoder.encodeStructPointer(native_file_system_error$.NativeFileSystemError, val.result); |
| }; |
| var kNativeFileSystemFileWriter_Write_Name = 0; |
| var kNativeFileSystemFileWriter_WriteStream_Name = 1; |
| var kNativeFileSystemFileWriter_Truncate_Name = 2; |
| var kNativeFileSystemFileWriter_Close_Name = 3; |
| |
| function NativeFileSystemFileWriterPtr(handleOrPtrInfo) { |
| this.ptr = new bindings.InterfacePtrController(NativeFileSystemFileWriter, |
| handleOrPtrInfo); |
| } |
| |
| function NativeFileSystemFileWriterAssociatedPtr(associatedInterfacePtrInfo) { |
| this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| NativeFileSystemFileWriter, associatedInterfacePtrInfo); |
| } |
| |
| NativeFileSystemFileWriterAssociatedPtr.prototype = |
| Object.create(NativeFileSystemFileWriterPtr.prototype); |
| NativeFileSystemFileWriterAssociatedPtr.prototype.constructor = |
| NativeFileSystemFileWriterAssociatedPtr; |
| |
| function NativeFileSystemFileWriterProxy(receiver) { |
| this.receiver_ = receiver; |
| } |
| NativeFileSystemFileWriterPtr.prototype.write = function() { |
| return NativeFileSystemFileWriterProxy.prototype.write |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| NativeFileSystemFileWriterProxy.prototype.write = function(offset, data) { |
| var params_ = new NativeFileSystemFileWriter_Write_Params(); |
| params_.offset = offset; |
| params_.data = data; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kNativeFileSystemFileWriter_Write_Name, |
| codec.align(NativeFileSystemFileWriter_Write_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(NativeFileSystemFileWriter_Write_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(NativeFileSystemFileWriter_Write_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| NativeFileSystemFileWriterPtr.prototype.writeStream = function() { |
| return NativeFileSystemFileWriterProxy.prototype.writeStream |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| NativeFileSystemFileWriterProxy.prototype.writeStream = function(offset, stream) { |
| var params_ = new NativeFileSystemFileWriter_WriteStream_Params(); |
| params_.offset = offset; |
| params_.stream = stream; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kNativeFileSystemFileWriter_WriteStream_Name, |
| codec.align(NativeFileSystemFileWriter_WriteStream_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(NativeFileSystemFileWriter_WriteStream_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(NativeFileSystemFileWriter_WriteStream_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| NativeFileSystemFileWriterPtr.prototype.truncate = function() { |
| return NativeFileSystemFileWriterProxy.prototype.truncate |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| NativeFileSystemFileWriterProxy.prototype.truncate = function(length) { |
| var params_ = new NativeFileSystemFileWriter_Truncate_Params(); |
| params_.length = length; |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kNativeFileSystemFileWriter_Truncate_Name, |
| codec.align(NativeFileSystemFileWriter_Truncate_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(NativeFileSystemFileWriter_Truncate_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(NativeFileSystemFileWriter_Truncate_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| NativeFileSystemFileWriterPtr.prototype.close = function() { |
| return NativeFileSystemFileWriterProxy.prototype.close |
| .apply(this.ptr.getProxy(), arguments); |
| }; |
| |
| NativeFileSystemFileWriterProxy.prototype.close = function() { |
| var params_ = new NativeFileSystemFileWriter_Close_Params(); |
| return new Promise(function(resolve, reject) { |
| var builder = new codec.MessageV1Builder( |
| kNativeFileSystemFileWriter_Close_Name, |
| codec.align(NativeFileSystemFileWriter_Close_Params.encodedSize), |
| codec.kMessageExpectsResponse, 0); |
| builder.encodeStruct(NativeFileSystemFileWriter_Close_Params, params_); |
| var message = builder.finish(); |
| this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| var reader = new codec.MessageReader(message); |
| var responseParams = |
| reader.decodeStruct(NativeFileSystemFileWriter_Close_ResponseParams); |
| resolve(responseParams); |
| }).catch(function(result) { |
| reject(Error("Connection error: " + result)); |
| }); |
| }.bind(this)); |
| }; |
| |
| function NativeFileSystemFileWriterStub(delegate) { |
| this.delegate_ = delegate; |
| } |
| NativeFileSystemFileWriterStub.prototype.write = function(offset, data) { |
| return this.delegate_ && this.delegate_.write && this.delegate_.write(offset, data); |
| } |
| NativeFileSystemFileWriterStub.prototype.writeStream = function(offset, stream) { |
| return this.delegate_ && this.delegate_.writeStream && this.delegate_.writeStream(offset, stream); |
| } |
| NativeFileSystemFileWriterStub.prototype.truncate = function(length) { |
| return this.delegate_ && this.delegate_.truncate && this.delegate_.truncate(length); |
| } |
| NativeFileSystemFileWriterStub.prototype.close = function() { |
| return this.delegate_ && this.delegate_.close && this.delegate_.close(); |
| } |
| |
| NativeFileSystemFileWriterStub.prototype.accept = function(message) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| default: |
| return false; |
| } |
| }; |
| |
| NativeFileSystemFileWriterStub.prototype.acceptWithResponder = |
| function(message, responder) { |
| var reader = new codec.MessageReader(message); |
| switch (reader.messageName) { |
| case kNativeFileSystemFileWriter_Write_Name: |
| var params = reader.decodeStruct(NativeFileSystemFileWriter_Write_Params); |
| this.write(params.offset, params.data).then(function(response) { |
| var responseParams = |
| new NativeFileSystemFileWriter_Write_ResponseParams(); |
| responseParams.result = response.result; |
| responseParams.bytesWritten = response.bytesWritten; |
| var builder = new codec.MessageV1Builder( |
| kNativeFileSystemFileWriter_Write_Name, |
| codec.align(NativeFileSystemFileWriter_Write_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(NativeFileSystemFileWriter_Write_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kNativeFileSystemFileWriter_WriteStream_Name: |
| var params = reader.decodeStruct(NativeFileSystemFileWriter_WriteStream_Params); |
| this.writeStream(params.offset, params.stream).then(function(response) { |
| var responseParams = |
| new NativeFileSystemFileWriter_WriteStream_ResponseParams(); |
| responseParams.result = response.result; |
| responseParams.bytesWritten = response.bytesWritten; |
| var builder = new codec.MessageV1Builder( |
| kNativeFileSystemFileWriter_WriteStream_Name, |
| codec.align(NativeFileSystemFileWriter_WriteStream_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(NativeFileSystemFileWriter_WriteStream_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kNativeFileSystemFileWriter_Truncate_Name: |
| var params = reader.decodeStruct(NativeFileSystemFileWriter_Truncate_Params); |
| this.truncate(params.length).then(function(response) { |
| var responseParams = |
| new NativeFileSystemFileWriter_Truncate_ResponseParams(); |
| responseParams.result = response.result; |
| var builder = new codec.MessageV1Builder( |
| kNativeFileSystemFileWriter_Truncate_Name, |
| codec.align(NativeFileSystemFileWriter_Truncate_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(NativeFileSystemFileWriter_Truncate_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| case kNativeFileSystemFileWriter_Close_Name: |
| var params = reader.decodeStruct(NativeFileSystemFileWriter_Close_Params); |
| this.close().then(function(response) { |
| var responseParams = |
| new NativeFileSystemFileWriter_Close_ResponseParams(); |
| responseParams.result = response.result; |
| var builder = new codec.MessageV1Builder( |
| kNativeFileSystemFileWriter_Close_Name, |
| codec.align(NativeFileSystemFileWriter_Close_ResponseParams.encodedSize), |
| codec.kMessageIsResponse, reader.requestID); |
| builder.encodeStruct(NativeFileSystemFileWriter_Close_ResponseParams, |
| responseParams); |
| var message = builder.finish(); |
| responder.accept(message); |
| }); |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| function validateNativeFileSystemFileWriterRequest(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kNativeFileSystemFileWriter_Write_Name: |
| if (message.expectsResponse()) |
| paramsClass = NativeFileSystemFileWriter_Write_Params; |
| break; |
| case kNativeFileSystemFileWriter_WriteStream_Name: |
| if (message.expectsResponse()) |
| paramsClass = NativeFileSystemFileWriter_WriteStream_Params; |
| break; |
| case kNativeFileSystemFileWriter_Truncate_Name: |
| if (message.expectsResponse()) |
| paramsClass = NativeFileSystemFileWriter_Truncate_Params; |
| break; |
| case kNativeFileSystemFileWriter_Close_Name: |
| if (message.expectsResponse()) |
| paramsClass = NativeFileSystemFileWriter_Close_Params; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| function validateNativeFileSystemFileWriterResponse(messageValidator) { |
| var message = messageValidator.message; |
| var paramsClass = null; |
| switch (message.getName()) { |
| case kNativeFileSystemFileWriter_Write_Name: |
| if (message.isResponse()) |
| paramsClass = NativeFileSystemFileWriter_Write_ResponseParams; |
| break; |
| case kNativeFileSystemFileWriter_WriteStream_Name: |
| if (message.isResponse()) |
| paramsClass = NativeFileSystemFileWriter_WriteStream_ResponseParams; |
| break; |
| case kNativeFileSystemFileWriter_Truncate_Name: |
| if (message.isResponse()) |
| paramsClass = NativeFileSystemFileWriter_Truncate_ResponseParams; |
| break; |
| case kNativeFileSystemFileWriter_Close_Name: |
| if (message.isResponse()) |
| paramsClass = NativeFileSystemFileWriter_Close_ResponseParams; |
| break; |
| } |
| if (paramsClass === null) |
| return validator.validationError.NONE; |
| return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes()); |
| } |
| |
| var NativeFileSystemFileWriter = { |
| name: 'blink.mojom.NativeFileSystemFileWriter', |
| kVersion: 0, |
| ptrClass: NativeFileSystemFileWriterPtr, |
| proxyClass: NativeFileSystemFileWriterProxy, |
| stubClass: NativeFileSystemFileWriterStub, |
| validateRequest: validateNativeFileSystemFileWriterRequest, |
| validateResponse: validateNativeFileSystemFileWriterResponse, |
| }; |
| NativeFileSystemFileWriterStub.prototype.validator = validateNativeFileSystemFileWriterRequest; |
| NativeFileSystemFileWriterProxy.prototype.validator = validateNativeFileSystemFileWriterResponse; |
| exports.NativeFileSystemFileWriter = NativeFileSystemFileWriter; |
| exports.NativeFileSystemFileWriterPtr = NativeFileSystemFileWriterPtr; |
| exports.NativeFileSystemFileWriterAssociatedPtr = NativeFileSystemFileWriterAssociatedPtr; |
| })(); |