| Index: third_party/WebKit/LayoutTests/external/wpt/resources/chromium/mojo_bindings.js
|
| diff --git a/third_party/WebKit/LayoutTests/external/wpt/resources/chromium/mojo_bindings.js b/third_party/WebKit/LayoutTests/external/wpt/resources/chromium/mojo_bindings.js
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..af8d8592dc1a8910948cddf30809b0839066d36f
|
| --- /dev/null
|
| +++ b/third_party/WebKit/LayoutTests/external/wpt/resources/chromium/mojo_bindings.js
|
| @@ -0,0 +1,5110 @@
|
| +// Copyright 2017 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';
|
| +
|
| +if (mojo && mojo.internal) {
|
| + throw new Error('The Mojo bindings library has been initialized.');
|
| +}
|
| +
|
| +var mojo = mojo || {};
|
| +mojo.internal = {};
|
| +mojo.internal.global = this;
|
| +mojo.config = {
|
| + // Whether to automatically load mojom dependencies.
|
| + // For example, if foo.mojom imports bar.mojom, |autoLoadMojomDeps| set to
|
| + // true means that loading foo.mojom.js will insert a <script> tag to load
|
| + // bar.mojom.js, if it hasn't been loaded.
|
| + //
|
| + // The URL of bar.mojom.js is determined by the relative path of bar.mojom
|
| + // (relative to the position of foo.mojom at build time) and the URL of
|
| + // foo.mojom.js. For exmple, if at build time the two mojom files are
|
| + // located at:
|
| + // a/b/c/foo.mojom
|
| + // a/b/d/bar.mojom
|
| + // and the URL of foo.mojom.js is:
|
| + // http://example.org/scripts/b/c/foo.mojom.js
|
| + // then the URL of bar.mojom.js will be:
|
| + // http://example.org/scripts/b/d/bar.mojom.js
|
| + //
|
| + // If you would like bar.mojom.js to live at a different location, you need
|
| + // to turn off |autoLoadMojomDeps| before loading foo.mojom.js, and manually
|
| + // load bar.mojom.js yourself. Similarly, you need to turn off the option if
|
| + // you merge bar.mojom.js and foo.mojom.js into a single file.
|
| + //
|
| + // Performance tip: Avoid loading the same mojom.js file multiple times.
|
| + // Assume that |autoLoadMojomDeps| is set to true:
|
| + // <!-- No duplicate loading; recommended. -->
|
| + // <script src="http://example.org/scripts/b/c/foo.mojom.js"></script>
|
| + //
|
| + // <!-- No duplicate loading, although unnecessary. -->
|
| + // <script src="http://example.org/scripts/b/d/bar.mojom.js"></script>
|
| + // <script src="http://example.org/scripts/b/c/foo.mojom.js"></script>
|
| + //
|
| + // <!-- Load bar.mojom.js twice; should be avoided. -->
|
| + // <script src="http://example.org/scripts/b/c/foo.mojom.js"></script>
|
| + // <script src="http://example.org/scripts/b/d/bar.mojom.js"></script>
|
| + autoLoadMojomDeps: false
|
| +};
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + var LoadState = {
|
| + PENDING_LOAD: 1,
|
| + LOADED: 2
|
| + };
|
| +
|
| + var mojomRegistry = new Map();
|
| +
|
| + function exposeNamespace(namespace) {
|
| + var current = internal.global;
|
| + var parts = namespace.split('.');
|
| +
|
| + for (var part; parts.length && (part = parts.shift());) {
|
| + if (!current[part]) {
|
| + current[part] = {};
|
| + }
|
| + current = current[part];
|
| + }
|
| +
|
| + return current;
|
| + }
|
| +
|
| + function isMojomPendingLoad(id) {
|
| + return mojomRegistry.get(id) === LoadState.PENDING_LOAD;
|
| + }
|
| +
|
| + function isMojomLoaded(id) {
|
| + return mojomRegistry.get(id) === LoadState.LOADED;
|
| + }
|
| +
|
| + function markMojomPendingLoad(id) {
|
| + if (isMojomLoaded(id)) {
|
| + throw new Error('The following mojom file has been loaded: ' + id);
|
| + }
|
| +
|
| + mojomRegistry.set(id, LoadState.PENDING_LOAD);
|
| + }
|
| +
|
| + function markMojomLoaded(id) {
|
| + mojomRegistry.set(id, LoadState.LOADED);
|
| + }
|
| +
|
| + function loadMojomIfNecessary(id, url) {
|
| + if (mojomRegistry.has(id)) {
|
| + return;
|
| + }
|
| +
|
| + markMojomPendingLoad(id);
|
| + internal.global.document.write('<script type="text/javascript" src="' +
|
| + url + '"></script>');
|
| + }
|
| +
|
| + internal.exposeNamespace = exposeNamespace;
|
| + internal.isMojomPendingLoad = isMojomPendingLoad;
|
| + internal.isMojomLoaded = isMojomLoaded;
|
| + internal.markMojomPendingLoad = markMojomPendingLoad;
|
| + internal.markMojomLoaded = markMojomLoaded;
|
| + internal.loadMojomIfNecessary = loadMojomIfNecessary;
|
| +})();
|
| +// Copyright 2017 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + // ---------------------------------------------------------------------------
|
| +
|
| + // |output| could be an interface pointer, InterfacePtrInfo or
|
| + // AssociatedInterfacePtrInfo.
|
| + function makeRequest(output) {
|
| + if (output instanceof mojo.AssociatedInterfacePtrInfo) {
|
| + var {handle0, handle1} = internal.createPairPendingAssociation();
|
| + output.interfaceEndpointHandle = handle0;
|
| + output.version = 0;
|
| +
|
| + return new mojo.AssociatedInterfaceRequest(handle1);
|
| + }
|
| +
|
| + if (output instanceof mojo.InterfacePtrInfo) {
|
| + var pipe = Mojo.createMessagePipe();
|
| + output.handle = pipe.handle0;
|
| + output.version = 0;
|
| +
|
| + return new mojo.InterfaceRequest(pipe.handle1);
|
| + }
|
| +
|
| + var pipe = Mojo.createMessagePipe();
|
| + output.ptr.bind(new mojo.InterfacePtrInfo(pipe.handle0, 0));
|
| + return new mojo.InterfaceRequest(pipe.handle1);
|
| + }
|
| +
|
| + // ---------------------------------------------------------------------------
|
| +
|
| + // Operations used to setup/configure an interface pointer. Exposed as the
|
| + // |ptr| field of generated interface pointer classes.
|
| + // |ptrInfoOrHandle| could be omitted and passed into bind() later.
|
| + function InterfacePtrController(interfaceType, ptrInfoOrHandle) {
|
| + this.version = 0;
|
| +
|
| + this.interfaceType_ = interfaceType;
|
| + this.router_ = null;
|
| + this.interfaceEndpointClient_ = null;
|
| + this.proxy_ = null;
|
| +
|
| + // |router_| and |interfaceEndpointClient_| are lazily initialized.
|
| + // |handle_| is valid between bind() and
|
| + // the initialization of |router_| and |interfaceEndpointClient_|.
|
| + this.handle_ = null;
|
| +
|
| + if (ptrInfoOrHandle)
|
| + this.bind(ptrInfoOrHandle);
|
| + }
|
| +
|
| + InterfacePtrController.prototype.bind = function(ptrInfoOrHandle) {
|
| + this.reset();
|
| +
|
| + if (ptrInfoOrHandle instanceof mojo.InterfacePtrInfo) {
|
| + this.version = ptrInfoOrHandle.version;
|
| + this.handle_ = ptrInfoOrHandle.handle;
|
| + } else {
|
| + this.handle_ = ptrInfoOrHandle;
|
| + }
|
| + };
|
| +
|
| + InterfacePtrController.prototype.isBound = function() {
|
| + return this.interfaceEndpointClient_ !== null || this.handle_ !== null;
|
| + };
|
| +
|
| + // Although users could just discard the object, reset() closes the pipe
|
| + // immediately.
|
| + InterfacePtrController.prototype.reset = function() {
|
| + this.version = 0;
|
| + if (this.interfaceEndpointClient_) {
|
| + this.interfaceEndpointClient_.close();
|
| + this.interfaceEndpointClient_ = null;
|
| + }
|
| + if (this.router_) {
|
| + this.router_.close();
|
| + this.router_ = null;
|
| +
|
| + this.proxy_ = null;
|
| + }
|
| + if (this.handle_) {
|
| + this.handle_.close();
|
| + this.handle_ = null;
|
| + }
|
| + };
|
| +
|
| + InterfacePtrController.prototype.resetWithReason = function(reason) {
|
| + if (this.isBound()) {
|
| + this.configureProxyIfNecessary_();
|
| + this.interfaceEndpointClient_.close(reason);
|
| + this.interfaceEndpointClient_ = null;
|
| + }
|
| + this.reset();
|
| + };
|
| +
|
| + InterfacePtrController.prototype.setConnectionErrorHandler = function(
|
| + callback) {
|
| + if (!this.isBound())
|
| + throw new Error("Cannot set connection error handler if not bound.");
|
| +
|
| + this.configureProxyIfNecessary_();
|
| + this.interfaceEndpointClient_.setConnectionErrorHandler(callback);
|
| + };
|
| +
|
| + InterfacePtrController.prototype.passInterface = function() {
|
| + var result;
|
| + if (this.router_) {
|
| + // TODO(yzshen): Fix Router interface to support extracting handle.
|
| + result = new mojo.InterfacePtrInfo(
|
| + this.router_.connector_.handle_, this.version);
|
| + this.router_.connector_.handle_ = null;
|
| + } else {
|
| + // This also handles the case when this object is not bound.
|
| + result = new mojo.InterfacePtrInfo(this.handle_, this.version);
|
| + this.handle_ = null;
|
| + }
|
| +
|
| + this.reset();
|
| + return result;
|
| + };
|
| +
|
| + InterfacePtrController.prototype.getProxy = function() {
|
| + this.configureProxyIfNecessary_();
|
| + return this.proxy_;
|
| + };
|
| +
|
| + InterfacePtrController.prototype.configureProxyIfNecessary_ = function() {
|
| + if (!this.handle_)
|
| + return;
|
| +
|
| + this.router_ = new internal.Router(this.handle_, true);
|
| + this.handle_ = null;
|
| +
|
| + this.interfaceEndpointClient_ = new internal.InterfaceEndpointClient(
|
| + this.router_.createLocalEndpointHandle(internal.kMasterInterfaceId));
|
| +
|
| + this.interfaceEndpointClient_ .setPayloadValidators([
|
| + this.interfaceType_.validateResponse]);
|
| + this.proxy_ = new this.interfaceType_.proxyClass(
|
| + this.interfaceEndpointClient_);
|
| + };
|
| +
|
| + InterfacePtrController.prototype.queryVersion = function() {
|
| + function onQueryVersion(version) {
|
| + this.version = version;
|
| + return version;
|
| + }
|
| +
|
| + this.configureProxyIfNecessary_();
|
| + return this.interfaceEndpointClient_.queryVersion().then(
|
| + onQueryVersion.bind(this));
|
| + };
|
| +
|
| + InterfacePtrController.prototype.requireVersion = function(version) {
|
| + this.configureProxyIfNecessary_();
|
| +
|
| + if (this.version >= version) {
|
| + return;
|
| + }
|
| + this.version = version;
|
| + this.interfaceEndpointClient_.requireVersion(version);
|
| + };
|
| +
|
| + // ---------------------------------------------------------------------------
|
| +
|
| + // |request| could be omitted and passed into bind() later.
|
| + //
|
| + // Example:
|
| + //
|
| + // // FooImpl implements mojom.Foo.
|
| + // function FooImpl() { ... }
|
| + // FooImpl.prototype.fooMethod1 = function() { ... }
|
| + // FooImpl.prototype.fooMethod2 = function() { ... }
|
| + //
|
| + // var fooPtr = new mojom.FooPtr();
|
| + // var request = makeRequest(fooPtr);
|
| + // var binding = new Binding(mojom.Foo, new FooImpl(), request);
|
| + // fooPtr.fooMethod1();
|
| + function Binding(interfaceType, impl, requestOrHandle) {
|
| + this.interfaceType_ = interfaceType;
|
| + this.impl_ = impl;
|
| + this.router_ = null;
|
| + this.interfaceEndpointClient_ = null;
|
| + this.stub_ = null;
|
| +
|
| + if (requestOrHandle)
|
| + this.bind(requestOrHandle);
|
| + }
|
| +
|
| + Binding.prototype.isBound = function() {
|
| + return this.router_ !== null;
|
| + };
|
| +
|
| + Binding.prototype.createInterfacePtrAndBind = function() {
|
| + var ptr = new this.interfaceType_.ptrClass();
|
| + // TODO(yzshen): Set the version of the interface pointer.
|
| + this.bind(makeRequest(ptr));
|
| + return ptr;
|
| + };
|
| +
|
| + Binding.prototype.bind = function(requestOrHandle) {
|
| + this.close();
|
| +
|
| + var handle = requestOrHandle instanceof mojo.InterfaceRequest ?
|
| + requestOrHandle.handle : requestOrHandle;
|
| + if (!(handle instanceof MojoHandle))
|
| + return;
|
| +
|
| + this.router_ = new internal.Router(handle);
|
| +
|
| + this.stub_ = new this.interfaceType_.stubClass(this.impl_);
|
| + this.interfaceEndpointClient_ = new internal.InterfaceEndpointClient(
|
| + this.router_.createLocalEndpointHandle(internal.kMasterInterfaceId),
|
| + this.stub_, this.interfaceType_.kVersion);
|
| +
|
| + this.interfaceEndpointClient_ .setPayloadValidators([
|
| + this.interfaceType_.validateRequest]);
|
| + };
|
| +
|
| + Binding.prototype.close = function() {
|
| + if (!this.isBound())
|
| + return;
|
| +
|
| + if (this.interfaceEndpointClient_) {
|
| + this.interfaceEndpointClient_.close();
|
| + this.interfaceEndpointClient_ = null;
|
| + }
|
| +
|
| + this.router_.close();
|
| + this.router_ = null;
|
| + this.stub_ = null;
|
| + };
|
| +
|
| + Binding.prototype.closeWithReason = function(reason) {
|
| + if (this.interfaceEndpointClient_) {
|
| + this.interfaceEndpointClient_.close(reason);
|
| + this.interfaceEndpointClient_ = null;
|
| + }
|
| + this.close();
|
| + };
|
| +
|
| + Binding.prototype.setConnectionErrorHandler = function(callback) {
|
| + if (!this.isBound()) {
|
| + throw new Error("Cannot set connection error handler if not bound.");
|
| + }
|
| + this.interfaceEndpointClient_.setConnectionErrorHandler(callback);
|
| + };
|
| +
|
| + Binding.prototype.unbind = function() {
|
| + if (!this.isBound())
|
| + return new mojo.InterfaceRequest(null);
|
| +
|
| + var result = new mojo.InterfaceRequest(this.router_.connector_.handle_);
|
| + this.router_.connector_.handle_ = null;
|
| + this.close();
|
| + return result;
|
| + };
|
| +
|
| + // ---------------------------------------------------------------------------
|
| +
|
| + function BindingSetEntry(bindingSet, interfaceType, bindingType, impl,
|
| + requestOrHandle, bindingId) {
|
| + this.bindingSet_ = bindingSet;
|
| + this.bindingId_ = bindingId;
|
| + this.binding_ = new bindingType(interfaceType, impl,
|
| + requestOrHandle);
|
| +
|
| + this.binding_.setConnectionErrorHandler(function(reason) {
|
| + this.bindingSet_.onConnectionError(bindingId, reason);
|
| + }.bind(this));
|
| + }
|
| +
|
| + BindingSetEntry.prototype.close = function() {
|
| + this.binding_.close();
|
| + };
|
| +
|
| + function BindingSet(interfaceType) {
|
| + this.interfaceType_ = interfaceType;
|
| + this.nextBindingId_ = 0;
|
| + this.bindings_ = new Map();
|
| + this.errorHandler_ = null;
|
| + this.bindingType_ = Binding;
|
| + }
|
| +
|
| + BindingSet.prototype.isEmpty = function() {
|
| + return this.bindings_.size == 0;
|
| + };
|
| +
|
| + BindingSet.prototype.addBinding = function(impl, requestOrHandle) {
|
| + this.bindings_.set(
|
| + this.nextBindingId_,
|
| + new BindingSetEntry(this, this.interfaceType_, this.bindingType_, impl,
|
| + requestOrHandle, this.nextBindingId_));
|
| + ++this.nextBindingId_;
|
| + };
|
| +
|
| + BindingSet.prototype.closeAllBindings = function() {
|
| + for (var entry of this.bindings_.values())
|
| + entry.close();
|
| + this.bindings_.clear();
|
| + };
|
| +
|
| + BindingSet.prototype.setConnectionErrorHandler = function(callback) {
|
| + this.errorHandler_ = callback;
|
| + };
|
| +
|
| + BindingSet.prototype.onConnectionError = function(bindingId, reason) {
|
| + this.bindings_.delete(bindingId);
|
| +
|
| + if (this.errorHandler_)
|
| + this.errorHandler_(reason);
|
| + };
|
| +
|
| + // ---------------------------------------------------------------------------
|
| +
|
| + // Operations used to setup/configure an associated interface pointer.
|
| + // Exposed as |ptr| field of generated associated interface pointer classes.
|
| + // |associatedPtrInfo| could be omitted and passed into bind() later.
|
| + //
|
| + // Example:
|
| + // // IntegerSenderImpl implements mojom.IntegerSender
|
| + // function IntegerSenderImpl() { ... }
|
| + // IntegerSenderImpl.prototype.echo = function() { ... }
|
| + //
|
| + // // IntegerSenderConnectionImpl implements mojom.IntegerSenderConnection
|
| + // function IntegerSenderConnectionImpl() {
|
| + // this.senderBinding_ = null;
|
| + // }
|
| + // IntegerSenderConnectionImpl.prototype.getSender = function(
|
| + // associatedRequest) {
|
| + // this.senderBinding_ = new AssociatedBinding(mojom.IntegerSender,
|
| + // new IntegerSenderImpl(),
|
| + // associatedRequest);
|
| + // }
|
| + //
|
| + // var integerSenderConnection = new mojom.IntegerSenderConnectionPtr();
|
| + // var integerSenderConnectionBinding = new Binding(
|
| + // mojom.IntegerSenderConnection,
|
| + // new IntegerSenderConnectionImpl(),
|
| + // mojo.makeRequest(integerSenderConnection));
|
| + //
|
| + // // A locally-created associated interface pointer can only be used to
|
| + // // make calls when the corresponding associated request is sent over
|
| + // // another interface (either the master interface or another
|
| + // // associated interface).
|
| + // var associatedInterfacePtrInfo = new AssociatedInterfacePtrInfo();
|
| + // var associatedRequest = makeRequest(interfacePtrInfo);
|
| + //
|
| + // integerSenderConnection.getSender(associatedRequest);
|
| + //
|
| + // // Create an associated interface and bind the associated handle.
|
| + // var integerSender = new mojom.AssociatedIntegerSenderPtr();
|
| + // integerSender.ptr.bind(associatedInterfacePtrInfo);
|
| + // integerSender.echo();
|
| +
|
| + function AssociatedInterfacePtrController(interfaceType, associatedPtrInfo) {
|
| + this.version = 0;
|
| +
|
| + this.interfaceType_ = interfaceType;
|
| + this.interfaceEndpointClient_ = null;
|
| + this.proxy_ = null;
|
| +
|
| + if (associatedPtrInfo) {
|
| + this.bind(associatedPtrInfo);
|
| + }
|
| + }
|
| +
|
| + AssociatedInterfacePtrController.prototype.bind = function(
|
| + associatedPtrInfo) {
|
| + this.reset();
|
| + this.version = associatedPtrInfo.version;
|
| +
|
| + this.interfaceEndpointClient_ = new internal.InterfaceEndpointClient(
|
| + associatedPtrInfo.interfaceEndpointHandle);
|
| +
|
| + this.interfaceEndpointClient_ .setPayloadValidators([
|
| + this.interfaceType_.validateResponse]);
|
| + this.proxy_ = new this.interfaceType_.proxyClass(
|
| + this.interfaceEndpointClient_);
|
| + };
|
| +
|
| + AssociatedInterfacePtrController.prototype.isBound = function() {
|
| + return this.interfaceEndpointClient_ !== null;
|
| + };
|
| +
|
| + AssociatedInterfacePtrController.prototype.reset = function() {
|
| + this.version = 0;
|
| + if (this.interfaceEndpointClient_) {
|
| + this.interfaceEndpointClient_.close();
|
| + this.interfaceEndpointClient_ = null;
|
| + }
|
| + if (this.proxy_) {
|
| + this.proxy_ = null;
|
| + }
|
| + };
|
| +
|
| + AssociatedInterfacePtrController.prototype.resetWithReason = function(
|
| + reason) {
|
| + if (this.isBound()) {
|
| + this.interfaceEndpointClient_.close(reason);
|
| + this.interfaceEndpointClient_ = null;
|
| + }
|
| + this.reset();
|
| + };
|
| +
|
| + // Indicates whether an error has been encountered. If true, method calls
|
| + // on this interface will be dropped (and may already have been dropped).
|
| + AssociatedInterfacePtrController.prototype.getEncounteredError = function() {
|
| + return this.interfaceEndpointClient_ ?
|
| + this.interfaceEndpointClient_.getEncounteredError() : false;
|
| + };
|
| +
|
| + AssociatedInterfacePtrController.prototype.setConnectionErrorHandler =
|
| + function(callback) {
|
| + if (!this.isBound()) {
|
| + throw new Error("Cannot set connection error handler if not bound.");
|
| + }
|
| +
|
| + this.interfaceEndpointClient_.setConnectionErrorHandler(callback);
|
| + };
|
| +
|
| + AssociatedInterfacePtrController.prototype.passInterface = function() {
|
| + if (!this.isBound()) {
|
| + return new mojo.AssociatedInterfacePtrInfo(null);
|
| + }
|
| +
|
| + var result = new mojo.AssociatedInterfacePtrInfo(
|
| + this.interfaceEndpointClient_.passHandle(), this.version);
|
| + this.reset();
|
| + return result;
|
| + };
|
| +
|
| + AssociatedInterfacePtrController.prototype.getProxy = function() {
|
| + return this.proxy_;
|
| + };
|
| +
|
| + AssociatedInterfacePtrController.prototype.queryVersion = function() {
|
| + function onQueryVersion(version) {
|
| + this.version = version;
|
| + return version;
|
| + }
|
| +
|
| + return this.interfaceEndpointClient_.queryVersion().then(
|
| + onQueryVersion.bind(this));
|
| + };
|
| +
|
| + AssociatedInterfacePtrController.prototype.requireVersion = function(
|
| + version) {
|
| + if (this.version >= version) {
|
| + return;
|
| + }
|
| + this.version = version;
|
| + this.interfaceEndpointClient_.requireVersion(version);
|
| + };
|
| +
|
| + // ---------------------------------------------------------------------------
|
| +
|
| + // |associatedInterfaceRequest| could be omitted and passed into bind()
|
| + // later.
|
| + function AssociatedBinding(interfaceType, impl, associatedInterfaceRequest) {
|
| + this.interfaceType_ = interfaceType;
|
| + this.impl_ = impl;
|
| + this.interfaceEndpointClient_ = null;
|
| + this.stub_ = null;
|
| +
|
| + if (associatedInterfaceRequest) {
|
| + this.bind(associatedInterfaceRequest);
|
| + }
|
| + }
|
| +
|
| + AssociatedBinding.prototype.isBound = function() {
|
| + return this.interfaceEndpointClient_ !== null;
|
| + };
|
| +
|
| + AssociatedBinding.prototype.bind = function(associatedInterfaceRequest) {
|
| + this.close();
|
| +
|
| + this.stub_ = new this.interfaceType_.stubClass(this.impl_);
|
| + this.interfaceEndpointClient_ = new internal.InterfaceEndpointClient(
|
| + associatedInterfaceRequest.interfaceEndpointHandle, this.stub_,
|
| + this.interfaceType_.kVersion);
|
| +
|
| + this.interfaceEndpointClient_ .setPayloadValidators([
|
| + this.interfaceType_.validateRequest]);
|
| + };
|
| +
|
| +
|
| + AssociatedBinding.prototype.close = function() {
|
| + if (!this.isBound()) {
|
| + return;
|
| + }
|
| +
|
| + if (this.interfaceEndpointClient_) {
|
| + this.interfaceEndpointClient_.close();
|
| + this.interfaceEndpointClient_ = null;
|
| + }
|
| +
|
| + this.stub_ = null;
|
| + };
|
| +
|
| + AssociatedBinding.prototype.closeWithReason = function(reason) {
|
| + if (this.interfaceEndpointClient_) {
|
| + this.interfaceEndpointClient_.close(reason);
|
| + this.interfaceEndpointClient_ = null;
|
| + }
|
| + this.close();
|
| + };
|
| +
|
| + AssociatedBinding.prototype.setConnectionErrorHandler = function(callback) {
|
| + if (!this.isBound()) {
|
| + throw new Error("Cannot set connection error handler if not bound.");
|
| + }
|
| + this.interfaceEndpointClient_.setConnectionErrorHandler(callback);
|
| + };
|
| +
|
| + AssociatedBinding.prototype.unbind = function() {
|
| + if (!this.isBound()) {
|
| + return new mojo.AssociatedInterfaceRequest(null);
|
| + }
|
| +
|
| + var result = new mojo.AssociatedInterfaceRequest(
|
| + this.interfaceEndpointClient_.passHandle());
|
| + this.close();
|
| + return result;
|
| + };
|
| +
|
| + // ---------------------------------------------------------------------------
|
| +
|
| + function AssociatedBindingSet(interfaceType) {
|
| + mojo.BindingSet.call(this, interfaceType);
|
| + this.bindingType_ = AssociatedBinding;
|
| + }
|
| +
|
| + AssociatedBindingSet.prototype = Object.create(BindingSet.prototype);
|
| + AssociatedBindingSet.prototype.constructor = AssociatedBindingSet;
|
| +
|
| + mojo.makeRequest = makeRequest;
|
| + mojo.AssociatedInterfacePtrController = AssociatedInterfacePtrController;
|
| + mojo.AssociatedBinding = AssociatedBinding;
|
| + mojo.AssociatedBindingSet = AssociatedBindingSet;
|
| + mojo.Binding = Binding;
|
| + mojo.BindingSet = BindingSet;
|
| + mojo.InterfacePtrController = InterfacePtrController;
|
| +})();
|
| +// 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + var kHostIsLittleEndian = (function () {
|
| + var endianArrayBuffer = new ArrayBuffer(2);
|
| + var endianUint8Array = new Uint8Array(endianArrayBuffer);
|
| + var endianUint16Array = new Uint16Array(endianArrayBuffer);
|
| + endianUint16Array[0] = 1;
|
| + return endianUint8Array[0] == 1;
|
| + })();
|
| +
|
| + var kHighWordMultiplier = 0x100000000;
|
| +
|
| + function Buffer(sizeOrArrayBuffer) {
|
| + if (sizeOrArrayBuffer instanceof ArrayBuffer)
|
| + this.arrayBuffer = sizeOrArrayBuffer;
|
| + else
|
| + this.arrayBuffer = new ArrayBuffer(sizeOrArrayBuffer);
|
| +
|
| + this.dataView = new DataView(this.arrayBuffer);
|
| + this.next = 0;
|
| + }
|
| +
|
| + Object.defineProperty(Buffer.prototype, "byteLength", {
|
| + get: function() { return this.arrayBuffer.byteLength; }
|
| + });
|
| +
|
| + Buffer.prototype.alloc = function(size) {
|
| + var pointer = this.next;
|
| + this.next += size;
|
| + if (this.next > this.byteLength) {
|
| + var newSize = (1.5 * (this.byteLength + size)) | 0;
|
| + this.grow(newSize);
|
| + }
|
| + return pointer;
|
| + };
|
| +
|
| + function copyArrayBuffer(dstArrayBuffer, srcArrayBuffer) {
|
| + (new Uint8Array(dstArrayBuffer)).set(new Uint8Array(srcArrayBuffer));
|
| + }
|
| +
|
| + Buffer.prototype.grow = function(size) {
|
| + var newArrayBuffer = new ArrayBuffer(size);
|
| + copyArrayBuffer(newArrayBuffer, this.arrayBuffer);
|
| + this.arrayBuffer = newArrayBuffer;
|
| + this.dataView = new DataView(this.arrayBuffer);
|
| + };
|
| +
|
| + Buffer.prototype.trim = function() {
|
| + this.arrayBuffer = this.arrayBuffer.slice(0, this.next);
|
| + this.dataView = new DataView(this.arrayBuffer);
|
| + };
|
| +
|
| + Buffer.prototype.getUint8 = function(offset) {
|
| + return this.dataView.getUint8(offset);
|
| + }
|
| + Buffer.prototype.getUint16 = function(offset) {
|
| + return this.dataView.getUint16(offset, kHostIsLittleEndian);
|
| + }
|
| + Buffer.prototype.getUint32 = function(offset) {
|
| + return this.dataView.getUint32(offset, kHostIsLittleEndian);
|
| + }
|
| + Buffer.prototype.getUint64 = function(offset) {
|
| + var lo, hi;
|
| + if (kHostIsLittleEndian) {
|
| + lo = this.dataView.getUint32(offset, kHostIsLittleEndian);
|
| + hi = this.dataView.getUint32(offset + 4, kHostIsLittleEndian);
|
| + } else {
|
| + hi = this.dataView.getUint32(offset, kHostIsLittleEndian);
|
| + lo = this.dataView.getUint32(offset + 4, kHostIsLittleEndian);
|
| + }
|
| + return lo + hi * kHighWordMultiplier;
|
| + }
|
| +
|
| + Buffer.prototype.getInt8 = function(offset) {
|
| + return this.dataView.getInt8(offset);
|
| + }
|
| + Buffer.prototype.getInt16 = function(offset) {
|
| + return this.dataView.getInt16(offset, kHostIsLittleEndian);
|
| + }
|
| + Buffer.prototype.getInt32 = function(offset) {
|
| + return this.dataView.getInt32(offset, kHostIsLittleEndian);
|
| + }
|
| + Buffer.prototype.getInt64 = function(offset) {
|
| + var lo, hi;
|
| + if (kHostIsLittleEndian) {
|
| + lo = this.dataView.getUint32(offset, kHostIsLittleEndian);
|
| + hi = this.dataView.getInt32(offset + 4, kHostIsLittleEndian);
|
| + } else {
|
| + hi = this.dataView.getInt32(offset, kHostIsLittleEndian);
|
| + lo = this.dataView.getUint32(offset + 4, kHostIsLittleEndian);
|
| + }
|
| + return lo + hi * kHighWordMultiplier;
|
| + }
|
| +
|
| + Buffer.prototype.getFloat32 = function(offset) {
|
| + return this.dataView.getFloat32(offset, kHostIsLittleEndian);
|
| + }
|
| + Buffer.prototype.getFloat64 = function(offset) {
|
| + return this.dataView.getFloat64(offset, kHostIsLittleEndian);
|
| + }
|
| +
|
| + Buffer.prototype.setUint8 = function(offset, value) {
|
| + this.dataView.setUint8(offset, value);
|
| + }
|
| + Buffer.prototype.setUint16 = function(offset, value) {
|
| + this.dataView.setUint16(offset, value, kHostIsLittleEndian);
|
| + }
|
| + Buffer.prototype.setUint32 = function(offset, value) {
|
| + this.dataView.setUint32(offset, value, kHostIsLittleEndian);
|
| + }
|
| + Buffer.prototype.setUint64 = function(offset, value) {
|
| + var hi = (value / kHighWordMultiplier) | 0;
|
| + if (kHostIsLittleEndian) {
|
| + this.dataView.setInt32(offset, value, kHostIsLittleEndian);
|
| + this.dataView.setInt32(offset + 4, hi, kHostIsLittleEndian);
|
| + } else {
|
| + this.dataView.setInt32(offset, hi, kHostIsLittleEndian);
|
| + this.dataView.setInt32(offset + 4, value, kHostIsLittleEndian);
|
| + }
|
| + }
|
| +
|
| + Buffer.prototype.setInt8 = function(offset, value) {
|
| + this.dataView.setInt8(offset, value);
|
| + }
|
| + Buffer.prototype.setInt16 = function(offset, value) {
|
| + this.dataView.setInt16(offset, value, kHostIsLittleEndian);
|
| + }
|
| + Buffer.prototype.setInt32 = function(offset, value) {
|
| + this.dataView.setInt32(offset, value, kHostIsLittleEndian);
|
| + }
|
| + Buffer.prototype.setInt64 = function(offset, value) {
|
| + var hi = Math.floor(value / kHighWordMultiplier);
|
| + if (kHostIsLittleEndian) {
|
| + this.dataView.setInt32(offset, value, kHostIsLittleEndian);
|
| + this.dataView.setInt32(offset + 4, hi, kHostIsLittleEndian);
|
| + } else {
|
| + this.dataView.setInt32(offset, hi, kHostIsLittleEndian);
|
| + this.dataView.setInt32(offset + 4, value, kHostIsLittleEndian);
|
| + }
|
| + }
|
| +
|
| + Buffer.prototype.setFloat32 = function(offset, value) {
|
| + this.dataView.setFloat32(offset, value, kHostIsLittleEndian);
|
| + }
|
| + Buffer.prototype.setFloat64 = function(offset, value) {
|
| + this.dataView.setFloat64(offset, value, kHostIsLittleEndian);
|
| + }
|
| +
|
| + internal.Buffer = Buffer;
|
| +})();
|
| +// 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + var kErrorUnsigned = "Passing negative value to unsigned";
|
| + var kErrorArray = "Passing non Array for array type";
|
| + var kErrorString = "Passing non String for string type";
|
| + var kErrorMap = "Passing non Map for map type";
|
| +
|
| + // Memory -------------------------------------------------------------------
|
| +
|
| + var kAlignment = 8;
|
| +
|
| + function align(size) {
|
| + return size + (kAlignment - (size % kAlignment)) % kAlignment;
|
| + }
|
| +
|
| + function isAligned(offset) {
|
| + return offset >= 0 && (offset % kAlignment) === 0;
|
| + }
|
| +
|
| + // Constants ----------------------------------------------------------------
|
| +
|
| + var kArrayHeaderSize = 8;
|
| + var kStructHeaderSize = 8;
|
| + var kMessageV0HeaderSize = 24;
|
| + var kMessageV1HeaderSize = 32;
|
| + var kMessageV2HeaderSize = 48;
|
| + var kMapStructPayloadSize = 16;
|
| +
|
| + var kStructHeaderNumBytesOffset = 0;
|
| + var kStructHeaderVersionOffset = 4;
|
| +
|
| + var kEncodedInvalidHandleValue = 0xFFFFFFFF;
|
| +
|
| + // Decoder ------------------------------------------------------------------
|
| +
|
| + function Decoder(buffer, handles, associatedEndpointHandles, base) {
|
| + this.buffer = buffer;
|
| + this.handles = handles;
|
| + this.associatedEndpointHandles = associatedEndpointHandles;
|
| + this.base = base;
|
| + this.next = base;
|
| + }
|
| +
|
| + Decoder.prototype.align = function() {
|
| + this.next = align(this.next);
|
| + };
|
| +
|
| + Decoder.prototype.skip = function(offset) {
|
| + this.next += offset;
|
| + };
|
| +
|
| + Decoder.prototype.readInt8 = function() {
|
| + var result = this.buffer.getInt8(this.next);
|
| + this.next += 1;
|
| + return result;
|
| + };
|
| +
|
| + Decoder.prototype.readUint8 = function() {
|
| + var result = this.buffer.getUint8(this.next);
|
| + this.next += 1;
|
| + return result;
|
| + };
|
| +
|
| + Decoder.prototype.readInt16 = function() {
|
| + var result = this.buffer.getInt16(this.next);
|
| + this.next += 2;
|
| + return result;
|
| + };
|
| +
|
| + Decoder.prototype.readUint16 = function() {
|
| + var result = this.buffer.getUint16(this.next);
|
| + this.next += 2;
|
| + return result;
|
| + };
|
| +
|
| + Decoder.prototype.readInt32 = function() {
|
| + var result = this.buffer.getInt32(this.next);
|
| + this.next += 4;
|
| + return result;
|
| + };
|
| +
|
| + Decoder.prototype.readUint32 = function() {
|
| + var result = this.buffer.getUint32(this.next);
|
| + this.next += 4;
|
| + return result;
|
| + };
|
| +
|
| + Decoder.prototype.readInt64 = function() {
|
| + var result = this.buffer.getInt64(this.next);
|
| + this.next += 8;
|
| + return result;
|
| + };
|
| +
|
| + Decoder.prototype.readUint64 = function() {
|
| + var result = this.buffer.getUint64(this.next);
|
| + this.next += 8;
|
| + return result;
|
| + };
|
| +
|
| + Decoder.prototype.readFloat = function() {
|
| + var result = this.buffer.getFloat32(this.next);
|
| + this.next += 4;
|
| + return result;
|
| + };
|
| +
|
| + Decoder.prototype.readDouble = function() {
|
| + var result = this.buffer.getFloat64(this.next);
|
| + this.next += 8;
|
| + return result;
|
| + };
|
| +
|
| + Decoder.prototype.decodePointer = function() {
|
| + // TODO(abarth): To correctly decode a pointer, we need to know the real
|
| + // base address of the array buffer.
|
| + var offsetPointer = this.next;
|
| + var offset = this.readUint64();
|
| + if (!offset)
|
| + return 0;
|
| + return offsetPointer + offset;
|
| + };
|
| +
|
| + Decoder.prototype.decodeAndCreateDecoder = function(pointer) {
|
| + return new Decoder(this.buffer, this.handles,
|
| + this.associatedEndpointHandles, pointer);
|
| + };
|
| +
|
| + Decoder.prototype.decodeHandle = function() {
|
| + return this.handles[this.readUint32()] || null;
|
| + };
|
| +
|
| + Decoder.prototype.decodeAssociatedEndpointHandle = function() {
|
| + return this.associatedEndpointHandles[this.readUint32()] || null;
|
| + };
|
| +
|
| + Decoder.prototype.decodeString = function() {
|
| + var numberOfBytes = this.readUint32();
|
| + var numberOfElements = this.readUint32();
|
| + var base = this.next;
|
| + this.next += numberOfElements;
|
| + return internal.decodeUtf8String(
|
| + new Uint8Array(this.buffer.arrayBuffer, base, numberOfElements));
|
| + };
|
| +
|
| + Decoder.prototype.decodeArray = function(cls) {
|
| + var numberOfBytes = this.readUint32();
|
| + var numberOfElements = this.readUint32();
|
| + var val = new Array(numberOfElements);
|
| + if (cls === PackedBool) {
|
| + var byte;
|
| + for (var i = 0; i < numberOfElements; ++i) {
|
| + if (i % 8 === 0)
|
| + byte = this.readUint8();
|
| + val[i] = (byte & (1 << i % 8)) ? true : false;
|
| + }
|
| + } else {
|
| + for (var i = 0; i < numberOfElements; ++i) {
|
| + val[i] = cls.decode(this);
|
| + }
|
| + }
|
| + return val;
|
| + };
|
| +
|
| + Decoder.prototype.decodeStruct = function(cls) {
|
| + return cls.decode(this);
|
| + };
|
| +
|
| + Decoder.prototype.decodeStructPointer = function(cls) {
|
| + var pointer = this.decodePointer();
|
| + if (!pointer) {
|
| + return null;
|
| + }
|
| + return cls.decode(this.decodeAndCreateDecoder(pointer));
|
| + };
|
| +
|
| + Decoder.prototype.decodeArrayPointer = function(cls) {
|
| + var pointer = this.decodePointer();
|
| + if (!pointer) {
|
| + return null;
|
| + }
|
| + return this.decodeAndCreateDecoder(pointer).decodeArray(cls);
|
| + };
|
| +
|
| + Decoder.prototype.decodeStringPointer = function() {
|
| + var pointer = this.decodePointer();
|
| + if (!pointer) {
|
| + return null;
|
| + }
|
| + return this.decodeAndCreateDecoder(pointer).decodeString();
|
| + };
|
| +
|
| + Decoder.prototype.decodeMap = function(keyClass, valueClass) {
|
| + this.skip(4); // numberOfBytes
|
| + this.skip(4); // version
|
| + var keys = this.decodeArrayPointer(keyClass);
|
| + var values = this.decodeArrayPointer(valueClass);
|
| + var val = new Map();
|
| + for (var i = 0; i < keys.length; i++)
|
| + val.set(keys[i], values[i]);
|
| + return val;
|
| + };
|
| +
|
| + Decoder.prototype.decodeMapPointer = function(keyClass, valueClass) {
|
| + var pointer = this.decodePointer();
|
| + if (!pointer) {
|
| + return null;
|
| + }
|
| + var decoder = this.decodeAndCreateDecoder(pointer);
|
| + return decoder.decodeMap(keyClass, valueClass);
|
| + };
|
| +
|
| + // Encoder ------------------------------------------------------------------
|
| +
|
| + function Encoder(buffer, handles, associatedEndpointHandles, base) {
|
| + this.buffer = buffer;
|
| + this.handles = handles;
|
| + this.associatedEndpointHandles = associatedEndpointHandles;
|
| + this.base = base;
|
| + this.next = base;
|
| + }
|
| +
|
| + Encoder.prototype.align = function() {
|
| + this.next = align(this.next);
|
| + };
|
| +
|
| + Encoder.prototype.skip = function(offset) {
|
| + this.next += offset;
|
| + };
|
| +
|
| + Encoder.prototype.writeInt8 = function(val) {
|
| + this.buffer.setInt8(this.next, val);
|
| + this.next += 1;
|
| + };
|
| +
|
| + Encoder.prototype.writeUint8 = function(val) {
|
| + if (val < 0) {
|
| + throw new Error(kErrorUnsigned);
|
| + }
|
| + this.buffer.setUint8(this.next, val);
|
| + this.next += 1;
|
| + };
|
| +
|
| + Encoder.prototype.writeInt16 = function(val) {
|
| + this.buffer.setInt16(this.next, val);
|
| + this.next += 2;
|
| + };
|
| +
|
| + Encoder.prototype.writeUint16 = function(val) {
|
| + if (val < 0) {
|
| + throw new Error(kErrorUnsigned);
|
| + }
|
| + this.buffer.setUint16(this.next, val);
|
| + this.next += 2;
|
| + };
|
| +
|
| + Encoder.prototype.writeInt32 = function(val) {
|
| + this.buffer.setInt32(this.next, val);
|
| + this.next += 4;
|
| + };
|
| +
|
| + Encoder.prototype.writeUint32 = function(val) {
|
| + if (val < 0) {
|
| + throw new Error(kErrorUnsigned);
|
| + }
|
| + this.buffer.setUint32(this.next, val);
|
| + this.next += 4;
|
| + };
|
| +
|
| + Encoder.prototype.writeInt64 = function(val) {
|
| + this.buffer.setInt64(this.next, val);
|
| + this.next += 8;
|
| + };
|
| +
|
| + Encoder.prototype.writeUint64 = function(val) {
|
| + if (val < 0) {
|
| + throw new Error(kErrorUnsigned);
|
| + }
|
| + this.buffer.setUint64(this.next, val);
|
| + this.next += 8;
|
| + };
|
| +
|
| + Encoder.prototype.writeFloat = function(val) {
|
| + this.buffer.setFloat32(this.next, val);
|
| + this.next += 4;
|
| + };
|
| +
|
| + Encoder.prototype.writeDouble = function(val) {
|
| + this.buffer.setFloat64(this.next, val);
|
| + this.next += 8;
|
| + };
|
| +
|
| + Encoder.prototype.encodePointer = function(pointer) {
|
| + if (!pointer)
|
| + return this.writeUint64(0);
|
| + // TODO(abarth): To correctly encode a pointer, we need to know the real
|
| + // base address of the array buffer.
|
| + var offset = pointer - this.next;
|
| + this.writeUint64(offset);
|
| + };
|
| +
|
| + Encoder.prototype.createAndEncodeEncoder = function(size) {
|
| + var pointer = this.buffer.alloc(align(size));
|
| + this.encodePointer(pointer);
|
| + return new Encoder(this.buffer, this.handles,
|
| + this.associatedEndpointHandles, pointer);
|
| + };
|
| +
|
| + Encoder.prototype.encodeHandle = function(handle) {
|
| + if (handle) {
|
| + this.handles.push(handle);
|
| + this.writeUint32(this.handles.length - 1);
|
| + } else {
|
| + this.writeUint32(kEncodedInvalidHandleValue);
|
| + }
|
| + };
|
| +
|
| + Encoder.prototype.encodeAssociatedEndpointHandle = function(endpointHandle) {
|
| + if (endpointHandle) {
|
| + this.associatedEndpointHandles.push(endpointHandle);
|
| + this.writeUint32(this.associatedEndpointHandles.length - 1);
|
| + } else {
|
| + this.writeUint32(kEncodedInvalidHandleValue);
|
| + }
|
| + };
|
| +
|
| + Encoder.prototype.encodeString = function(val) {
|
| + var base = this.next + kArrayHeaderSize;
|
| + var numberOfElements = internal.encodeUtf8String(
|
| + val, new Uint8Array(this.buffer.arrayBuffer, base));
|
| + var numberOfBytes = kArrayHeaderSize + numberOfElements;
|
| + this.writeUint32(numberOfBytes);
|
| + this.writeUint32(numberOfElements);
|
| + this.next += numberOfElements;
|
| + };
|
| +
|
| + Encoder.prototype.encodeArray =
|
| + function(cls, val, numberOfElements, encodedSize) {
|
| + if (numberOfElements === undefined)
|
| + numberOfElements = val.length;
|
| + if (encodedSize === undefined)
|
| + encodedSize = kArrayHeaderSize + cls.encodedSize * numberOfElements;
|
| +
|
| + this.writeUint32(encodedSize);
|
| + this.writeUint32(numberOfElements);
|
| +
|
| + if (cls === PackedBool) {
|
| + var byte = 0;
|
| + for (i = 0; i < numberOfElements; ++i) {
|
| + if (val[i])
|
| + byte |= (1 << i % 8);
|
| + if (i % 8 === 7 || i == numberOfElements - 1) {
|
| + Uint8.encode(this, byte);
|
| + byte = 0;
|
| + }
|
| + }
|
| + } else {
|
| + for (var i = 0; i < numberOfElements; ++i)
|
| + cls.encode(this, val[i]);
|
| + }
|
| + };
|
| +
|
| + Encoder.prototype.encodeStruct = function(cls, val) {
|
| + return cls.encode(this, val);
|
| + };
|
| +
|
| + Encoder.prototype.encodeStructPointer = function(cls, val) {
|
| + if (val == null) {
|
| + // Also handles undefined, since undefined == null.
|
| + this.encodePointer(val);
|
| + return;
|
| + }
|
| + var encoder = this.createAndEncodeEncoder(cls.encodedSize);
|
| + cls.encode(encoder, val);
|
| + };
|
| +
|
| + Encoder.prototype.encodeArrayPointer = function(cls, val) {
|
| + if (val == null) {
|
| + // Also handles undefined, since undefined == null.
|
| + this.encodePointer(val);
|
| + return;
|
| + }
|
| +
|
| + var numberOfElements = val.length;
|
| + if (!Number.isSafeInteger(numberOfElements) || numberOfElements < 0)
|
| + throw new Error(kErrorArray);
|
| +
|
| + var encodedSize = kArrayHeaderSize + ((cls === PackedBool) ?
|
| + Math.ceil(numberOfElements / 8) : cls.encodedSize * numberOfElements);
|
| + var encoder = this.createAndEncodeEncoder(encodedSize);
|
| + encoder.encodeArray(cls, val, numberOfElements, encodedSize);
|
| + };
|
| +
|
| + Encoder.prototype.encodeStringPointer = function(val) {
|
| + if (val == null) {
|
| + // Also handles undefined, since undefined == null.
|
| + this.encodePointer(val);
|
| + return;
|
| + }
|
| + // Only accepts string primivites, not String Objects like new String("foo")
|
| + if (typeof(val) !== "string") {
|
| + throw new Error(kErrorString);
|
| + }
|
| + var encodedSize = kArrayHeaderSize + internal.utf8Length(val);
|
| + var encoder = this.createAndEncodeEncoder(encodedSize);
|
| + encoder.encodeString(val);
|
| + };
|
| +
|
| + Encoder.prototype.encodeMap = function(keyClass, valueClass, val) {
|
| + var keys = new Array(val.size);
|
| + var values = new Array(val.size);
|
| + var i = 0;
|
| + val.forEach(function(value, key) {
|
| + values[i] = value;
|
| + keys[i++] = key;
|
| + });
|
| + this.writeUint32(kStructHeaderSize + kMapStructPayloadSize);
|
| + this.writeUint32(0); // version
|
| + this.encodeArrayPointer(keyClass, keys);
|
| + this.encodeArrayPointer(valueClass, values);
|
| + }
|
| +
|
| + Encoder.prototype.encodeMapPointer = function(keyClass, valueClass, val) {
|
| + if (val == null) {
|
| + // Also handles undefined, since undefined == null.
|
| + this.encodePointer(val);
|
| + return;
|
| + }
|
| + if (!(val instanceof Map)) {
|
| + throw new Error(kErrorMap);
|
| + }
|
| + var encodedSize = kStructHeaderSize + kMapStructPayloadSize;
|
| + var encoder = this.createAndEncodeEncoder(encodedSize);
|
| + encoder.encodeMap(keyClass, valueClass, val);
|
| + };
|
| +
|
| + // Message ------------------------------------------------------------------
|
| +
|
| + var kMessageInterfaceIdOffset = kStructHeaderSize;
|
| + var kMessageNameOffset = kMessageInterfaceIdOffset + 4;
|
| + var kMessageFlagsOffset = kMessageNameOffset + 4;
|
| + var kMessageRequestIDOffset = kMessageFlagsOffset + 8;
|
| + var kMessagePayloadInterfaceIdsPointerOffset = kMessageV2HeaderSize - 8;
|
| +
|
| + var kMessageExpectsResponse = 1 << 0;
|
| + var kMessageIsResponse = 1 << 1;
|
| +
|
| + function Message(buffer, handles, associatedEndpointHandles) {
|
| + if (associatedEndpointHandles === undefined) {
|
| + associatedEndpointHandles = [];
|
| + }
|
| +
|
| + this.buffer = buffer;
|
| + this.handles = handles;
|
| + this.associatedEndpointHandles = associatedEndpointHandles;
|
| + }
|
| +
|
| + Message.prototype.getHeaderNumBytes = function() {
|
| + return this.buffer.getUint32(kStructHeaderNumBytesOffset);
|
| + };
|
| +
|
| + Message.prototype.getHeaderVersion = function() {
|
| + return this.buffer.getUint32(kStructHeaderVersionOffset);
|
| + };
|
| +
|
| + Message.prototype.getName = function() {
|
| + return this.buffer.getUint32(kMessageNameOffset);
|
| + };
|
| +
|
| + Message.prototype.getFlags = function() {
|
| + return this.buffer.getUint32(kMessageFlagsOffset);
|
| + };
|
| +
|
| + Message.prototype.getInterfaceId = function() {
|
| + return this.buffer.getUint32(kMessageInterfaceIdOffset);
|
| + };
|
| +
|
| + Message.prototype.getPayloadInterfaceIds = function() {
|
| + if (this.getHeaderVersion() < 2) {
|
| + return null;
|
| + }
|
| +
|
| + var decoder = new Decoder(this.buffer, this.handles,
|
| + this.associatedEndpointHandles,
|
| + kMessagePayloadInterfaceIdsPointerOffset);
|
| + var payloadInterfaceIds = decoder.decodeArrayPointer(Uint32);
|
| + return payloadInterfaceIds;
|
| + };
|
| +
|
| + Message.prototype.isResponse = function() {
|
| + return (this.getFlags() & kMessageIsResponse) != 0;
|
| + };
|
| +
|
| + Message.prototype.expectsResponse = function() {
|
| + return (this.getFlags() & kMessageExpectsResponse) != 0;
|
| + };
|
| +
|
| + Message.prototype.setRequestID = function(requestID) {
|
| + // TODO(darin): Verify that space was reserved for this field!
|
| + this.buffer.setUint64(kMessageRequestIDOffset, requestID);
|
| + };
|
| +
|
| + Message.prototype.setInterfaceId = function(interfaceId) {
|
| + this.buffer.setUint32(kMessageInterfaceIdOffset, interfaceId);
|
| + };
|
| +
|
| + Message.prototype.setPayloadInterfaceIds_ = function(payloadInterfaceIds) {
|
| + if (this.getHeaderVersion() < 2) {
|
| + throw new Error(
|
| + "Version of message does not support payload interface ids");
|
| + }
|
| +
|
| + var decoder = new Decoder(this.buffer, this.handles,
|
| + this.associatedEndpointHandles,
|
| + kMessagePayloadInterfaceIdsPointerOffset);
|
| + var payloadInterfaceIdsOffset = decoder.decodePointer();
|
| + var encoder = new Encoder(this.buffer, this.handles,
|
| + this.associatedEndpointHandles,
|
| + payloadInterfaceIdsOffset);
|
| + encoder.encodeArray(Uint32, payloadInterfaceIds);
|
| + };
|
| +
|
| + Message.prototype.serializeAssociatedEndpointHandles = function(
|
| + associatedGroupController) {
|
| + if (this.associatedEndpointHandles.length > 0) {
|
| + if (this.getHeaderVersion() < 2) {
|
| + throw new Error(
|
| + "Version of message does not support associated endpoint handles");
|
| + }
|
| +
|
| + var data = [];
|
| + for (var i = 0; i < this.associatedEndpointHandles.length; i++) {
|
| + var handle = this.associatedEndpointHandles[i];
|
| + data.push(associatedGroupController.associateInterface(handle));
|
| + }
|
| + this.associatedEndpointHandles = [];
|
| + this.setPayloadInterfaceIds_(data);
|
| + }
|
| + };
|
| +
|
| + Message.prototype.deserializeAssociatedEndpointHandles = function(
|
| + associatedGroupController) {
|
| + if (this.getHeaderVersion() < 2) {
|
| + return true;
|
| + }
|
| +
|
| + this.associatedEndpointHandles = [];
|
| + var ids = this.getPayloadInterfaceIds();
|
| +
|
| + var result = true;
|
| + for (var i = 0; i < ids.length; i++) {
|
| + var handle = associatedGroupController.createLocalEndpointHandle(ids[i]);
|
| + if (internal.isValidInterfaceId(ids[i]) && !handle.isValid()) {
|
| + // |ids[i]| itself is valid but handle creation failed. In that case,
|
| + // mark deserialization as failed but continue to deserialize the
|
| + // rest of handles.
|
| + result = false;
|
| + }
|
| + this.associatedEndpointHandles.push(handle);
|
| + ids[i] = internal.kInvalidInterfaceId;
|
| + }
|
| +
|
| + this.setPayloadInterfaceIds_(ids);
|
| + return result;
|
| + };
|
| +
|
| +
|
| + // MessageV0Builder ---------------------------------------------------------
|
| +
|
| + function MessageV0Builder(messageName, payloadSize) {
|
| + // Currently, we don't compute the payload size correctly ahead of time.
|
| + // Instead, we resize the buffer at the end.
|
| + var numberOfBytes = kMessageV0HeaderSize + payloadSize;
|
| + this.buffer = new internal.Buffer(numberOfBytes);
|
| + this.handles = [];
|
| + var encoder = this.createEncoder(kMessageV0HeaderSize);
|
| + encoder.writeUint32(kMessageV0HeaderSize);
|
| + encoder.writeUint32(0); // version.
|
| + encoder.writeUint32(0); // interface ID.
|
| + encoder.writeUint32(messageName);
|
| + encoder.writeUint32(0); // flags.
|
| + encoder.writeUint32(0); // padding.
|
| + }
|
| +
|
| + MessageV0Builder.prototype.createEncoder = function(size) {
|
| + var pointer = this.buffer.alloc(size);
|
| + return new Encoder(this.buffer, this.handles, [], pointer);
|
| + };
|
| +
|
| + MessageV0Builder.prototype.encodeStruct = function(cls, val) {
|
| + cls.encode(this.createEncoder(cls.encodedSize), val);
|
| + };
|
| +
|
| + MessageV0Builder.prototype.finish = function() {
|
| + // TODO(abarth): Rather than resizing the buffer at the end, we could
|
| + // compute the size we need ahead of time, like we do in C++.
|
| + this.buffer.trim();
|
| + var message = new Message(this.buffer, this.handles);
|
| + this.buffer = null;
|
| + this.handles = null;
|
| + this.encoder = null;
|
| + return message;
|
| + };
|
| +
|
| + // MessageV1Builder -----------------------------------------------
|
| +
|
| + function MessageV1Builder(messageName, payloadSize, flags,
|
| + requestID) {
|
| + // Currently, we don't compute the payload size correctly ahead of time.
|
| + // Instead, we resize the buffer at the end.
|
| + var numberOfBytes = kMessageV1HeaderSize + payloadSize;
|
| + this.buffer = new internal.Buffer(numberOfBytes);
|
| + this.handles = [];
|
| + var encoder = this.createEncoder(kMessageV1HeaderSize);
|
| + encoder.writeUint32(kMessageV1HeaderSize);
|
| + encoder.writeUint32(1); // version.
|
| + encoder.writeUint32(0); // interface ID.
|
| + encoder.writeUint32(messageName);
|
| + encoder.writeUint32(flags);
|
| + encoder.writeUint32(0); // padding.
|
| + encoder.writeUint64(requestID);
|
| + }
|
| +
|
| + MessageV1Builder.prototype =
|
| + Object.create(MessageV0Builder.prototype);
|
| +
|
| + MessageV1Builder.prototype.constructor =
|
| + MessageV1Builder;
|
| +
|
| + // MessageV2 -----------------------------------------------
|
| +
|
| + function MessageV2Builder(messageName, payloadSize, flags, requestID) {
|
| + // Currently, we don't compute the payload size correctly ahead of time.
|
| + // Instead, we resize the buffer at the end.
|
| + var numberOfBytes = kMessageV2HeaderSize + payloadSize;
|
| + this.buffer = new internal.Buffer(numberOfBytes);
|
| + this.handles = [];
|
| +
|
| + this.payload = null;
|
| + this.associatedEndpointHandles = [];
|
| +
|
| + this.encoder = this.createEncoder(kMessageV2HeaderSize);
|
| + this.encoder.writeUint32(kMessageV2HeaderSize);
|
| + this.encoder.writeUint32(2); // version.
|
| + // Gets set to an appropriate interfaceId for the endpoint by the Router.
|
| + this.encoder.writeUint32(0); // interface ID.
|
| + this.encoder.writeUint32(messageName);
|
| + this.encoder.writeUint32(flags);
|
| + this.encoder.writeUint32(0); // padding.
|
| + this.encoder.writeUint64(requestID);
|
| + }
|
| +
|
| + MessageV2Builder.prototype.createEncoder = function(size) {
|
| + var pointer = this.buffer.alloc(size);
|
| + return new Encoder(this.buffer, this.handles,
|
| + this.associatedEndpointHandles, pointer);
|
| + };
|
| +
|
| + MessageV2Builder.prototype.setPayload = function(cls, val) {
|
| + this.payload = {cls: cls, val: val};
|
| + };
|
| +
|
| + MessageV2Builder.prototype.finish = function() {
|
| + if (!this.payload) {
|
| + throw new Error("Payload needs to be set before calling finish");
|
| + }
|
| +
|
| + this.encoder.encodeStructPointer(this.payload.cls, this.payload.val);
|
| + this.encoder.encodeArrayPointer(Uint32,
|
| + new Array(this.associatedEndpointHandles.length));
|
| +
|
| + this.buffer.trim();
|
| + var message = new Message(this.buffer, this.handles,
|
| + this.associatedEndpointHandles);
|
| + this.buffer = null;
|
| + this.handles = null;
|
| + this.encoder = null;
|
| + this.payload = null;
|
| + this.associatedEndpointHandles = null;
|
| +
|
| + return message;
|
| + };
|
| +
|
| + // MessageReader ------------------------------------------------------------
|
| +
|
| + function MessageReader(message) {
|
| + this.decoder = new Decoder(message.buffer, message.handles,
|
| + message.associatedEndpointHandles, 0);
|
| + var messageHeaderSize = this.decoder.readUint32();
|
| + this.payloadSize = message.buffer.byteLength - messageHeaderSize;
|
| + var version = this.decoder.readUint32();
|
| + var interface_id = this.decoder.readUint32();
|
| + this.messageName = this.decoder.readUint32();
|
| + this.flags = this.decoder.readUint32();
|
| + // Skip the padding.
|
| + this.decoder.skip(4);
|
| + if (version >= 1)
|
| + this.requestID = this.decoder.readUint64();
|
| + this.decoder.skip(messageHeaderSize - this.decoder.next);
|
| + }
|
| +
|
| + MessageReader.prototype.decodeStruct = function(cls) {
|
| + return cls.decode(this.decoder);
|
| + };
|
| +
|
| + // Built-in types -----------------------------------------------------------
|
| +
|
| + // This type is only used with ArrayOf(PackedBool).
|
| + function PackedBool() {
|
| + }
|
| +
|
| + function Int8() {
|
| + }
|
| +
|
| + Int8.encodedSize = 1;
|
| +
|
| + Int8.decode = function(decoder) {
|
| + return decoder.readInt8();
|
| + };
|
| +
|
| + Int8.encode = function(encoder, val) {
|
| + encoder.writeInt8(val);
|
| + };
|
| +
|
| + Uint8.encode = function(encoder, val) {
|
| + encoder.writeUint8(val);
|
| + };
|
| +
|
| + function Uint8() {
|
| + }
|
| +
|
| + Uint8.encodedSize = 1;
|
| +
|
| + Uint8.decode = function(decoder) {
|
| + return decoder.readUint8();
|
| + };
|
| +
|
| + Uint8.encode = function(encoder, val) {
|
| + encoder.writeUint8(val);
|
| + };
|
| +
|
| + function Int16() {
|
| + }
|
| +
|
| + Int16.encodedSize = 2;
|
| +
|
| + Int16.decode = function(decoder) {
|
| + return decoder.readInt16();
|
| + };
|
| +
|
| + Int16.encode = function(encoder, val) {
|
| + encoder.writeInt16(val);
|
| + };
|
| +
|
| + function Uint16() {
|
| + }
|
| +
|
| + Uint16.encodedSize = 2;
|
| +
|
| + Uint16.decode = function(decoder) {
|
| + return decoder.readUint16();
|
| + };
|
| +
|
| + Uint16.encode = function(encoder, val) {
|
| + encoder.writeUint16(val);
|
| + };
|
| +
|
| + function Int32() {
|
| + }
|
| +
|
| + Int32.encodedSize = 4;
|
| +
|
| + Int32.decode = function(decoder) {
|
| + return decoder.readInt32();
|
| + };
|
| +
|
| + Int32.encode = function(encoder, val) {
|
| + encoder.writeInt32(val);
|
| + };
|
| +
|
| + function Uint32() {
|
| + }
|
| +
|
| + Uint32.encodedSize = 4;
|
| +
|
| + Uint32.decode = function(decoder) {
|
| + return decoder.readUint32();
|
| + };
|
| +
|
| + Uint32.encode = function(encoder, val) {
|
| + encoder.writeUint32(val);
|
| + };
|
| +
|
| + function Int64() {
|
| + }
|
| +
|
| + Int64.encodedSize = 8;
|
| +
|
| + Int64.decode = function(decoder) {
|
| + return decoder.readInt64();
|
| + };
|
| +
|
| + Int64.encode = function(encoder, val) {
|
| + encoder.writeInt64(val);
|
| + };
|
| +
|
| + function Uint64() {
|
| + }
|
| +
|
| + Uint64.encodedSize = 8;
|
| +
|
| + Uint64.decode = function(decoder) {
|
| + return decoder.readUint64();
|
| + };
|
| +
|
| + Uint64.encode = function(encoder, val) {
|
| + encoder.writeUint64(val);
|
| + };
|
| +
|
| + function String() {
|
| + };
|
| +
|
| + String.encodedSize = 8;
|
| +
|
| + String.decode = function(decoder) {
|
| + return decoder.decodeStringPointer();
|
| + };
|
| +
|
| + String.encode = function(encoder, val) {
|
| + encoder.encodeStringPointer(val);
|
| + };
|
| +
|
| + function NullableString() {
|
| + }
|
| +
|
| + NullableString.encodedSize = String.encodedSize;
|
| +
|
| + NullableString.decode = String.decode;
|
| +
|
| + NullableString.encode = String.encode;
|
| +
|
| + function Float() {
|
| + }
|
| +
|
| + Float.encodedSize = 4;
|
| +
|
| + Float.decode = function(decoder) {
|
| + return decoder.readFloat();
|
| + };
|
| +
|
| + Float.encode = function(encoder, val) {
|
| + encoder.writeFloat(val);
|
| + };
|
| +
|
| + function Double() {
|
| + }
|
| +
|
| + Double.encodedSize = 8;
|
| +
|
| + Double.decode = function(decoder) {
|
| + return decoder.readDouble();
|
| + };
|
| +
|
| + Double.encode = function(encoder, val) {
|
| + encoder.writeDouble(val);
|
| + };
|
| +
|
| + function Enum(cls) {
|
| + this.cls = cls;
|
| + }
|
| +
|
| + Enum.prototype.encodedSize = 4;
|
| +
|
| + Enum.prototype.decode = function(decoder) {
|
| + return decoder.readInt32();
|
| + };
|
| +
|
| + Enum.prototype.encode = function(encoder, val) {
|
| + encoder.writeInt32(val);
|
| + };
|
| +
|
| + function PointerTo(cls) {
|
| + this.cls = cls;
|
| + }
|
| +
|
| + PointerTo.prototype.encodedSize = 8;
|
| +
|
| + PointerTo.prototype.decode = function(decoder) {
|
| + var pointer = decoder.decodePointer();
|
| + if (!pointer) {
|
| + return null;
|
| + }
|
| + return this.cls.decode(decoder.decodeAndCreateDecoder(pointer));
|
| + };
|
| +
|
| + PointerTo.prototype.encode = function(encoder, val) {
|
| + if (!val) {
|
| + encoder.encodePointer(val);
|
| + return;
|
| + }
|
| + var objectEncoder = encoder.createAndEncodeEncoder(this.cls.encodedSize);
|
| + this.cls.encode(objectEncoder, val);
|
| + };
|
| +
|
| + function NullablePointerTo(cls) {
|
| + PointerTo.call(this, cls);
|
| + }
|
| +
|
| + NullablePointerTo.prototype = Object.create(PointerTo.prototype);
|
| +
|
| + function ArrayOf(cls, length) {
|
| + this.cls = cls;
|
| + this.length = length || 0;
|
| + }
|
| +
|
| + ArrayOf.prototype.encodedSize = 8;
|
| +
|
| + ArrayOf.prototype.dimensions = function() {
|
| + return [this.length].concat(
|
| + (this.cls instanceof ArrayOf) ? this.cls.dimensions() : []);
|
| + }
|
| +
|
| + ArrayOf.prototype.decode = function(decoder) {
|
| + return decoder.decodeArrayPointer(this.cls);
|
| + };
|
| +
|
| + ArrayOf.prototype.encode = function(encoder, val) {
|
| + encoder.encodeArrayPointer(this.cls, val);
|
| + };
|
| +
|
| + function NullableArrayOf(cls) {
|
| + ArrayOf.call(this, cls);
|
| + }
|
| +
|
| + NullableArrayOf.prototype = Object.create(ArrayOf.prototype);
|
| +
|
| + function Handle() {
|
| + }
|
| +
|
| + Handle.encodedSize = 4;
|
| +
|
| + Handle.decode = function(decoder) {
|
| + return decoder.decodeHandle();
|
| + };
|
| +
|
| + Handle.encode = function(encoder, val) {
|
| + encoder.encodeHandle(val);
|
| + };
|
| +
|
| + function NullableHandle() {
|
| + }
|
| +
|
| + NullableHandle.encodedSize = Handle.encodedSize;
|
| +
|
| + NullableHandle.decode = Handle.decode;
|
| +
|
| + NullableHandle.encode = Handle.encode;
|
| +
|
| + function Interface(cls) {
|
| + this.cls = cls;
|
| + }
|
| +
|
| + Interface.prototype.encodedSize = 8;
|
| +
|
| + Interface.prototype.decode = function(decoder) {
|
| + var interfacePtrInfo = new mojo.InterfacePtrInfo(
|
| + decoder.decodeHandle(), decoder.readUint32());
|
| + var interfacePtr = new this.cls();
|
| + interfacePtr.ptr.bind(interfacePtrInfo);
|
| + return interfacePtr;
|
| + };
|
| +
|
| + Interface.prototype.encode = function(encoder, val) {
|
| + var interfacePtrInfo =
|
| + val ? val.ptr.passInterface() : new mojo.InterfacePtrInfo(null, 0);
|
| + encoder.encodeHandle(interfacePtrInfo.handle);
|
| + encoder.writeUint32(interfacePtrInfo.version);
|
| + };
|
| +
|
| + function NullableInterface(cls) {
|
| + Interface.call(this, cls);
|
| + }
|
| +
|
| + NullableInterface.prototype = Object.create(Interface.prototype);
|
| +
|
| + function AssociatedInterfacePtrInfo() {
|
| + }
|
| +
|
| + AssociatedInterfacePtrInfo.prototype.encodedSize = 8;
|
| +
|
| + AssociatedInterfacePtrInfo.decode = function(decoder) {
|
| + return new mojo.AssociatedInterfacePtrInfo(
|
| + decoder.decodeAssociatedEndpointHandle(), decoder.readUint32());
|
| + };
|
| +
|
| + AssociatedInterfacePtrInfo.encode = function(encoder, val) {
|
| + var associatedinterfacePtrInfo =
|
| + val ? val : new mojo.AssociatedInterfacePtrInfo(null, 0);
|
| + encoder.encodeAssociatedEndpointHandle(
|
| + associatedinterfacePtrInfo.interfaceEndpointHandle);
|
| + encoder.writeUint32(associatedinterfacePtrInfo.version);
|
| + };
|
| +
|
| + function NullableAssociatedInterfacePtrInfo() {
|
| + }
|
| +
|
| + NullableAssociatedInterfacePtrInfo.encodedSize =
|
| + AssociatedInterfacePtrInfo.encodedSize;
|
| +
|
| + NullableAssociatedInterfacePtrInfo.decode =
|
| + AssociatedInterfacePtrInfo.decode;
|
| +
|
| + NullableAssociatedInterfacePtrInfo.encode =
|
| + AssociatedInterfacePtrInfo.encode;
|
| +
|
| + function InterfaceRequest() {
|
| + }
|
| +
|
| + InterfaceRequest.encodedSize = 4;
|
| +
|
| + InterfaceRequest.decode = function(decoder) {
|
| + return new mojo.InterfaceRequest(decoder.decodeHandle());
|
| + };
|
| +
|
| + InterfaceRequest.encode = function(encoder, val) {
|
| + encoder.encodeHandle(val ? val.handle : null);
|
| + };
|
| +
|
| + function NullableInterfaceRequest() {
|
| + }
|
| +
|
| + NullableInterfaceRequest.encodedSize = InterfaceRequest.encodedSize;
|
| +
|
| + NullableInterfaceRequest.decode = InterfaceRequest.decode;
|
| +
|
| + NullableInterfaceRequest.encode = InterfaceRequest.encode;
|
| +
|
| + function AssociatedInterfaceRequest() {
|
| + }
|
| +
|
| + AssociatedInterfaceRequest.decode = function(decoder) {
|
| + var handle = decoder.decodeAssociatedEndpointHandle();
|
| + return new mojo.AssociatedInterfaceRequest(handle);
|
| + };
|
| +
|
| + AssociatedInterfaceRequest.encode = function(encoder, val) {
|
| + encoder.encodeAssociatedEndpointHandle(
|
| + val ? val.interfaceEndpointHandle : null);
|
| + };
|
| +
|
| + AssociatedInterfaceRequest.encodedSize = 4;
|
| +
|
| + function NullableAssociatedInterfaceRequest() {
|
| + }
|
| +
|
| + NullableAssociatedInterfaceRequest.encodedSize =
|
| + AssociatedInterfaceRequest.encodedSize;
|
| +
|
| + NullableAssociatedInterfaceRequest.decode =
|
| + AssociatedInterfaceRequest.decode;
|
| +
|
| + NullableAssociatedInterfaceRequest.encode =
|
| + AssociatedInterfaceRequest.encode;
|
| +
|
| + function MapOf(keyClass, valueClass) {
|
| + this.keyClass = keyClass;
|
| + this.valueClass = valueClass;
|
| + }
|
| +
|
| + MapOf.prototype.encodedSize = 8;
|
| +
|
| + MapOf.prototype.decode = function(decoder) {
|
| + return decoder.decodeMapPointer(this.keyClass, this.valueClass);
|
| + };
|
| +
|
| + MapOf.prototype.encode = function(encoder, val) {
|
| + encoder.encodeMapPointer(this.keyClass, this.valueClass, val);
|
| + };
|
| +
|
| + function NullableMapOf(keyClass, valueClass) {
|
| + MapOf.call(this, keyClass, valueClass);
|
| + }
|
| +
|
| + NullableMapOf.prototype = Object.create(MapOf.prototype);
|
| +
|
| + internal.align = align;
|
| + internal.isAligned = isAligned;
|
| + internal.Message = Message;
|
| + internal.MessageV0Builder = MessageV0Builder;
|
| + internal.MessageV1Builder = MessageV1Builder;
|
| + internal.MessageV2Builder = MessageV2Builder;
|
| + internal.MessageReader = MessageReader;
|
| + internal.kArrayHeaderSize = kArrayHeaderSize;
|
| + internal.kMapStructPayloadSize = kMapStructPayloadSize;
|
| + internal.kStructHeaderSize = kStructHeaderSize;
|
| + internal.kEncodedInvalidHandleValue = kEncodedInvalidHandleValue;
|
| + internal.kMessageV0HeaderSize = kMessageV0HeaderSize;
|
| + internal.kMessageV1HeaderSize = kMessageV1HeaderSize;
|
| + internal.kMessageV2HeaderSize = kMessageV2HeaderSize;
|
| + internal.kMessagePayloadInterfaceIdsPointerOffset =
|
| + kMessagePayloadInterfaceIdsPointerOffset;
|
| + internal.kMessageExpectsResponse = kMessageExpectsResponse;
|
| + internal.kMessageIsResponse = kMessageIsResponse;
|
| + internal.Int8 = Int8;
|
| + internal.Uint8 = Uint8;
|
| + internal.Int16 = Int16;
|
| + internal.Uint16 = Uint16;
|
| + internal.Int32 = Int32;
|
| + internal.Uint32 = Uint32;
|
| + internal.Int64 = Int64;
|
| + internal.Uint64 = Uint64;
|
| + internal.Float = Float;
|
| + internal.Double = Double;
|
| + internal.String = String;
|
| + internal.Enum = Enum;
|
| + internal.NullableString = NullableString;
|
| + internal.PointerTo = PointerTo;
|
| + internal.NullablePointerTo = NullablePointerTo;
|
| + internal.ArrayOf = ArrayOf;
|
| + internal.NullableArrayOf = NullableArrayOf;
|
| + internal.PackedBool = PackedBool;
|
| + internal.Handle = Handle;
|
| + internal.NullableHandle = NullableHandle;
|
| + internal.Interface = Interface;
|
| + internal.NullableInterface = NullableInterface;
|
| + internal.InterfaceRequest = InterfaceRequest;
|
| + internal.NullableInterfaceRequest = NullableInterfaceRequest;
|
| + internal.AssociatedInterfacePtrInfo = AssociatedInterfacePtrInfo;
|
| + internal.NullableAssociatedInterfacePtrInfo =
|
| + NullableAssociatedInterfacePtrInfo;
|
| + internal.AssociatedInterfaceRequest = AssociatedInterfaceRequest;
|
| + internal.NullableAssociatedInterfaceRequest =
|
| + NullableAssociatedInterfaceRequest;
|
| + internal.MapOf = MapOf;
|
| + internal.NullableMapOf = NullableMapOf;
|
| +})();
|
| +// 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + function Connector(handle) {
|
| + if (!(handle instanceof MojoHandle))
|
| + throw new Error("Connector: not a handle " + handle);
|
| + this.handle_ = handle;
|
| + this.dropWrites_ = false;
|
| + this.error_ = false;
|
| + this.incomingReceiver_ = null;
|
| + this.readWatcher_ = null;
|
| + this.errorHandler_ = null;
|
| + this.paused_ = false;
|
| +
|
| + this.waitToReadMore();
|
| + }
|
| +
|
| + Connector.prototype.close = function() {
|
| + this.cancelWait();
|
| + if (this.handle_ != null) {
|
| + this.handle_.close();
|
| + this.handle_ = null;
|
| + }
|
| + };
|
| +
|
| + Connector.prototype.pauseIncomingMethodCallProcessing = function() {
|
| + if (this.paused_) {
|
| + return;
|
| + }
|
| + this.paused_= true;
|
| + this.cancelWait();
|
| + };
|
| +
|
| + Connector.prototype.resumeIncomingMethodCallProcessing = function() {
|
| + if (!this.paused_) {
|
| + return;
|
| + }
|
| + this.paused_= false;
|
| + this.waitToReadMore();
|
| + };
|
| +
|
| + Connector.prototype.accept = function(message) {
|
| + if (this.error_)
|
| + return false;
|
| +
|
| + if (this.dropWrites_)
|
| + return true;
|
| +
|
| + var result = this.handle_.writeMessage(
|
| + new Uint8Array(message.buffer.arrayBuffer), message.handles);
|
| + switch (result) {
|
| + case Mojo.RESULT_OK:
|
| + // The handles were successfully transferred, so we don't own them
|
| + // anymore.
|
| + message.handles = [];
|
| + break;
|
| + case Mojo.RESULT_FAILED_PRECONDITION:
|
| + // There's no point in continuing to write to this pipe since the other
|
| + // end is gone. Avoid writing any future messages. Hide write failures
|
| + // from the caller since we'd like them to continue consuming any
|
| + // backlog of incoming messages before regarding the message pipe as
|
| + // closed.
|
| + this.dropWrites_ = true;
|
| + break;
|
| + default:
|
| + // This particular write was rejected, presumably because of bad input.
|
| + // The pipe is not necessarily in a bad state.
|
| + return false;
|
| + }
|
| + return true;
|
| + };
|
| +
|
| + Connector.prototype.setIncomingReceiver = function(receiver) {
|
| + this.incomingReceiver_ = receiver;
|
| + };
|
| +
|
| + Connector.prototype.setErrorHandler = function(handler) {
|
| + this.errorHandler_ = handler;
|
| + };
|
| +
|
| + Connector.prototype.readMore_ = function(result) {
|
| + for (;;) {
|
| + if (this.paused_) {
|
| + return;
|
| + }
|
| +
|
| + var read = this.handle_.readMessage();
|
| + if (this.handle_ == null) // The connector has been closed.
|
| + return;
|
| + if (read.result == Mojo.RESULT_SHOULD_WAIT)
|
| + return;
|
| + if (read.result != Mojo.RESULT_OK) {
|
| + this.handleError(read.result !== Mojo.RESULT_FAILED_PRECONDITION,
|
| + false);
|
| + return;
|
| + }
|
| + var messageBuffer = new internal.Buffer(read.buffer);
|
| + var message = new internal.Message(messageBuffer, read.handles);
|
| + var receiverResult = this.incomingReceiver_ &&
|
| + this.incomingReceiver_.accept(message);
|
| +
|
| + // Handle invalid incoming message.
|
| + if (!internal.isTestingMode() && !receiverResult) {
|
| + // TODO(yzshen): Consider notifying the embedder.
|
| + this.handleError(true, false);
|
| + }
|
| + }
|
| + };
|
| +
|
| + Connector.prototype.cancelWait = function() {
|
| + if (this.readWatcher_) {
|
| + this.readWatcher_.cancel();
|
| + this.readWatcher_ = null;
|
| + }
|
| + };
|
| +
|
| + Connector.prototype.waitToReadMore = function() {
|
| + if (this.handle_) {
|
| + this.readWatcher_ = this.handle_.watch({readable: true},
|
| + this.readMore_.bind(this));
|
| + }
|
| + };
|
| +
|
| + Connector.prototype.handleError = function(forcePipeReset,
|
| + forceAsyncHandler) {
|
| + if (this.error_ || this.handle_ === null) {
|
| + return;
|
| + }
|
| +
|
| + if (this.paused_) {
|
| + // Enforce calling the error handler asynchronously if the user has
|
| + // paused receiving messages. We need to wait until the user starts
|
| + // receiving messages again.
|
| + forceAsyncHandler = true;
|
| + }
|
| +
|
| + if (!forcePipeReset && forceAsyncHandler) {
|
| + forcePipeReset = true;
|
| + }
|
| +
|
| + this.cancelWait();
|
| + if (forcePipeReset) {
|
| + this.handle_.close();
|
| + var dummyPipe = Mojo.createMessagePipe();
|
| + this.handle_ = dummyPipe.handle0;
|
| + }
|
| +
|
| + if (forceAsyncHandler) {
|
| + if (!this.paused_) {
|
| + this.waitToReadMore();
|
| + }
|
| + } else {
|
| + this.error_ = true;
|
| + if (this.errorHandler_) {
|
| + this.errorHandler_.onError();
|
| + }
|
| + }
|
| + };
|
| +
|
| + internal.Connector = Connector;
|
| +})();
|
| +// Copyright 2016 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + // Constants ----------------------------------------------------------------
|
| + var kInterfaceIdNamespaceMask = 0x80000000;
|
| + var kMasterInterfaceId = 0x00000000;
|
| + var kInvalidInterfaceId = 0xFFFFFFFF;
|
| +
|
| + // ---------------------------------------------------------------------------
|
| +
|
| + function InterfacePtrInfo(handle, version) {
|
| + this.handle = handle;
|
| + this.version = version;
|
| + }
|
| +
|
| + InterfacePtrInfo.prototype.isValid = function() {
|
| + return this.handle instanceof MojoHandle;
|
| + };
|
| +
|
| + InterfacePtrInfo.prototype.close = function() {
|
| + if (!this.isValid())
|
| + return;
|
| +
|
| + this.handle.close();
|
| + this.handle = null;
|
| + this.version = 0;
|
| + };
|
| +
|
| + function AssociatedInterfacePtrInfo(interfaceEndpointHandle, version) {
|
| + this.interfaceEndpointHandle = interfaceEndpointHandle;
|
| + this.version = version;
|
| + }
|
| +
|
| + AssociatedInterfacePtrInfo.prototype.isValid = function() {
|
| + return this.interfaceEndpointHandle.isValid();
|
| + };
|
| +
|
| + // ---------------------------------------------------------------------------
|
| +
|
| + function InterfaceRequest(handle) {
|
| + this.handle = handle;
|
| + }
|
| +
|
| + InterfaceRequest.prototype.isValid = function() {
|
| + return this.handle instanceof MojoHandle;
|
| + };
|
| +
|
| + InterfaceRequest.prototype.close = function() {
|
| + if (!this.isValid())
|
| + return;
|
| +
|
| + this.handle.close();
|
| + this.handle = null;
|
| + };
|
| +
|
| + function AssociatedInterfaceRequest(interfaceEndpointHandle) {
|
| + this.interfaceEndpointHandle = interfaceEndpointHandle;
|
| + }
|
| +
|
| + AssociatedInterfaceRequest.prototype.isValid = function() {
|
| + return this.interfaceEndpointHandle.isValid();
|
| + };
|
| +
|
| + AssociatedInterfaceRequest.prototype.resetWithReason = function(reason) {
|
| + this.interfaceEndpointHandle.reset(reason);
|
| + };
|
| +
|
| + function isMasterInterfaceId(interfaceId) {
|
| + return interfaceId === kMasterInterfaceId;
|
| + }
|
| +
|
| + function isValidInterfaceId(interfaceId) {
|
| + return interfaceId !== kInvalidInterfaceId;
|
| + }
|
| +
|
| + mojo.InterfacePtrInfo = InterfacePtrInfo;
|
| + mojo.InterfaceRequest = InterfaceRequest;
|
| + mojo.AssociatedInterfacePtrInfo = AssociatedInterfacePtrInfo;
|
| + mojo.AssociatedInterfaceRequest = AssociatedInterfaceRequest;
|
| + internal.isMasterInterfaceId = isMasterInterfaceId;
|
| + internal.isValidInterfaceId = isValidInterfaceId;
|
| + internal.kInvalidInterfaceId = kInvalidInterfaceId;
|
| + internal.kMasterInterfaceId = kMasterInterfaceId;
|
| + internal.kInterfaceIdNamespaceMask = kInterfaceIdNamespaceMask;
|
| +})();
|
| +// Copyright 2017 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + function validateControlRequestWithResponse(message) {
|
| + var messageValidator = new internal.Validator(message);
|
| + var error = messageValidator.validateMessageIsRequestExpectingResponse();
|
| + if (error !== internal.validationError.NONE) {
|
| + throw error;
|
| + }
|
| +
|
| + if (message.getName() != mojo.interfaceControl2.kRunMessageId) {
|
| + throw new Error("Control message name is not kRunMessageId");
|
| + }
|
| +
|
| + // Validate payload.
|
| + error = mojo.interfaceControl2.RunMessageParams.validate(messageValidator,
|
| + message.getHeaderNumBytes());
|
| + if (error != internal.validationError.NONE) {
|
| + throw error;
|
| + }
|
| + }
|
| +
|
| + function validateControlRequestWithoutResponse(message) {
|
| + var messageValidator = new internal.Validator(message);
|
| + var error = messageValidator.validateMessageIsRequestWithoutResponse();
|
| + if (error != internal.validationError.NONE) {
|
| + throw error;
|
| + }
|
| +
|
| + if (message.getName() != mojo.interfaceControl2.kRunOrClosePipeMessageId) {
|
| + throw new Error("Control message name is not kRunOrClosePipeMessageId");
|
| + }
|
| +
|
| + // Validate payload.
|
| + error = mojo.interfaceControl2.RunOrClosePipeMessageParams.validate(
|
| + messageValidator, message.getHeaderNumBytes());
|
| + if (error != internal.validationError.NONE) {
|
| + throw error;
|
| + }
|
| + }
|
| +
|
| + function runOrClosePipe(message, interfaceVersion) {
|
| + var reader = new internal.MessageReader(message);
|
| + var runOrClosePipeMessageParams = reader.decodeStruct(
|
| + mojo.interfaceControl2.RunOrClosePipeMessageParams);
|
| + return interfaceVersion >=
|
| + runOrClosePipeMessageParams.input.requireVersion.version;
|
| + }
|
| +
|
| + function run(message, responder, interfaceVersion) {
|
| + var reader = new internal.MessageReader(message);
|
| + var runMessageParams =
|
| + reader.decodeStruct(mojo.interfaceControl2.RunMessageParams);
|
| + var runOutput = null;
|
| +
|
| + if (runMessageParams.input.queryVersion) {
|
| + runOutput = new mojo.interfaceControl2.RunOutput();
|
| + runOutput.queryVersionResult = new
|
| + mojo.interfaceControl2.QueryVersionResult(
|
| + {'version': interfaceVersion});
|
| + }
|
| +
|
| + var runResponseMessageParams = new
|
| + mojo.interfaceControl2.RunResponseMessageParams();
|
| + runResponseMessageParams.output = runOutput;
|
| +
|
| + var messageName = mojo.interfaceControl2.kRunMessageId;
|
| + var payloadSize =
|
| + mojo.interfaceControl2.RunResponseMessageParams.encodedSize;
|
| + var requestID = reader.requestID;
|
| + var builder = new internal.MessageV1Builder(messageName,
|
| + payloadSize, internal.kMessageIsResponse, requestID);
|
| + builder.encodeStruct(mojo.interfaceControl2.RunResponseMessageParams,
|
| + runResponseMessageParams);
|
| + responder.accept(builder.finish());
|
| + return true;
|
| + }
|
| +
|
| + function isInterfaceControlMessage(message) {
|
| + return message.getName() == mojo.interfaceControl2.kRunMessageId ||
|
| + message.getName() == mojo.interfaceControl2.kRunOrClosePipeMessageId;
|
| + }
|
| +
|
| + function ControlMessageHandler(interfaceVersion) {
|
| + this.interfaceVersion_ = interfaceVersion;
|
| + }
|
| +
|
| + ControlMessageHandler.prototype.accept = function(message) {
|
| + validateControlRequestWithoutResponse(message);
|
| + return runOrClosePipe(message, this.interfaceVersion_);
|
| + };
|
| +
|
| + ControlMessageHandler.prototype.acceptWithResponder = function(message,
|
| + responder) {
|
| + validateControlRequestWithResponse(message);
|
| + return run(message, responder, this.interfaceVersion_);
|
| + };
|
| +
|
| + internal.ControlMessageHandler = ControlMessageHandler;
|
| + internal.isInterfaceControlMessage = isInterfaceControlMessage;
|
| +})();
|
| +// Copyright 2017 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + function constructRunOrClosePipeMessage(runOrClosePipeInput) {
|
| + var runOrClosePipeMessageParams = new
|
| + mojo.interfaceControl2.RunOrClosePipeMessageParams();
|
| + runOrClosePipeMessageParams.input = runOrClosePipeInput;
|
| +
|
| + var messageName = mojo.interfaceControl2.kRunOrClosePipeMessageId;
|
| + var payloadSize =
|
| + mojo.interfaceControl2.RunOrClosePipeMessageParams.encodedSize;
|
| + var builder = new internal.MessageV0Builder(messageName, payloadSize);
|
| + builder.encodeStruct(mojo.interfaceControl2.RunOrClosePipeMessageParams,
|
| + runOrClosePipeMessageParams);
|
| + var message = builder.finish();
|
| + return message;
|
| + }
|
| +
|
| + function validateControlResponse(message) {
|
| + var messageValidator = new internal.Validator(message);
|
| + var error = messageValidator.validateMessageIsResponse();
|
| + if (error != internal.validationError.NONE) {
|
| + throw error;
|
| + }
|
| +
|
| + if (message.getName() != mojo.interfaceControl2.kRunMessageId) {
|
| + throw new Error("Control message name is not kRunMessageId");
|
| + }
|
| +
|
| + // Validate payload.
|
| + error = mojo.interfaceControl2.RunResponseMessageParams.validate(
|
| + messageValidator, message.getHeaderNumBytes());
|
| + if (error != internal.validationError.NONE) {
|
| + throw error;
|
| + }
|
| + }
|
| +
|
| + function acceptRunResponse(message) {
|
| + validateControlResponse(message);
|
| +
|
| + var reader = new internal.MessageReader(message);
|
| + var runResponseMessageParams = reader.decodeStruct(
|
| + mojo.interfaceControl2.RunResponseMessageParams);
|
| +
|
| + return Promise.resolve(runResponseMessageParams);
|
| + }
|
| +
|
| + /**
|
| + * Sends the given run message through the receiver.
|
| + * Accepts the response message from the receiver and decodes the message
|
| + * struct to RunResponseMessageParams.
|
| + *
|
| + * @param {Router} receiver.
|
| + * @param {RunMessageParams} runMessageParams to be sent via a message.
|
| + * @return {Promise} that resolves to a RunResponseMessageParams.
|
| + */
|
| + function sendRunMessage(receiver, runMessageParams) {
|
| + var messageName = mojo.interfaceControl2.kRunMessageId;
|
| + var payloadSize = mojo.interfaceControl2.RunMessageParams.encodedSize;
|
| + // |requestID| is set to 0, but is later properly set by Router.
|
| + var builder = new internal.MessageV1Builder(messageName,
|
| + payloadSize, internal.kMessageExpectsResponse, 0);
|
| + builder.encodeStruct(mojo.interfaceControl2.RunMessageParams,
|
| + runMessageParams);
|
| + var message = builder.finish();
|
| +
|
| + return receiver.acceptAndExpectResponse(message).then(acceptRunResponse);
|
| + }
|
| +
|
| + function ControlMessageProxy(receiver) {
|
| + this.receiver_ = receiver;
|
| + }
|
| +
|
| + ControlMessageProxy.prototype.queryVersion = function() {
|
| + var runMessageParams = new mojo.interfaceControl2.RunMessageParams();
|
| + runMessageParams.input = new mojo.interfaceControl2.RunInput();
|
| + runMessageParams.input.queryVersion =
|
| + new mojo.interfaceControl2.QueryVersion();
|
| +
|
| + return sendRunMessage(this.receiver_, runMessageParams).then(function(
|
| + runResponseMessageParams) {
|
| + return runResponseMessageParams.output.queryVersionResult.version;
|
| + });
|
| + };
|
| +
|
| + ControlMessageProxy.prototype.requireVersion = function(version) {
|
| + var runOrClosePipeInput = new mojo.interfaceControl2.RunOrClosePipeInput();
|
| + runOrClosePipeInput.requireVersion =
|
| + new mojo.interfaceControl2.RequireVersion({'version': version});
|
| + var message = constructRunOrClosePipeMessage(runOrClosePipeInput);
|
| + this.receiver_.accept(message);
|
| + };
|
| +
|
| + internal.ControlMessageProxy = ControlMessageProxy;
|
| +})();
|
| +// Copyright 2017 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + function InterfaceEndpointClient(interfaceEndpointHandle, receiver,
|
| + interfaceVersion) {
|
| + this.controller_ = null;
|
| + this.encounteredError_ = false;
|
| + this.handle_ = interfaceEndpointHandle;
|
| + this.incomingReceiver_ = receiver;
|
| +
|
| + if (interfaceVersion !== undefined) {
|
| + this.controlMessageHandler_ = new internal.ControlMessageHandler(
|
| + interfaceVersion);
|
| + } else {
|
| + this.controlMessageProxy_ = new internal.ControlMessageProxy(this);
|
| + }
|
| +
|
| + this.nextRequestID_ = 0;
|
| + this.completers_ = new Map();
|
| + this.payloadValidators_ = [];
|
| + this.connectionErrorHandler_ = null;
|
| +
|
| + if (interfaceEndpointHandle.pendingAssociation()) {
|
| + interfaceEndpointHandle.setAssociationEventHandler(
|
| + this.onAssociationEvent.bind(this));
|
| + } else {
|
| + this.initControllerIfNecessary_();
|
| + }
|
| + }
|
| +
|
| + InterfaceEndpointClient.prototype.initControllerIfNecessary_ = function() {
|
| + if (this.controller_ || this.handle_.pendingAssociation()) {
|
| + return;
|
| + }
|
| +
|
| + this.controller_ = this.handle_.groupController().attachEndpointClient(
|
| + this.handle_, this);
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.onAssociationEvent = function(
|
| + associationEvent) {
|
| + if (associationEvent === internal.AssociationEvent.ASSOCIATED) {
|
| + this.initControllerIfNecessary_();
|
| + } else if (associationEvent ===
|
| + internal.AssociationEvent.PEER_CLOSED_BEFORE_ASSOCIATION) {
|
| + setTimeout(this.notifyError.bind(this, this.handle_.disconnectReason()),
|
| + 0);
|
| + }
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.passHandle = function() {
|
| + if (!this.handle_.isValid()) {
|
| + return new internal.InterfaceEndpointHandle();
|
| + }
|
| +
|
| + // Used to clear the previously set callback.
|
| + this.handle_.setAssociationEventHandler(undefined);
|
| +
|
| + if (this.controller_) {
|
| + this.controller_ = null;
|
| + this.handle_.groupController().detachEndpointClient(this.handle_);
|
| + }
|
| + var handle = this.handle_;
|
| + this.handle_ = null;
|
| + return handle;
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.close = function(reason) {
|
| + var handle = this.passHandle();
|
| + handle.reset(reason);
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.accept = function(message) {
|
| + if (message.associatedEndpointHandles.length > 0) {
|
| + message.serializeAssociatedEndpointHandles(
|
| + this.handle_.groupController());
|
| + }
|
| +
|
| + if (this.encounteredError_) {
|
| + return false;
|
| + }
|
| +
|
| + this.initControllerIfNecessary_();
|
| + return this.controller_.sendMessage(message);
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.acceptAndExpectResponse = function(
|
| + message) {
|
| + if (message.associatedEndpointHandles.length > 0) {
|
| + message.serializeAssociatedEndpointHandles(
|
| + this.handle_.groupController());
|
| + }
|
| +
|
| + if (this.encounteredError_) {
|
| + return Promise.reject();
|
| + }
|
| +
|
| + this.initControllerIfNecessary_();
|
| +
|
| + // Reserve 0 in case we want it to convey special meaning in the future.
|
| + var requestID = this.nextRequestID_++;
|
| + if (requestID === 0)
|
| + requestID = this.nextRequestID_++;
|
| +
|
| + message.setRequestID(requestID);
|
| + var result = this.controller_.sendMessage(message);
|
| + if (!result)
|
| + return Promise.reject(Error("Connection error"));
|
| +
|
| + var completer = {};
|
| + this.completers_.set(requestID, completer);
|
| + return new Promise(function(resolve, reject) {
|
| + completer.resolve = resolve;
|
| + completer.reject = reject;
|
| + });
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.setPayloadValidators = function(
|
| + payloadValidators) {
|
| + this.payloadValidators_ = payloadValidators;
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.setIncomingReceiver = function(receiver) {
|
| + this.incomingReceiver_ = receiver;
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.setConnectionErrorHandler = function(
|
| + handler) {
|
| + this.connectionErrorHandler_ = handler;
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.handleIncomingMessage = function(message,
|
| + messageValidator) {
|
| + var noError = internal.validationError.NONE;
|
| + var err = noError;
|
| + for (var i = 0; err === noError && i < this.payloadValidators_.length; ++i)
|
| + err = this.payloadValidators_[i](messageValidator);
|
| +
|
| + if (err == noError) {
|
| + return this.handleValidIncomingMessage_(message);
|
| + } else {
|
| + internal.reportValidationError(err);
|
| + return false;
|
| + }
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.handleValidIncomingMessage_ = function(
|
| + message) {
|
| + if (internal.isTestingMode()) {
|
| + return true;
|
| + }
|
| +
|
| + if (this.encounteredError_) {
|
| + return false;
|
| + }
|
| +
|
| + var ok = false;
|
| +
|
| + if (message.expectsResponse()) {
|
| + if (internal.isInterfaceControlMessage(message) &&
|
| + this.controlMessageHandler_) {
|
| + ok = this.controlMessageHandler_.acceptWithResponder(message, this);
|
| + } else if (this.incomingReceiver_) {
|
| + ok = this.incomingReceiver_.acceptWithResponder(message, this);
|
| + }
|
| + } else if (message.isResponse()) {
|
| + var reader = new internal.MessageReader(message);
|
| + var requestID = reader.requestID;
|
| + var completer = this.completers_.get(requestID);
|
| + if (completer) {
|
| + this.completers_.delete(requestID);
|
| + completer.resolve(message);
|
| + ok = true;
|
| + } else {
|
| + console.log("Unexpected response with request ID: " + requestID);
|
| + }
|
| + } else {
|
| + if (internal.isInterfaceControlMessage(message) &&
|
| + this.controlMessageHandler_) {
|
| + ok = this.controlMessageHandler_.accept(message);
|
| + } else if (this.incomingReceiver_) {
|
| + ok = this.incomingReceiver_.accept(message);
|
| + }
|
| + }
|
| + return ok;
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.notifyError = function(reason) {
|
| + if (this.encounteredError_) {
|
| + return;
|
| + }
|
| + this.encounteredError_ = true;
|
| +
|
| + this.completers_.forEach(function(value) {
|
| + value.reject();
|
| + });
|
| + this.completers_.clear(); // Drop any responders.
|
| +
|
| + if (this.connectionErrorHandler_) {
|
| + this.connectionErrorHandler_(reason);
|
| + }
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.queryVersion = function() {
|
| + return this.controlMessageProxy_.queryVersion();
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.requireVersion = function(version) {
|
| + this.controlMessageProxy_.requireVersion(version);
|
| + };
|
| +
|
| + InterfaceEndpointClient.prototype.getEncounteredError = function() {
|
| + return this.encounteredError_;
|
| + };
|
| +
|
| + internal.InterfaceEndpointClient = InterfaceEndpointClient;
|
| +})();
|
| +// Copyright 2017 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + var AssociationEvent = {
|
| + // The interface has been associated with a message pipe.
|
| + ASSOCIATED: 'associated',
|
| + // The peer of this object has been closed before association.
|
| + PEER_CLOSED_BEFORE_ASSOCIATION: 'peer_closed_before_association'
|
| + };
|
| +
|
| + function State(interfaceId, associatedGroupController) {
|
| + if (interfaceId === undefined) {
|
| + interfaceId = internal.kInvalidInterfaceId;
|
| + }
|
| +
|
| + this.interfaceId = interfaceId;
|
| + this.associatedGroupController = associatedGroupController;
|
| + this.pendingAssociation = false;
|
| + this.disconnectReason = null;
|
| + this.peerState_ = null;
|
| + this.associationEventHandler_ = null;
|
| + }
|
| +
|
| + State.prototype.initPendingState = function(peer) {
|
| + this.pendingAssociation = true;
|
| + this.peerState_ = peer;
|
| + };
|
| +
|
| + State.prototype.isValid = function() {
|
| + return this.pendingAssociation ||
|
| + internal.isValidInterfaceId(this.interfaceId);
|
| + };
|
| +
|
| + State.prototype.close = function(disconnectReason) {
|
| + var cachedGroupController;
|
| + var cachedPeerState;
|
| + var cachedId = internal.kInvalidInterfaceId;
|
| +
|
| + if (!this.pendingAssociation) {
|
| + if (internal.isValidInterfaceId(this.interfaceId)) {
|
| + cachedGroupController = this.associatedGroupController;
|
| + this.associatedGroupController = null;
|
| + cachedId = this.interfaceId;
|
| + this.interfaceId = internal.kInvalidInterfaceId;
|
| + }
|
| + } else {
|
| + this.pendingAssociation = false;
|
| + cachedPeerState = this.peerState_;
|
| + this.peerState_ = null;
|
| + }
|
| +
|
| + if (cachedGroupController) {
|
| + cachedGroupController.closeEndpointHandle(cachedId,
|
| + disconnectReason);
|
| + } else if (cachedPeerState) {
|
| + cachedPeerState.onPeerClosedBeforeAssociation(disconnectReason);
|
| + }
|
| + };
|
| +
|
| + State.prototype.runAssociationEventHandler = function(associationEvent) {
|
| + if (this.associationEventHandler_) {
|
| + var handler = this.associationEventHandler_;
|
| + this.associationEventHandler_ = null;
|
| + handler(associationEvent);
|
| + }
|
| + };
|
| +
|
| + State.prototype.setAssociationEventHandler = function(handler) {
|
| + if (!this.pendingAssociation &&
|
| + !internal.isValidInterfaceId(this.interfaceId)) {
|
| + return;
|
| + }
|
| +
|
| + if (!handler) {
|
| + this.associationEventHandler_ = null;
|
| + return;
|
| + }
|
| +
|
| + this.associationEventHandler_ = handler;
|
| + if (!this.pendingAssociation) {
|
| + setTimeout(this.runAssociationEventHandler.bind(this,
|
| + AssociationEvent.ASSOCIATED), 0);
|
| + } else if (!this.peerState_) {
|
| + setTimeout(this.runAssociationEventHandler.bind(this,
|
| + AssociationEvent.PEER_CLOSED_BEFORE_ASSOCIATION), 0);
|
| + }
|
| + };
|
| +
|
| + State.prototype.notifyAssociation = function(interfaceId,
|
| + peerGroupController) {
|
| + var cachedPeerState = this.peerState_;
|
| + this.peerState_ = null;
|
| +
|
| + this.pendingAssociation = false;
|
| +
|
| + if (cachedPeerState) {
|
| + cachedPeerState.onAssociated(interfaceId, peerGroupController);
|
| + return true;
|
| + }
|
| + return false;
|
| + };
|
| +
|
| + State.prototype.onAssociated = function(interfaceId,
|
| + associatedGroupController) {
|
| + if (!this.pendingAssociation) {
|
| + return;
|
| + }
|
| +
|
| + this.pendingAssociation = false;
|
| + this.peerState_ = null;
|
| + this.interfaceId = interfaceId;
|
| + this.associatedGroupController = associatedGroupController;
|
| + this.runAssociationEventHandler(AssociationEvent.ASSOCIATED);
|
| + };
|
| +
|
| + State.prototype.onPeerClosedBeforeAssociation = function(disconnectReason) {
|
| + if (!this.pendingAssociation) {
|
| + return;
|
| + }
|
| +
|
| + this.peerState_ = null;
|
| + this.disconnectReason = disconnectReason;
|
| +
|
| + this.runAssociationEventHandler(
|
| + AssociationEvent.PEER_CLOSED_BEFORE_ASSOCIATION);
|
| + };
|
| +
|
| + function createPairPendingAssociation() {
|
| + var handle0 = new InterfaceEndpointHandle();
|
| + var handle1 = new InterfaceEndpointHandle();
|
| + handle0.state_.initPendingState(handle1.state_);
|
| + handle1.state_.initPendingState(handle0.state_);
|
| + return {handle0: handle0, handle1: handle1};
|
| + }
|
| +
|
| + function InterfaceEndpointHandle(interfaceId, associatedGroupController) {
|
| + this.state_ = new State(interfaceId, associatedGroupController);
|
| + }
|
| +
|
| + InterfaceEndpointHandle.prototype.isValid = function() {
|
| + return this.state_.isValid();
|
| + };
|
| +
|
| + InterfaceEndpointHandle.prototype.pendingAssociation = function() {
|
| + return this.state_.pendingAssociation;
|
| + };
|
| +
|
| + InterfaceEndpointHandle.prototype.id = function() {
|
| + return this.state_.interfaceId;
|
| + };
|
| +
|
| + InterfaceEndpointHandle.prototype.groupController = function() {
|
| + return this.state_.associatedGroupController;
|
| + };
|
| +
|
| + InterfaceEndpointHandle.prototype.disconnectReason = function() {
|
| + return this.state_.disconnectReason;
|
| + };
|
| +
|
| + InterfaceEndpointHandle.prototype.setAssociationEventHandler = function(
|
| + handler) {
|
| + this.state_.setAssociationEventHandler(handler);
|
| + };
|
| +
|
| + InterfaceEndpointHandle.prototype.notifyAssociation = function(interfaceId,
|
| + peerGroupController) {
|
| + return this.state_.notifyAssociation(interfaceId, peerGroupController);
|
| + };
|
| +
|
| + InterfaceEndpointHandle.prototype.reset = function(reason) {
|
| + this.state_.close(reason);
|
| + this.state_ = new State();
|
| + };
|
| +
|
| + internal.AssociationEvent = AssociationEvent;
|
| + internal.InterfaceEndpointHandle = InterfaceEndpointHandle;
|
| + internal.createPairPendingAssociation = createPairPendingAssociation;
|
| +})();
|
| +// Copyright 2017 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + function validateControlRequestWithoutResponse(message) {
|
| + var messageValidator = new internal.Validator(message);
|
| + var error = messageValidator.validateMessageIsRequestWithoutResponse();
|
| + if (error != internal.validationError.NONE) {
|
| + throw error;
|
| + }
|
| +
|
| + if (message.getName() != mojo.pipeControl2.kRunOrClosePipeMessageId) {
|
| + throw new Error("Control message name is not kRunOrClosePipeMessageId");
|
| + }
|
| +
|
| + // Validate payload.
|
| + error = mojo.pipeControl2.RunOrClosePipeMessageParams.validate(
|
| + messageValidator, message.getHeaderNumBytes());
|
| + if (error != internal.validationError.NONE) {
|
| + throw error;
|
| + }
|
| + }
|
| +
|
| + function runOrClosePipe(message, delegate) {
|
| + var reader = new internal.MessageReader(message);
|
| + var runOrClosePipeMessageParams = reader.decodeStruct(
|
| + mojo.pipeControl2.RunOrClosePipeMessageParams);
|
| + var event = runOrClosePipeMessageParams.input
|
| + .peerAssociatedEndpointClosedEvent;
|
| + return delegate.onPeerAssociatedEndpointClosed(event.id,
|
| + event.disconnectReason);
|
| + }
|
| +
|
| + function isPipeControlMessage(message) {
|
| + return !internal.isValidInterfaceId(message.getInterfaceId());
|
| + }
|
| +
|
| + function PipeControlMessageHandler(delegate) {
|
| + this.delegate_ = delegate;
|
| + }
|
| +
|
| + PipeControlMessageHandler.prototype.accept = function(message) {
|
| + validateControlRequestWithoutResponse(message);
|
| + return runOrClosePipe(message, this.delegate_);
|
| + };
|
| +
|
| + internal.PipeControlMessageHandler = PipeControlMessageHandler;
|
| + internal.isPipeControlMessage = isPipeControlMessage;
|
| +})();
|
| +// Copyright 2017 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + function constructRunOrClosePipeMessage(runOrClosePipeInput) {
|
| + var runOrClosePipeMessageParams = new
|
| + mojo.pipeControl2.RunOrClosePipeMessageParams();
|
| + runOrClosePipeMessageParams.input = runOrClosePipeInput;
|
| +
|
| + var messageName = mojo.pipeControl2.kRunOrClosePipeMessageId;
|
| + var payloadSize =
|
| + mojo.pipeControl2.RunOrClosePipeMessageParams.encodedSize;
|
| +
|
| + var builder = new internal.MessageV0Builder(messageName, payloadSize);
|
| + builder.encodeStruct(mojo.pipeControl2.RunOrClosePipeMessageParams,
|
| + runOrClosePipeMessageParams);
|
| + var message = builder.finish();
|
| + message.setInterfaceId(internal.kInvalidInterfaceId);
|
| + return message;
|
| + }
|
| +
|
| + function PipeControlMessageProxy(receiver) {
|
| + this.receiver_ = receiver;
|
| + }
|
| +
|
| + PipeControlMessageProxy.prototype.notifyPeerEndpointClosed = function(
|
| + interfaceId, reason) {
|
| + var message = this.constructPeerEndpointClosedMessage(interfaceId, reason);
|
| + this.receiver_.accept(message);
|
| + };
|
| +
|
| + PipeControlMessageProxy.prototype.constructPeerEndpointClosedMessage =
|
| + function(interfaceId, reason) {
|
| + var event = new mojo.pipeControl2.PeerAssociatedEndpointClosedEvent();
|
| + event.id = interfaceId;
|
| + if (reason) {
|
| + event.disconnectReason = new mojo.pipeControl2.DisconnectReason({
|
| + customReason: reason.customReason,
|
| + description: reason.description});
|
| + }
|
| + var runOrClosePipeInput = new mojo.pipeControl2.RunOrClosePipeInput();
|
| + runOrClosePipeInput.peerAssociatedEndpointClosedEvent = event;
|
| + return constructRunOrClosePipeMessage(runOrClosePipeInput);
|
| + };
|
| +
|
| + internal.PipeControlMessageProxy = PipeControlMessageProxy;
|
| +})();
|
| +// 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + /**
|
| + * The state of |endpoint|. If both the endpoint and its peer have been
|
| + * closed, removes it from |endpoints_|.
|
| + * @enum {string}
|
| + */
|
| + var EndpointStateUpdateType = {
|
| + ENDPOINT_CLOSED: 'endpoint_closed',
|
| + PEER_ENDPOINT_CLOSED: 'peer_endpoint_closed'
|
| + };
|
| +
|
| + function check(condition, output) {
|
| + if (!condition) {
|
| + // testharness.js does not rethrow errors so the error stack needs to be
|
| + // included as a string in the error we throw for debugging layout tests.
|
| + throw new Error((new Error()).stack);
|
| + }
|
| + }
|
| +
|
| + function InterfaceEndpoint(router, interfaceId) {
|
| + this.router_ = router;
|
| + this.id = interfaceId;
|
| + this.closed = false;
|
| + this.peerClosed = false;
|
| + this.handleCreated = false;
|
| + this.disconnectReason = null;
|
| + this.client = null;
|
| + }
|
| +
|
| + InterfaceEndpoint.prototype.sendMessage = function(message) {
|
| + message.setInterfaceId(this.id);
|
| + return this.router_.connector_.accept(message);
|
| + };
|
| +
|
| + function Router(handle, setInterfaceIdNamespaceBit) {
|
| + if (!(handle instanceof MojoHandle)) {
|
| + throw new Error("Router constructor: Not a handle");
|
| + }
|
| + if (setInterfaceIdNamespaceBit === undefined) {
|
| + setInterfaceIdNamespaceBit = false;
|
| + }
|
| +
|
| + this.connector_ = new internal.Connector(handle);
|
| +
|
| + this.connector_.setIncomingReceiver({
|
| + accept: this.accept.bind(this),
|
| + });
|
| + this.connector_.setErrorHandler({
|
| + onError: this.onPipeConnectionError.bind(this),
|
| + });
|
| +
|
| + this.setInterfaceIdNamespaceBit_ = setInterfaceIdNamespaceBit;
|
| + // |cachedMessageData| caches infomation about a message, so it can be
|
| + // processed later if a client is not yet attached to the target endpoint.
|
| + this.cachedMessageData = null;
|
| + this.controlMessageHandler_ = new internal.PipeControlMessageHandler(this);
|
| + this.controlMessageProxy_ =
|
| + new internal.PipeControlMessageProxy(this.connector_);
|
| + this.nextInterfaceIdValue_ = 1;
|
| + this.encounteredError_ = false;
|
| + this.endpoints_ = new Map();
|
| + }
|
| +
|
| + Router.prototype.associateInterface = function(handleToSend) {
|
| + if (!handleToSend.pendingAssociation()) {
|
| + return internal.kInvalidInterfaceId;
|
| + }
|
| +
|
| + var id = 0;
|
| + do {
|
| + if (this.nextInterfaceIdValue_ >= internal.kInterfaceIdNamespaceMask) {
|
| + this.nextInterfaceIdValue_ = 1;
|
| + }
|
| + id = this.nextInterfaceIdValue_++;
|
| + if (this.setInterfaceIdNamespaceBit_) {
|
| + id += internal.kInterfaceIdNamespaceMask;
|
| + }
|
| + } while (this.endpoints_.has(id));
|
| +
|
| + var endpoint = new InterfaceEndpoint(this, id);
|
| + this.endpoints_.set(id, endpoint);
|
| + if (this.encounteredError_) {
|
| + this.updateEndpointStateMayRemove(endpoint,
|
| + EndpointStateUpdateType.PEER_ENDPOINT_CLOSED);
|
| + }
|
| + endpoint.handleCreated = true;
|
| +
|
| + if (!handleToSend.notifyAssociation(id, this)) {
|
| + // The peer handle of |handleToSend|, which is supposed to join this
|
| + // associated group, has been closed.
|
| + this.updateEndpointStateMayRemove(endpoint,
|
| + EndpointStateUpdateType.ENDPOINT_CLOSED);
|
| +
|
| + pipeControlMessageproxy.notifyPeerEndpointClosed(id,
|
| + handleToSend.disconnectReason());
|
| + }
|
| +
|
| + return id;
|
| + };
|
| +
|
| + Router.prototype.attachEndpointClient = function(
|
| + interfaceEndpointHandle, interfaceEndpointClient) {
|
| + check(internal.isValidInterfaceId(interfaceEndpointHandle.id()));
|
| + check(interfaceEndpointClient);
|
| +
|
| + var endpoint = this.endpoints_.get(interfaceEndpointHandle.id());
|
| + check(endpoint);
|
| + check(!endpoint.client);
|
| + check(!endpoint.closed);
|
| + endpoint.client = interfaceEndpointClient;
|
| +
|
| + if (endpoint.peerClosed) {
|
| + setTimeout(endpoint.client.notifyError.bind(endpoint.client), 0);
|
| + }
|
| +
|
| + if (this.cachedMessageData && interfaceEndpointHandle.id() ===
|
| + this.cachedMessageData.message.getInterfaceId()) {
|
| + setTimeout((function() {
|
| + if (!this.cachedMessageData) {
|
| + return;
|
| + }
|
| +
|
| + var targetEndpoint = this.endpoints_.get(
|
| + this.cachedMessageData.message.getInterfaceId());
|
| + // Check that the target endpoint's client still exists.
|
| + if (targetEndpoint && targetEndpoint.client) {
|
| + var message = this.cachedMessageData.message;
|
| + var messageValidator = this.cachedMessageData.messageValidator;
|
| + this.cachedMessageData = null;
|
| + this.connector_.resumeIncomingMethodCallProcessing();
|
| + var ok = endpoint.client.handleIncomingMessage(message,
|
| + messageValidator);
|
| +
|
| + // Handle invalid cached incoming message.
|
| + if (!internal.isTestingMode() && !ok) {
|
| + this.connector_.handleError(true, true);
|
| + }
|
| + }
|
| + }).bind(this), 0);
|
| + }
|
| +
|
| + return endpoint;
|
| + };
|
| +
|
| + Router.prototype.detachEndpointClient = function(
|
| + interfaceEndpointHandle) {
|
| + check(internal.isValidInterfaceId(interfaceEndpointHandle.id()));
|
| + var endpoint = this.endpoints_.get(interfaceEndpointHandle.id());
|
| + check(endpoint);
|
| + check(endpoint.client);
|
| + check(!endpoint.closed);
|
| +
|
| + endpoint.client = null;
|
| + };
|
| +
|
| + Router.prototype.createLocalEndpointHandle = function(
|
| + interfaceId) {
|
| + if (!internal.isValidInterfaceId(interfaceId)) {
|
| + return new internal.InterfaceEndpointHandle();
|
| + }
|
| +
|
| + var endpoint = this.endpoints_.get(interfaceId);
|
| +
|
| + if (!endpoint) {
|
| + endpoint = new InterfaceEndpoint(this, interfaceId);
|
| + this.endpoints_.set(interfaceId, endpoint);
|
| +
|
| + check(!endpoint.handleCreated);
|
| +
|
| + if (this.encounteredError_) {
|
| + this.updateEndpointStateMayRemove(endpoint,
|
| + EndpointStateUpdateType.PEER_ENDPOINT_CLOSED);
|
| + }
|
| + } else {
|
| + // If the endpoint already exist, it is because we have received a
|
| + // notification that the peer endpoint has closed.
|
| + check(!endpoint.closed);
|
| + check(endpoint.peerClosed);
|
| +
|
| + if (endpoint.handleCreated) {
|
| + return new internal.InterfaceEndpointHandle();
|
| + }
|
| + }
|
| +
|
| + endpoint.handleCreated = true;
|
| + return new internal.InterfaceEndpointHandle(interfaceId, this);
|
| + };
|
| +
|
| + Router.prototype.accept = function(message) {
|
| + var messageValidator = new internal.Validator(message);
|
| + var err = messageValidator.validateMessageHeader();
|
| +
|
| + var ok = false;
|
| + if (err !== internal.validationError.NONE) {
|
| + internal.reportValidationError(err);
|
| + } else if (message.deserializeAssociatedEndpointHandles(this)) {
|
| + if (internal.isPipeControlMessage(message)) {
|
| + ok = this.controlMessageHandler_.accept(message);
|
| + } else {
|
| + var interfaceId = message.getInterfaceId();
|
| + var endpoint = this.endpoints_.get(interfaceId);
|
| + if (!endpoint || endpoint.closed) {
|
| + return true;
|
| + }
|
| +
|
| + if (!endpoint.client) {
|
| + // We need to wait until a client is attached in order to dispatch
|
| + // further messages.
|
| + this.cachedMessageData = {message: message,
|
| + messageValidator: messageValidator};
|
| + this.connector_.pauseIncomingMethodCallProcessing();
|
| + return true;
|
| + }
|
| + ok = endpoint.client.handleIncomingMessage(message, messageValidator);
|
| + }
|
| + }
|
| + return ok;
|
| + };
|
| +
|
| + Router.prototype.close = function() {
|
| + this.connector_.close();
|
| + // Closing the message pipe won't trigger connection error handler.
|
| + // Explicitly call onPipeConnectionError() so that associated endpoints
|
| + // will get notified.
|
| + this.onPipeConnectionError();
|
| + };
|
| +
|
| + Router.prototype.onPeerAssociatedEndpointClosed = function(interfaceId,
|
| + reason) {
|
| + check(!internal.isMasterInterfaceId(interfaceId) || reason);
|
| +
|
| + var endpoint = this.endpoints_.get(interfaceId);
|
| + if (!endpoint) {
|
| + endpoint = new InterfaceEndpoint(this, interfaceId);
|
| + this.endpoints_.set(interfaceId, endpoint);
|
| + }
|
| +
|
| + if (reason) {
|
| + endpoint.disconnectReason = reason;
|
| + }
|
| +
|
| + if (!endpoint.peerClosed) {
|
| + if (endpoint.client) {
|
| + setTimeout(endpoint.client.notifyError.bind(endpoint.client, reason),
|
| + 0);
|
| + }
|
| + this.updateEndpointStateMayRemove(endpoint,
|
| + EndpointStateUpdateType.PEER_ENDPOINT_CLOSED);
|
| + }
|
| + return true;
|
| + };
|
| +
|
| + Router.prototype.onPipeConnectionError = function() {
|
| + this.encounteredError_ = true;
|
| +
|
| + for (var endpoint of this.endpoints_.values()) {
|
| + if (endpoint.client) {
|
| + setTimeout(
|
| + endpoint.client.notifyError.bind(
|
| + endpoint.client, endpoint.disconnectReason),
|
| + 0);
|
| + }
|
| + this.updateEndpointStateMayRemove(endpoint,
|
| + EndpointStateUpdateType.PEER_ENDPOINT_CLOSED);
|
| + }
|
| + };
|
| +
|
| + Router.prototype.closeEndpointHandle = function(interfaceId, reason) {
|
| + if (!internal.isValidInterfaceId(interfaceId)) {
|
| + return;
|
| + }
|
| + var endpoint = this.endpoints_.get(interfaceId);
|
| + check(endpoint);
|
| + check(!endpoint.client);
|
| + check(!endpoint.closed);
|
| +
|
| + this.updateEndpointStateMayRemove(endpoint,
|
| + EndpointStateUpdateType.ENDPOINT_CLOSED);
|
| +
|
| + if (!internal.isMasterInterfaceId(interfaceId) || reason) {
|
| + this.controlMessageProxy_.notifyPeerEndpointClosed(interfaceId, reason);
|
| + }
|
| +
|
| + if (this.cachedMessageData && interfaceId ===
|
| + this.cachedMessageData.message.getInterfaceId()) {
|
| + this.cachedMessageData = null;
|
| + this.connector_.resumeIncomingMethodCallProcessing();
|
| + }
|
| + };
|
| +
|
| + Router.prototype.updateEndpointStateMayRemove = function(endpoint,
|
| + endpointStateUpdateType) {
|
| + if (endpointStateUpdateType === EndpointStateUpdateType.ENDPOINT_CLOSED) {
|
| + endpoint.closed = true;
|
| + } else {
|
| + endpoint.peerClosed = true;
|
| + }
|
| + if (endpoint.closed && endpoint.peerClosed) {
|
| + this.endpoints_.delete(endpoint.id);
|
| + }
|
| + };
|
| +
|
| + internal.Router = Router;
|
| +})();
|
| +// 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.
|
| +
|
| +/**
|
| + * Defines functions for translating between JavaScript strings and UTF8 strings
|
| + * stored in ArrayBuffers. There is much room for optimization in this code if
|
| + * it proves necessary.
|
| + */
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + /**
|
| + * Decodes the UTF8 string from the given buffer.
|
| + * @param {ArrayBufferView} buffer The buffer containing UTF8 string data.
|
| + * @return {string} The corresponding JavaScript string.
|
| + */
|
| + function decodeUtf8String(buffer) {
|
| + return decodeURIComponent(escape(String.fromCharCode.apply(null, buffer)));
|
| + }
|
| +
|
| + /**
|
| + * Encodes the given JavaScript string into UTF8.
|
| + * @param {string} str The string to encode.
|
| + * @param {ArrayBufferView} outputBuffer The buffer to contain the result.
|
| + * Should be pre-allocated to hold enough space. Use |utf8Length| to determine
|
| + * how much space is required.
|
| + * @return {number} The number of bytes written to |outputBuffer|.
|
| + */
|
| + function encodeUtf8String(str, outputBuffer) {
|
| + var utf8String = unescape(encodeURIComponent(str));
|
| + if (outputBuffer.length < utf8String.length)
|
| + throw new Error("Buffer too small for encodeUtf8String");
|
| + for (var i = 0; i < outputBuffer.length && i < utf8String.length; i++)
|
| + outputBuffer[i] = utf8String.charCodeAt(i);
|
| + return i;
|
| + }
|
| +
|
| + /**
|
| + * Returns the number of bytes that a UTF8 encoding of the JavaScript string
|
| + * |str| would occupy.
|
| + */
|
| + function utf8Length(str) {
|
| + var utf8String = unescape(encodeURIComponent(str));
|
| + return utf8String.length;
|
| + }
|
| +
|
| + internal.decodeUtf8String = decodeUtf8String;
|
| + internal.encodeUtf8String = encodeUtf8String;
|
| + internal.utf8Length = utf8Length;
|
| +})();
|
| +// 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.
|
| +
|
| +(function() {
|
| + var internal = mojo.internal;
|
| +
|
| + var validationError = {
|
| + NONE: 'VALIDATION_ERROR_NONE',
|
| + MISALIGNED_OBJECT: 'VALIDATION_ERROR_MISALIGNED_OBJECT',
|
| + ILLEGAL_MEMORY_RANGE: 'VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE',
|
| + UNEXPECTED_STRUCT_HEADER: 'VALIDATION_ERROR_UNEXPECTED_STRUCT_HEADER',
|
| + UNEXPECTED_ARRAY_HEADER: 'VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER',
|
| + ILLEGAL_HANDLE: 'VALIDATION_ERROR_ILLEGAL_HANDLE',
|
| + UNEXPECTED_INVALID_HANDLE: 'VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE',
|
| + ILLEGAL_POINTER: 'VALIDATION_ERROR_ILLEGAL_POINTER',
|
| + UNEXPECTED_NULL_POINTER: 'VALIDATION_ERROR_UNEXPECTED_NULL_POINTER',
|
| + ILLEGAL_INTERFACE_ID: 'VALIDATION_ERROR_ILLEGAL_INTERFACE_ID',
|
| + UNEXPECTED_INVALID_INTERFACE_ID:
|
| + 'VALIDATION_ERROR_UNEXPECTED_INVALID_INTERFACE_ID',
|
| + MESSAGE_HEADER_INVALID_FLAGS:
|
| + 'VALIDATION_ERROR_MESSAGE_HEADER_INVALID_FLAGS',
|
| + MESSAGE_HEADER_MISSING_REQUEST_ID:
|
| + 'VALIDATION_ERROR_MESSAGE_HEADER_MISSING_REQUEST_ID',
|
| + DIFFERENT_SIZED_ARRAYS_IN_MAP:
|
| + 'VALIDATION_ERROR_DIFFERENT_SIZED_ARRAYS_IN_MAP',
|
| + INVALID_UNION_SIZE: 'VALIDATION_ERROR_INVALID_UNION_SIZE',
|
| + UNEXPECTED_NULL_UNION: 'VALIDATION_ERROR_UNEXPECTED_NULL_UNION',
|
| + UNKNOWN_ENUM_VALUE: 'VALIDATION_ERROR_UNKNOWN_ENUM_VALUE',
|
| + };
|
| +
|
| + var NULL_MOJO_POINTER = "NULL_MOJO_POINTER";
|
| + var gValidationErrorObserver = null;
|
| +
|
| + function reportValidationError(error) {
|
| + if (gValidationErrorObserver) {
|
| + gValidationErrorObserver.lastError = error;
|
| + } else {
|
| + console.warn('Invalid message: ' + error);
|
| + }
|
| + }
|
| +
|
| + var ValidationErrorObserverForTesting = (function() {
|
| + function Observer() {
|
| + this.lastError = validationError.NONE;
|
| + }
|
| +
|
| + Observer.prototype.reset = function() {
|
| + this.lastError = validationError.NONE;
|
| + };
|
| +
|
| + return {
|
| + getInstance: function() {
|
| + if (!gValidationErrorObserver) {
|
| + gValidationErrorObserver = new Observer();
|
| + }
|
| + return gValidationErrorObserver;
|
| + }
|
| + };
|
| + })();
|
| +
|
| + function isTestingMode() {
|
| + return Boolean(gValidationErrorObserver);
|
| + }
|
| +
|
| + function clearTestingMode() {
|
| + gValidationErrorObserver = null;
|
| + }
|
| +
|
| + function isEnumClass(cls) {
|
| + return cls instanceof internal.Enum;
|
| + }
|
| +
|
| + function isStringClass(cls) {
|
| + return cls === internal.String || cls === internal.NullableString;
|
| + }
|
| +
|
| + function isHandleClass(cls) {
|
| + return cls === internal.Handle || cls === internal.NullableHandle;
|
| + }
|
| +
|
| + function isInterfaceClass(cls) {
|
| + return cls instanceof internal.Interface;
|
| + }
|
| +
|
| + function isInterfaceRequestClass(cls) {
|
| + return cls === internal.InterfaceRequest ||
|
| + cls === internal.NullableInterfaceRequest;
|
| + }
|
| +
|
| + function isAssociatedInterfaceClass(cls) {
|
| + return cls === internal.AssociatedInterfacePtrInfo ||
|
| + cls === internal.NullableAssociatedInterfacePtrInfo;
|
| + }
|
| +
|
| + function isAssociatedInterfaceRequestClass(cls) {
|
| + return cls === internal.AssociatedInterfaceRequest ||
|
| + cls === internal.NullableAssociatedInterfaceRequest;
|
| + }
|
| +
|
| + function isNullable(type) {
|
| + return type === internal.NullableString ||
|
| + type === internal.NullableHandle ||
|
| + type === internal.NullableAssociatedInterfacePtrInfo ||
|
| + type === internal.NullableAssociatedInterfaceRequest ||
|
| + type === internal.NullableInterface ||
|
| + type === internal.NullableInterfaceRequest ||
|
| + type instanceof internal.NullableArrayOf ||
|
| + type instanceof internal.NullablePointerTo;
|
| + }
|
| +
|
| + function Validator(message) {
|
| + this.message = message;
|
| + this.offset = 0;
|
| + this.handleIndex = 0;
|
| + this.associatedEndpointHandleIndex = 0;
|
| + this.payloadInterfaceIds = null;
|
| + this.offsetLimit = this.message.buffer.byteLength;
|
| + }
|
| +
|
| + Object.defineProperty(Validator.prototype, "handleIndexLimit", {
|
| + get: function() { return this.message.handles.length; }
|
| + });
|
| +
|
| + Object.defineProperty(Validator.prototype, "associatedHandleIndexLimit", {
|
| + get: function() {
|
| + return this.payloadInterfaceIds ? this.payloadInterfaceIds.length : 0;
|
| + }
|
| + });
|
| +
|
| + // True if we can safely allocate a block of bytes from start to
|
| + // to start + numBytes.
|
| + Validator.prototype.isValidRange = function(start, numBytes) {
|
| + // Only positive JavaScript integers that are less than 2^53
|
| + // (Number.MAX_SAFE_INTEGER) can be represented exactly.
|
| + if (start < this.offset || numBytes <= 0 ||
|
| + !Number.isSafeInteger(start) ||
|
| + !Number.isSafeInteger(numBytes))
|
| + return false;
|
| +
|
| + var newOffset = start + numBytes;
|
| + if (!Number.isSafeInteger(newOffset) || newOffset > this.offsetLimit)
|
| + return false;
|
| +
|
| + return true;
|
| + };
|
| +
|
| + Validator.prototype.claimRange = function(start, numBytes) {
|
| + if (this.isValidRange(start, numBytes)) {
|
| + this.offset = start + numBytes;
|
| + return true;
|
| + }
|
| + return false;
|
| + };
|
| +
|
| + Validator.prototype.claimHandle = function(index) {
|
| + if (index === internal.kEncodedInvalidHandleValue)
|
| + return true;
|
| +
|
| + if (index < this.handleIndex || index >= this.handleIndexLimit)
|
| + return false;
|
| +
|
| + // This is safe because handle indices are uint32.
|
| + this.handleIndex = index + 1;
|
| + return true;
|
| + };
|
| +
|
| + Validator.prototype.claimAssociatedEndpointHandle = function(index) {
|
| + if (index === internal.kEncodedInvalidHandleValue) {
|
| + return true;
|
| + }
|
| +
|
| + if (index < this.associatedEndpointHandleIndex ||
|
| + index >= this.associatedHandleIndexLimit) {
|
| + return false;
|
| + }
|
| +
|
| + // This is safe because handle indices are uint32.
|
| + this.associatedEndpointHandleIndex = index + 1;
|
| + return true;
|
| + };
|
| +
|
| + Validator.prototype.validateEnum = function(offset, enumClass) {
|
| + // Note: Assumes that enums are always 32 bits! But this matches
|
| + // mojom::generate::pack::PackedField::GetSizeForKind, so it should be okay.
|
| + var value = this.message.buffer.getInt32(offset);
|
| + return enumClass.validate(value);
|
| + }
|
| +
|
| + Validator.prototype.validateHandle = function(offset, nullable) {
|
| + var index = this.message.buffer.getUint32(offset);
|
| +
|
| + if (index === internal.kEncodedInvalidHandleValue)
|
| + return nullable ?
|
| + validationError.NONE : validationError.UNEXPECTED_INVALID_HANDLE;
|
| +
|
| + if (!this.claimHandle(index))
|
| + return validationError.ILLEGAL_HANDLE;
|
| +
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateAssociatedEndpointHandle = function(offset,
|
| + nullable) {
|
| + var index = this.message.buffer.getUint32(offset);
|
| +
|
| + if (index === internal.kEncodedInvalidHandleValue) {
|
| + return nullable ? validationError.NONE :
|
| + validationError.UNEXPECTED_INVALID_INTERFACE_ID;
|
| + }
|
| +
|
| + if (!this.claimAssociatedEndpointHandle(index)) {
|
| + return validationError.ILLEGAL_INTERFACE_ID;
|
| + }
|
| +
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateInterface = function(offset, nullable) {
|
| + return this.validateHandle(offset, nullable);
|
| + };
|
| +
|
| + Validator.prototype.validateInterfaceRequest = function(offset, nullable) {
|
| + return this.validateHandle(offset, nullable);
|
| + };
|
| +
|
| + Validator.prototype.validateAssociatedInterface = function(offset,
|
| + nullable) {
|
| + return this.validateAssociatedEndpointHandle(offset, nullable);
|
| + };
|
| +
|
| + Validator.prototype.validateAssociatedInterfaceRequest = function(
|
| + offset, nullable) {
|
| + return this.validateAssociatedEndpointHandle(offset, nullable);
|
| + };
|
| +
|
| + Validator.prototype.validateStructHeader = function(offset, minNumBytes) {
|
| + if (!internal.isAligned(offset))
|
| + return validationError.MISALIGNED_OBJECT;
|
| +
|
| + if (!this.isValidRange(offset, internal.kStructHeaderSize))
|
| + return validationError.ILLEGAL_MEMORY_RANGE;
|
| +
|
| + var numBytes = this.message.buffer.getUint32(offset);
|
| +
|
| + if (numBytes < minNumBytes)
|
| + return validationError.UNEXPECTED_STRUCT_HEADER;
|
| +
|
| + if (!this.claimRange(offset, numBytes))
|
| + return validationError.ILLEGAL_MEMORY_RANGE;
|
| +
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateStructVersion = function(offset, versionSizes) {
|
| + var numBytes = this.message.buffer.getUint32(offset);
|
| + var version = this.message.buffer.getUint32(offset + 4);
|
| +
|
| + if (version <= versionSizes[versionSizes.length - 1].version) {
|
| + // Scan in reverse order to optimize for more recent versionSizes.
|
| + for (var i = versionSizes.length - 1; i >= 0; --i) {
|
| + if (version >= versionSizes[i].version) {
|
| + if (numBytes == versionSizes[i].numBytes)
|
| + break;
|
| + return validationError.UNEXPECTED_STRUCT_HEADER;
|
| + }
|
| + }
|
| + } else if (numBytes < versionSizes[versionSizes.length-1].numBytes) {
|
| + return validationError.UNEXPECTED_STRUCT_HEADER;
|
| + }
|
| +
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.isFieldInStructVersion = function(offset, fieldVersion) {
|
| + var structVersion = this.message.buffer.getUint32(offset + 4);
|
| + return fieldVersion <= structVersion;
|
| + };
|
| +
|
| + Validator.prototype.validateMessageHeader = function() {
|
| + var err = this.validateStructHeader(0, internal.kMessageV0HeaderSize);
|
| + if (err != validationError.NONE) {
|
| + return err;
|
| + }
|
| +
|
| + var numBytes = this.message.getHeaderNumBytes();
|
| + var version = this.message.getHeaderVersion();
|
| +
|
| + var validVersionAndNumBytes =
|
| + (version == 0 && numBytes == internal.kMessageV0HeaderSize) ||
|
| + (version == 1 && numBytes == internal.kMessageV1HeaderSize) ||
|
| + (version == 2 && numBytes == internal.kMessageV2HeaderSize) ||
|
| + (version > 2 && numBytes >= internal.kMessageV2HeaderSize);
|
| +
|
| + if (!validVersionAndNumBytes) {
|
| + return validationError.UNEXPECTED_STRUCT_HEADER;
|
| + }
|
| +
|
| + var expectsResponse = this.message.expectsResponse();
|
| + var isResponse = this.message.isResponse();
|
| +
|
| + if (version == 0 && (expectsResponse || isResponse)) {
|
| + return validationError.MESSAGE_HEADER_MISSING_REQUEST_ID;
|
| + }
|
| +
|
| + if (isResponse && expectsResponse) {
|
| + return validationError.MESSAGE_HEADER_INVALID_FLAGS;
|
| + }
|
| +
|
| + if (version < 2) {
|
| + return validationError.NONE;
|
| + }
|
| +
|
| + var err = this.validateArrayPointer(
|
| + internal.kMessagePayloadInterfaceIdsPointerOffset,
|
| + internal.Uint32.encodedSize, internal.Uint32, true, [0], 0);
|
| +
|
| + if (err != validationError.NONE) {
|
| + return err;
|
| + }
|
| +
|
| + this.payloadInterfaceIds = this.message.getPayloadInterfaceIds();
|
| + if (this.payloadInterfaceIds) {
|
| + for (var interfaceId of this.payloadInterfaceIds) {
|
| + if (!internal.isValidInterfaceId(interfaceId) ||
|
| + internal.isMasterInterfaceId(interfaceId)) {
|
| + return validationError.ILLEGAL_INTERFACE_ID;
|
| + }
|
| + }
|
| + }
|
| +
|
| + // Set offset to the start of the payload and offsetLimit to the start of
|
| + // the payload interface Ids so that payload can be validated using the
|
| + // same messageValidator.
|
| + this.offset = this.message.getHeaderNumBytes();
|
| + this.offsetLimit = this.decodePointer(
|
| + internal.kMessagePayloadInterfaceIdsPointerOffset);
|
| +
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateMessageIsRequestWithoutResponse = function() {
|
| + if (this.message.isResponse() || this.message.expectsResponse()) {
|
| + return validationError.MESSAGE_HEADER_INVALID_FLAGS;
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateMessageIsRequestExpectingResponse = function() {
|
| + if (this.message.isResponse() || !this.message.expectsResponse()) {
|
| + return validationError.MESSAGE_HEADER_INVALID_FLAGS;
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateMessageIsResponse = function() {
|
| + if (this.message.expectsResponse() || !this.message.isResponse()) {
|
| + return validationError.MESSAGE_HEADER_INVALID_FLAGS;
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + // Returns the message.buffer relative offset this pointer "points to",
|
| + // NULL_MOJO_POINTER if the pointer represents a null, or JS null if the
|
| + // pointer's value is not valid.
|
| + Validator.prototype.decodePointer = function(offset) {
|
| + var pointerValue = this.message.buffer.getUint64(offset);
|
| + if (pointerValue === 0)
|
| + return NULL_MOJO_POINTER;
|
| + var bufferOffset = offset + pointerValue;
|
| + return Number.isSafeInteger(bufferOffset) ? bufferOffset : null;
|
| + };
|
| +
|
| + Validator.prototype.decodeUnionSize = function(offset) {
|
| + return this.message.buffer.getUint32(offset);
|
| + };
|
| +
|
| + Validator.prototype.decodeUnionTag = function(offset) {
|
| + return this.message.buffer.getUint32(offset + 4);
|
| + };
|
| +
|
| + Validator.prototype.validateArrayPointer = function(
|
| + offset, elementSize, elementType, nullable, expectedDimensionSizes,
|
| + currentDimension) {
|
| + var arrayOffset = this.decodePointer(offset);
|
| + if (arrayOffset === null)
|
| + return validationError.ILLEGAL_POINTER;
|
| +
|
| + if (arrayOffset === NULL_MOJO_POINTER)
|
| + return nullable ?
|
| + validationError.NONE : validationError.UNEXPECTED_NULL_POINTER;
|
| +
|
| + return this.validateArray(arrayOffset, elementSize, elementType,
|
| + expectedDimensionSizes, currentDimension);
|
| + };
|
| +
|
| + Validator.prototype.validateStructPointer = function(
|
| + offset, structClass, nullable) {
|
| + var structOffset = this.decodePointer(offset);
|
| + if (structOffset === null)
|
| + return validationError.ILLEGAL_POINTER;
|
| +
|
| + if (structOffset === NULL_MOJO_POINTER)
|
| + return nullable ?
|
| + validationError.NONE : validationError.UNEXPECTED_NULL_POINTER;
|
| +
|
| + return structClass.validate(this, structOffset);
|
| + };
|
| +
|
| + Validator.prototype.validateUnion = function(
|
| + offset, unionClass, nullable) {
|
| + var size = this.message.buffer.getUint32(offset);
|
| + if (size == 0) {
|
| + return nullable ?
|
| + validationError.NONE : validationError.UNEXPECTED_NULL_UNION;
|
| + }
|
| +
|
| + return unionClass.validate(this, offset);
|
| + };
|
| +
|
| + Validator.prototype.validateNestedUnion = function(
|
| + offset, unionClass, nullable) {
|
| + var unionOffset = this.decodePointer(offset);
|
| + if (unionOffset === null)
|
| + return validationError.ILLEGAL_POINTER;
|
| +
|
| + if (unionOffset === NULL_MOJO_POINTER)
|
| + return nullable ?
|
| + validationError.NONE : validationError.UNEXPECTED_NULL_UNION;
|
| +
|
| + return this.validateUnion(unionOffset, unionClass, nullable);
|
| + };
|
| +
|
| + // This method assumes that the array at arrayPointerOffset has
|
| + // been validated.
|
| +
|
| + Validator.prototype.arrayLength = function(arrayPointerOffset) {
|
| + var arrayOffset = this.decodePointer(arrayPointerOffset);
|
| + return this.message.buffer.getUint32(arrayOffset + 4);
|
| + };
|
| +
|
| + Validator.prototype.validateMapPointer = function(
|
| + offset, mapIsNullable, keyClass, valueClass, valueIsNullable) {
|
| + // Validate the implicit map struct:
|
| + // struct {array<keyClass> keys; array<valueClass> values};
|
| + var structOffset = this.decodePointer(offset);
|
| + if (structOffset === null)
|
| + return validationError.ILLEGAL_POINTER;
|
| +
|
| + if (structOffset === NULL_MOJO_POINTER)
|
| + return mapIsNullable ?
|
| + validationError.NONE : validationError.UNEXPECTED_NULL_POINTER;
|
| +
|
| + var mapEncodedSize = internal.kStructHeaderSize +
|
| + internal.kMapStructPayloadSize;
|
| + var err = this.validateStructHeader(structOffset, mapEncodedSize);
|
| + if (err !== validationError.NONE)
|
| + return err;
|
| +
|
| + // Validate the keys array.
|
| + var keysArrayPointerOffset = structOffset + internal.kStructHeaderSize;
|
| + err = this.validateArrayPointer(
|
| + keysArrayPointerOffset, keyClass.encodedSize, keyClass, false, [0], 0);
|
| + if (err !== validationError.NONE)
|
| + return err;
|
| +
|
| + // Validate the values array.
|
| + var valuesArrayPointerOffset = keysArrayPointerOffset + 8;
|
| + var valuesArrayDimensions = [0]; // Validate the actual length below.
|
| + if (valueClass instanceof internal.ArrayOf)
|
| + valuesArrayDimensions =
|
| + valuesArrayDimensions.concat(valueClass.dimensions());
|
| + var err = this.validateArrayPointer(valuesArrayPointerOffset,
|
| + valueClass.encodedSize,
|
| + valueClass,
|
| + valueIsNullable,
|
| + valuesArrayDimensions,
|
| + 0);
|
| + if (err !== validationError.NONE)
|
| + return err;
|
| +
|
| + // Validate the lengths of the keys and values arrays.
|
| + var keysArrayLength = this.arrayLength(keysArrayPointerOffset);
|
| + var valuesArrayLength = this.arrayLength(valuesArrayPointerOffset);
|
| + if (keysArrayLength != valuesArrayLength)
|
| + return validationError.DIFFERENT_SIZED_ARRAYS_IN_MAP;
|
| +
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateStringPointer = function(offset, nullable) {
|
| + return this.validateArrayPointer(
|
| + offset, internal.Uint8.encodedSize, internal.Uint8, nullable, [0], 0);
|
| + };
|
| +
|
| + // Similar to Array_Data<T>::Validate()
|
| + // mojo/public/cpp/bindings/lib/array_internal.h
|
| +
|
| + Validator.prototype.validateArray =
|
| + function (offset, elementSize, elementType, expectedDimensionSizes,
|
| + currentDimension) {
|
| + if (!internal.isAligned(offset))
|
| + return validationError.MISALIGNED_OBJECT;
|
| +
|
| + if (!this.isValidRange(offset, internal.kArrayHeaderSize))
|
| + return validationError.ILLEGAL_MEMORY_RANGE;
|
| +
|
| + var numBytes = this.message.buffer.getUint32(offset);
|
| + var numElements = this.message.buffer.getUint32(offset + 4);
|
| +
|
| + // Note: this computation is "safe" because elementSize <= 8 and
|
| + // numElements is a uint32.
|
| + var elementsTotalSize = (elementType === internal.PackedBool) ?
|
| + Math.ceil(numElements / 8) : (elementSize * numElements);
|
| +
|
| + if (numBytes < internal.kArrayHeaderSize + elementsTotalSize)
|
| + return validationError.UNEXPECTED_ARRAY_HEADER;
|
| +
|
| + if (expectedDimensionSizes[currentDimension] != 0 &&
|
| + numElements != expectedDimensionSizes[currentDimension]) {
|
| + return validationError.UNEXPECTED_ARRAY_HEADER;
|
| + }
|
| +
|
| + if (!this.claimRange(offset, numBytes))
|
| + return validationError.ILLEGAL_MEMORY_RANGE;
|
| +
|
| + // Validate the array's elements if they are pointers or handles.
|
| +
|
| + var elementsOffset = offset + internal.kArrayHeaderSize;
|
| + var nullable = isNullable(elementType);
|
| +
|
| + if (isHandleClass(elementType))
|
| + return this.validateHandleElements(elementsOffset, numElements, nullable);
|
| + if (isInterfaceClass(elementType))
|
| + return this.validateInterfaceElements(
|
| + elementsOffset, numElements, nullable);
|
| + if (isInterfaceRequestClass(elementType))
|
| + return this.validateInterfaceRequestElements(
|
| + elementsOffset, numElements, nullable);
|
| + if (isAssociatedInterfaceClass(elementType))
|
| + return this.validateAssociatedInterfaceElements(
|
| + elementsOffset, numElements, nullable);
|
| + if (isAssociatedInterfaceRequestClass(elementType))
|
| + return this.validateAssociatedInterfaceRequestElements(
|
| + elementsOffset, numElements, nullable);
|
| + if (isStringClass(elementType))
|
| + return this.validateArrayElements(
|
| + elementsOffset, numElements, internal.Uint8, nullable, [0], 0);
|
| + if (elementType instanceof internal.PointerTo)
|
| + return this.validateStructElements(
|
| + elementsOffset, numElements, elementType.cls, nullable);
|
| + if (elementType instanceof internal.ArrayOf)
|
| + return this.validateArrayElements(
|
| + elementsOffset, numElements, elementType.cls, nullable,
|
| + expectedDimensionSizes, currentDimension + 1);
|
| + if (isEnumClass(elementType))
|
| + return this.validateEnumElements(elementsOffset, numElements,
|
| + elementType.cls);
|
| +
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + // Note: the |offset + i * elementSize| computation in the validateFooElements
|
| + // methods below is "safe" because elementSize <= 8, offset and
|
| + // numElements are uint32, and 0 <= i < numElements.
|
| +
|
| + Validator.prototype.validateHandleElements =
|
| + function(offset, numElements, nullable) {
|
| + var elementSize = internal.Handle.encodedSize;
|
| + for (var i = 0; i < numElements; i++) {
|
| + var elementOffset = offset + i * elementSize;
|
| + var err = this.validateHandle(elementOffset, nullable);
|
| + if (err != validationError.NONE)
|
| + return err;
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateInterfaceElements =
|
| + function(offset, numElements, nullable) {
|
| + var elementSize = internal.Interface.prototype.encodedSize;
|
| + for (var i = 0; i < numElements; i++) {
|
| + var elementOffset = offset + i * elementSize;
|
| + var err = this.validateInterface(elementOffset, nullable);
|
| + if (err != validationError.NONE)
|
| + return err;
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateInterfaceRequestElements =
|
| + function(offset, numElements, nullable) {
|
| + var elementSize = internal.InterfaceRequest.encodedSize;
|
| + for (var i = 0; i < numElements; i++) {
|
| + var elementOffset = offset + i * elementSize;
|
| + var err = this.validateInterfaceRequest(elementOffset, nullable);
|
| + if (err != validationError.NONE)
|
| + return err;
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateAssociatedInterfaceElements =
|
| + function(offset, numElements, nullable) {
|
| + var elementSize = internal.AssociatedInterfacePtrInfo.prototype.encodedSize;
|
| + for (var i = 0; i < numElements; i++) {
|
| + var elementOffset = offset + i * elementSize;
|
| + var err = this.validateAssociatedInterface(elementOffset, nullable);
|
| + if (err != validationError.NONE) {
|
| + return err;
|
| + }
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateAssociatedInterfaceRequestElements =
|
| + function(offset, numElements, nullable) {
|
| + var elementSize = internal.AssociatedInterfaceRequest.encodedSize;
|
| + for (var i = 0; i < numElements; i++) {
|
| + var elementOffset = offset + i * elementSize;
|
| + var err = this.validateAssociatedInterfaceRequest(elementOffset,
|
| + nullable);
|
| + if (err != validationError.NONE) {
|
| + return err;
|
| + }
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + // The elementClass parameter is the element type of the element arrays.
|
| + Validator.prototype.validateArrayElements =
|
| + function(offset, numElements, elementClass, nullable,
|
| + expectedDimensionSizes, currentDimension) {
|
| + var elementSize = internal.PointerTo.prototype.encodedSize;
|
| + for (var i = 0; i < numElements; i++) {
|
| + var elementOffset = offset + i * elementSize;
|
| + var err = this.validateArrayPointer(
|
| + elementOffset, elementClass.encodedSize, elementClass, nullable,
|
| + expectedDimensionSizes, currentDimension);
|
| + if (err != validationError.NONE)
|
| + return err;
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateStructElements =
|
| + function(offset, numElements, structClass, nullable) {
|
| + var elementSize = internal.PointerTo.prototype.encodedSize;
|
| + for (var i = 0; i < numElements; i++) {
|
| + var elementOffset = offset + i * elementSize;
|
| + var err =
|
| + this.validateStructPointer(elementOffset, structClass, nullable);
|
| + if (err != validationError.NONE)
|
| + return err;
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + Validator.prototype.validateEnumElements =
|
| + function(offset, numElements, enumClass) {
|
| + var elementSize = internal.Enum.prototype.encodedSize;
|
| + for (var i = 0; i < numElements; i++) {
|
| + var elementOffset = offset + i * elementSize;
|
| + var err = this.validateEnum(elementOffset, enumClass);
|
| + if (err != validationError.NONE)
|
| + return err;
|
| + }
|
| + return validationError.NONE;
|
| + };
|
| +
|
| + internal.validationError = validationError;
|
| + internal.Validator = Validator;
|
| + internal.ValidationErrorObserverForTesting =
|
| + ValidationErrorObserverForTesting;
|
| + internal.reportValidationError = reportValidationError;
|
| + internal.isTestingMode = isTestingMode;
|
| + internal.clearTestingMode = clearTestingMode;
|
| +})();
|
| +// 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 = 'mojo/public/interfaces/bindings/new_bindings/interface_control_messages.mojom';
|
| + if (mojo.internal.isMojomLoaded(mojomId)) {
|
| + console.warn('The following mojom is loaded multiple times: ' + mojomId);
|
| + return;
|
| + }
|
| + mojo.internal.markMojomLoaded(mojomId);
|
| +
|
| + // TODO(yzshen): Define these aliases to minimize the differences between the
|
| + // old/new modes. Remove them when the old mode goes away.
|
| + var bindings = mojo;
|
| + var associatedBindings = mojo;
|
| + var codec = mojo.internal;
|
| + var validator = mojo.internal;
|
| +
|
| +
|
| + var kRunMessageId = 0xFFFFFFFF;
|
| + var kRunOrClosePipeMessageId = 0xFFFFFFFE;
|
| +
|
| + function RunMessageParams(values) {
|
| + this.initDefaults_();
|
| + this.initFields_(values);
|
| + }
|
| +
|
| +
|
| + RunMessageParams.prototype.initDefaults_ = function() {
|
| + this.input = null;
|
| + };
|
| + RunMessageParams.prototype.initFields_ = function(fields) {
|
| + for(var field in fields) {
|
| + if (this.hasOwnProperty(field))
|
| + this[field] = fields[field];
|
| + }
|
| + };
|
| +
|
| + RunMessageParams.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 RunMessageParams.input
|
| + err = messageValidator.validateUnion(offset + codec.kStructHeaderSize + 0, RunInput, false);
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| +
|
| + return validator.validationError.NONE;
|
| + };
|
| +
|
| + RunMessageParams.encodedSize = codec.kStructHeaderSize + 16;
|
| +
|
| + RunMessageParams.decode = function(decoder) {
|
| + var packed;
|
| + var val = new RunMessageParams();
|
| + var numberOfBytes = decoder.readUint32();
|
| + var version = decoder.readUint32();
|
| + val.input = decoder.decodeStruct(RunInput);
|
| + return val;
|
| + };
|
| +
|
| + RunMessageParams.encode = function(encoder, val) {
|
| + var packed;
|
| + encoder.writeUint32(RunMessageParams.encodedSize);
|
| + encoder.writeUint32(0);
|
| + encoder.encodeStruct(RunInput, val.input);
|
| + };
|
| + function RunResponseMessageParams(values) {
|
| + this.initDefaults_();
|
| + this.initFields_(values);
|
| + }
|
| +
|
| +
|
| + RunResponseMessageParams.prototype.initDefaults_ = function() {
|
| + this.output = null;
|
| + };
|
| + RunResponseMessageParams.prototype.initFields_ = function(fields) {
|
| + for(var field in fields) {
|
| + if (this.hasOwnProperty(field))
|
| + this[field] = fields[field];
|
| + }
|
| + };
|
| +
|
| + RunResponseMessageParams.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 RunResponseMessageParams.output
|
| + err = messageValidator.validateUnion(offset + codec.kStructHeaderSize + 0, RunOutput, true);
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| +
|
| + return validator.validationError.NONE;
|
| + };
|
| +
|
| + RunResponseMessageParams.encodedSize = codec.kStructHeaderSize + 16;
|
| +
|
| + RunResponseMessageParams.decode = function(decoder) {
|
| + var packed;
|
| + var val = new RunResponseMessageParams();
|
| + var numberOfBytes = decoder.readUint32();
|
| + var version = decoder.readUint32();
|
| + val.output = decoder.decodeStruct(RunOutput);
|
| + return val;
|
| + };
|
| +
|
| + RunResponseMessageParams.encode = function(encoder, val) {
|
| + var packed;
|
| + encoder.writeUint32(RunResponseMessageParams.encodedSize);
|
| + encoder.writeUint32(0);
|
| + encoder.encodeStruct(RunOutput, val.output);
|
| + };
|
| + function QueryVersion(values) {
|
| + this.initDefaults_();
|
| + this.initFields_(values);
|
| + }
|
| +
|
| +
|
| + QueryVersion.prototype.initDefaults_ = function() {
|
| + };
|
| + QueryVersion.prototype.initFields_ = function(fields) {
|
| + for(var field in fields) {
|
| + if (this.hasOwnProperty(field))
|
| + this[field] = fields[field];
|
| + }
|
| + };
|
| +
|
| + QueryVersion.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;
|
| + };
|
| +
|
| + QueryVersion.encodedSize = codec.kStructHeaderSize + 0;
|
| +
|
| + QueryVersion.decode = function(decoder) {
|
| + var packed;
|
| + var val = new QueryVersion();
|
| + var numberOfBytes = decoder.readUint32();
|
| + var version = decoder.readUint32();
|
| + return val;
|
| + };
|
| +
|
| + QueryVersion.encode = function(encoder, val) {
|
| + var packed;
|
| + encoder.writeUint32(QueryVersion.encodedSize);
|
| + encoder.writeUint32(0);
|
| + };
|
| + function QueryVersionResult(values) {
|
| + this.initDefaults_();
|
| + this.initFields_(values);
|
| + }
|
| +
|
| +
|
| + QueryVersionResult.prototype.initDefaults_ = function() {
|
| + this.version = 0;
|
| + };
|
| + QueryVersionResult.prototype.initFields_ = function(fields) {
|
| + for(var field in fields) {
|
| + if (this.hasOwnProperty(field))
|
| + this[field] = fields[field];
|
| + }
|
| + };
|
| +
|
| + QueryVersionResult.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;
|
| + };
|
| +
|
| + QueryVersionResult.encodedSize = codec.kStructHeaderSize + 8;
|
| +
|
| + QueryVersionResult.decode = function(decoder) {
|
| + var packed;
|
| + var val = new QueryVersionResult();
|
| + var numberOfBytes = decoder.readUint32();
|
| + var version = decoder.readUint32();
|
| + val.version = decoder.decodeStruct(codec.Uint32);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + return val;
|
| + };
|
| +
|
| + QueryVersionResult.encode = function(encoder, val) {
|
| + var packed;
|
| + encoder.writeUint32(QueryVersionResult.encodedSize);
|
| + encoder.writeUint32(0);
|
| + encoder.encodeStruct(codec.Uint32, val.version);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + };
|
| + function FlushForTesting(values) {
|
| + this.initDefaults_();
|
| + this.initFields_(values);
|
| + }
|
| +
|
| +
|
| + FlushForTesting.prototype.initDefaults_ = function() {
|
| + };
|
| + FlushForTesting.prototype.initFields_ = function(fields) {
|
| + for(var field in fields) {
|
| + if (this.hasOwnProperty(field))
|
| + this[field] = fields[field];
|
| + }
|
| + };
|
| +
|
| + FlushForTesting.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;
|
| + };
|
| +
|
| + FlushForTesting.encodedSize = codec.kStructHeaderSize + 0;
|
| +
|
| + FlushForTesting.decode = function(decoder) {
|
| + var packed;
|
| + var val = new FlushForTesting();
|
| + var numberOfBytes = decoder.readUint32();
|
| + var version = decoder.readUint32();
|
| + return val;
|
| + };
|
| +
|
| + FlushForTesting.encode = function(encoder, val) {
|
| + var packed;
|
| + encoder.writeUint32(FlushForTesting.encodedSize);
|
| + encoder.writeUint32(0);
|
| + };
|
| + function RunOrClosePipeMessageParams(values) {
|
| + this.initDefaults_();
|
| + this.initFields_(values);
|
| + }
|
| +
|
| +
|
| + RunOrClosePipeMessageParams.prototype.initDefaults_ = function() {
|
| + this.input = null;
|
| + };
|
| + RunOrClosePipeMessageParams.prototype.initFields_ = function(fields) {
|
| + for(var field in fields) {
|
| + if (this.hasOwnProperty(field))
|
| + this[field] = fields[field];
|
| + }
|
| + };
|
| +
|
| + RunOrClosePipeMessageParams.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 RunOrClosePipeMessageParams.input
|
| + err = messageValidator.validateUnion(offset + codec.kStructHeaderSize + 0, RunOrClosePipeInput, false);
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| +
|
| + return validator.validationError.NONE;
|
| + };
|
| +
|
| + RunOrClosePipeMessageParams.encodedSize = codec.kStructHeaderSize + 16;
|
| +
|
| + RunOrClosePipeMessageParams.decode = function(decoder) {
|
| + var packed;
|
| + var val = new RunOrClosePipeMessageParams();
|
| + var numberOfBytes = decoder.readUint32();
|
| + var version = decoder.readUint32();
|
| + val.input = decoder.decodeStruct(RunOrClosePipeInput);
|
| + return val;
|
| + };
|
| +
|
| + RunOrClosePipeMessageParams.encode = function(encoder, val) {
|
| + var packed;
|
| + encoder.writeUint32(RunOrClosePipeMessageParams.encodedSize);
|
| + encoder.writeUint32(0);
|
| + encoder.encodeStruct(RunOrClosePipeInput, val.input);
|
| + };
|
| + function RequireVersion(values) {
|
| + this.initDefaults_();
|
| + this.initFields_(values);
|
| + }
|
| +
|
| +
|
| + RequireVersion.prototype.initDefaults_ = function() {
|
| + this.version = 0;
|
| + };
|
| + RequireVersion.prototype.initFields_ = function(fields) {
|
| + for(var field in fields) {
|
| + if (this.hasOwnProperty(field))
|
| + this[field] = fields[field];
|
| + }
|
| + };
|
| +
|
| + RequireVersion.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;
|
| + };
|
| +
|
| + RequireVersion.encodedSize = codec.kStructHeaderSize + 8;
|
| +
|
| + RequireVersion.decode = function(decoder) {
|
| + var packed;
|
| + var val = new RequireVersion();
|
| + var numberOfBytes = decoder.readUint32();
|
| + var version = decoder.readUint32();
|
| + val.version = decoder.decodeStruct(codec.Uint32);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + return val;
|
| + };
|
| +
|
| + RequireVersion.encode = function(encoder, val) {
|
| + var packed;
|
| + encoder.writeUint32(RequireVersion.encodedSize);
|
| + encoder.writeUint32(0);
|
| + encoder.encodeStruct(codec.Uint32, val.version);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + };
|
| +
|
| + function RunInput(value) {
|
| + this.initDefault_();
|
| + this.initValue_(value);
|
| + }
|
| +
|
| +
|
| + RunInput.Tags = {
|
| + queryVersion: 0,
|
| + flushForTesting: 1,
|
| + };
|
| +
|
| + RunInput.prototype.initDefault_ = function() {
|
| + this.$data = null;
|
| + this.$tag = undefined;
|
| + }
|
| +
|
| + RunInput.prototype.initValue_ = function(value) {
|
| + if (value == undefined) {
|
| + return;
|
| + }
|
| +
|
| + var keys = Object.keys(value);
|
| + if (keys.length == 0) {
|
| + return;
|
| + }
|
| +
|
| + if (keys.length > 1) {
|
| + throw new TypeError("You may set only one member on a union.");
|
| + }
|
| +
|
| + var fields = [
|
| + "queryVersion",
|
| + "flushForTesting",
|
| + ];
|
| +
|
| + if (fields.indexOf(keys[0]) < 0) {
|
| + throw new ReferenceError(keys[0] + " is not a RunInput member.");
|
| +
|
| + }
|
| +
|
| + this[keys[0]] = value[keys[0]];
|
| + }
|
| + Object.defineProperty(RunInput.prototype, "queryVersion", {
|
| + get: function() {
|
| + if (this.$tag != RunInput.Tags.queryVersion) {
|
| + throw new ReferenceError(
|
| + "RunInput.queryVersion is not currently set.");
|
| + }
|
| + return this.$data;
|
| + },
|
| +
|
| + set: function(value) {
|
| + this.$tag = RunInput.Tags.queryVersion;
|
| + this.$data = value;
|
| + }
|
| + });
|
| + Object.defineProperty(RunInput.prototype, "flushForTesting", {
|
| + get: function() {
|
| + if (this.$tag != RunInput.Tags.flushForTesting) {
|
| + throw new ReferenceError(
|
| + "RunInput.flushForTesting is not currently set.");
|
| + }
|
| + return this.$data;
|
| + },
|
| +
|
| + set: function(value) {
|
| + this.$tag = RunInput.Tags.flushForTesting;
|
| + this.$data = value;
|
| + }
|
| + });
|
| +
|
| +
|
| + RunInput.encode = function(encoder, val) {
|
| + if (val == null) {
|
| + encoder.writeUint64(0);
|
| + encoder.writeUint64(0);
|
| + return;
|
| + }
|
| + if (val.$tag == undefined) {
|
| + throw new TypeError("Cannot encode unions with an unknown member set.");
|
| + }
|
| +
|
| + encoder.writeUint32(16);
|
| + encoder.writeUint32(val.$tag);
|
| + switch (val.$tag) {
|
| + case RunInput.Tags.queryVersion:
|
| + encoder.encodeStructPointer(QueryVersion, val.queryVersion);
|
| + break;
|
| + case RunInput.Tags.flushForTesting:
|
| + encoder.encodeStructPointer(FlushForTesting, val.flushForTesting);
|
| + break;
|
| + }
|
| + encoder.align();
|
| + };
|
| +
|
| +
|
| + RunInput.decode = function(decoder) {
|
| + var size = decoder.readUint32();
|
| + if (size == 0) {
|
| + decoder.readUint32();
|
| + decoder.readUint64();
|
| + return null;
|
| + }
|
| +
|
| + var result = new RunInput();
|
| + var tag = decoder.readUint32();
|
| + switch (tag) {
|
| + case RunInput.Tags.queryVersion:
|
| + result.queryVersion = decoder.decodeStructPointer(QueryVersion);
|
| + break;
|
| + case RunInput.Tags.flushForTesting:
|
| + result.flushForTesting = decoder.decodeStructPointer(FlushForTesting);
|
| + break;
|
| + }
|
| + decoder.align();
|
| +
|
| + return result;
|
| + };
|
| +
|
| +
|
| + RunInput.validate = function(messageValidator, offset) {
|
| + var size = messageValidator.decodeUnionSize(offset);
|
| + if (size != 16) {
|
| + return validator.validationError.INVALID_UNION_SIZE;
|
| + }
|
| +
|
| + var tag = messageValidator.decodeUnionTag(offset);
|
| + var data_offset = offset + 8;
|
| + var err;
|
| + switch (tag) {
|
| + case RunInput.Tags.queryVersion:
|
| +
|
| +
|
| + // validate RunInput.queryVersion
|
| + err = messageValidator.validateStructPointer(data_offset, QueryVersion, false);
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| + break;
|
| + case RunInput.Tags.flushForTesting:
|
| +
|
| +
|
| + // validate RunInput.flushForTesting
|
| + err = messageValidator.validateStructPointer(data_offset, FlushForTesting, false);
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| + break;
|
| + }
|
| +
|
| + return validator.validationError.NONE;
|
| + };
|
| +
|
| + RunInput.encodedSize = 16;
|
| +
|
| + function RunOutput(value) {
|
| + this.initDefault_();
|
| + this.initValue_(value);
|
| + }
|
| +
|
| +
|
| + RunOutput.Tags = {
|
| + queryVersionResult: 0,
|
| + };
|
| +
|
| + RunOutput.prototype.initDefault_ = function() {
|
| + this.$data = null;
|
| + this.$tag = undefined;
|
| + }
|
| +
|
| + RunOutput.prototype.initValue_ = function(value) {
|
| + if (value == undefined) {
|
| + return;
|
| + }
|
| +
|
| + var keys = Object.keys(value);
|
| + if (keys.length == 0) {
|
| + return;
|
| + }
|
| +
|
| + if (keys.length > 1) {
|
| + throw new TypeError("You may set only one member on a union.");
|
| + }
|
| +
|
| + var fields = [
|
| + "queryVersionResult",
|
| + ];
|
| +
|
| + if (fields.indexOf(keys[0]) < 0) {
|
| + throw new ReferenceError(keys[0] + " is not a RunOutput member.");
|
| +
|
| + }
|
| +
|
| + this[keys[0]] = value[keys[0]];
|
| + }
|
| + Object.defineProperty(RunOutput.prototype, "queryVersionResult", {
|
| + get: function() {
|
| + if (this.$tag != RunOutput.Tags.queryVersionResult) {
|
| + throw new ReferenceError(
|
| + "RunOutput.queryVersionResult is not currently set.");
|
| + }
|
| + return this.$data;
|
| + },
|
| +
|
| + set: function(value) {
|
| + this.$tag = RunOutput.Tags.queryVersionResult;
|
| + this.$data = value;
|
| + }
|
| + });
|
| +
|
| +
|
| + RunOutput.encode = function(encoder, val) {
|
| + if (val == null) {
|
| + encoder.writeUint64(0);
|
| + encoder.writeUint64(0);
|
| + return;
|
| + }
|
| + if (val.$tag == undefined) {
|
| + throw new TypeError("Cannot encode unions with an unknown member set.");
|
| + }
|
| +
|
| + encoder.writeUint32(16);
|
| + encoder.writeUint32(val.$tag);
|
| + switch (val.$tag) {
|
| + case RunOutput.Tags.queryVersionResult:
|
| + encoder.encodeStructPointer(QueryVersionResult, val.queryVersionResult);
|
| + break;
|
| + }
|
| + encoder.align();
|
| + };
|
| +
|
| +
|
| + RunOutput.decode = function(decoder) {
|
| + var size = decoder.readUint32();
|
| + if (size == 0) {
|
| + decoder.readUint32();
|
| + decoder.readUint64();
|
| + return null;
|
| + }
|
| +
|
| + var result = new RunOutput();
|
| + var tag = decoder.readUint32();
|
| + switch (tag) {
|
| + case RunOutput.Tags.queryVersionResult:
|
| + result.queryVersionResult = decoder.decodeStructPointer(QueryVersionResult);
|
| + break;
|
| + }
|
| + decoder.align();
|
| +
|
| + return result;
|
| + };
|
| +
|
| +
|
| + RunOutput.validate = function(messageValidator, offset) {
|
| + var size = messageValidator.decodeUnionSize(offset);
|
| + if (size != 16) {
|
| + return validator.validationError.INVALID_UNION_SIZE;
|
| + }
|
| +
|
| + var tag = messageValidator.decodeUnionTag(offset);
|
| + var data_offset = offset + 8;
|
| + var err;
|
| + switch (tag) {
|
| + case RunOutput.Tags.queryVersionResult:
|
| +
|
| +
|
| + // validate RunOutput.queryVersionResult
|
| + err = messageValidator.validateStructPointer(data_offset, QueryVersionResult, false);
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| + break;
|
| + }
|
| +
|
| + return validator.validationError.NONE;
|
| + };
|
| +
|
| + RunOutput.encodedSize = 16;
|
| +
|
| + function RunOrClosePipeInput(value) {
|
| + this.initDefault_();
|
| + this.initValue_(value);
|
| + }
|
| +
|
| +
|
| + RunOrClosePipeInput.Tags = {
|
| + requireVersion: 0,
|
| + };
|
| +
|
| + RunOrClosePipeInput.prototype.initDefault_ = function() {
|
| + this.$data = null;
|
| + this.$tag = undefined;
|
| + }
|
| +
|
| + RunOrClosePipeInput.prototype.initValue_ = function(value) {
|
| + if (value == undefined) {
|
| + return;
|
| + }
|
| +
|
| + var keys = Object.keys(value);
|
| + if (keys.length == 0) {
|
| + return;
|
| + }
|
| +
|
| + if (keys.length > 1) {
|
| + throw new TypeError("You may set only one member on a union.");
|
| + }
|
| +
|
| + var fields = [
|
| + "requireVersion",
|
| + ];
|
| +
|
| + if (fields.indexOf(keys[0]) < 0) {
|
| + throw new ReferenceError(keys[0] + " is not a RunOrClosePipeInput member.");
|
| +
|
| + }
|
| +
|
| + this[keys[0]] = value[keys[0]];
|
| + }
|
| + Object.defineProperty(RunOrClosePipeInput.prototype, "requireVersion", {
|
| + get: function() {
|
| + if (this.$tag != RunOrClosePipeInput.Tags.requireVersion) {
|
| + throw new ReferenceError(
|
| + "RunOrClosePipeInput.requireVersion is not currently set.");
|
| + }
|
| + return this.$data;
|
| + },
|
| +
|
| + set: function(value) {
|
| + this.$tag = RunOrClosePipeInput.Tags.requireVersion;
|
| + this.$data = value;
|
| + }
|
| + });
|
| +
|
| +
|
| + RunOrClosePipeInput.encode = function(encoder, val) {
|
| + if (val == null) {
|
| + encoder.writeUint64(0);
|
| + encoder.writeUint64(0);
|
| + return;
|
| + }
|
| + if (val.$tag == undefined) {
|
| + throw new TypeError("Cannot encode unions with an unknown member set.");
|
| + }
|
| +
|
| + encoder.writeUint32(16);
|
| + encoder.writeUint32(val.$tag);
|
| + switch (val.$tag) {
|
| + case RunOrClosePipeInput.Tags.requireVersion:
|
| + encoder.encodeStructPointer(RequireVersion, val.requireVersion);
|
| + break;
|
| + }
|
| + encoder.align();
|
| + };
|
| +
|
| +
|
| + RunOrClosePipeInput.decode = function(decoder) {
|
| + var size = decoder.readUint32();
|
| + if (size == 0) {
|
| + decoder.readUint32();
|
| + decoder.readUint64();
|
| + return null;
|
| + }
|
| +
|
| + var result = new RunOrClosePipeInput();
|
| + var tag = decoder.readUint32();
|
| + switch (tag) {
|
| + case RunOrClosePipeInput.Tags.requireVersion:
|
| + result.requireVersion = decoder.decodeStructPointer(RequireVersion);
|
| + break;
|
| + }
|
| + decoder.align();
|
| +
|
| + return result;
|
| + };
|
| +
|
| +
|
| + RunOrClosePipeInput.validate = function(messageValidator, offset) {
|
| + var size = messageValidator.decodeUnionSize(offset);
|
| + if (size != 16) {
|
| + return validator.validationError.INVALID_UNION_SIZE;
|
| + }
|
| +
|
| + var tag = messageValidator.decodeUnionTag(offset);
|
| + var data_offset = offset + 8;
|
| + var err;
|
| + switch (tag) {
|
| + case RunOrClosePipeInput.Tags.requireVersion:
|
| +
|
| +
|
| + // validate RunOrClosePipeInput.requireVersion
|
| + err = messageValidator.validateStructPointer(data_offset, RequireVersion, false);
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| + break;
|
| + }
|
| +
|
| + return validator.validationError.NONE;
|
| + };
|
| +
|
| + RunOrClosePipeInput.encodedSize = 16;
|
| + var exports = mojo.internal.exposeNamespace("mojo.interfaceControl2");
|
| + exports.kRunMessageId = kRunMessageId;
|
| + exports.kRunOrClosePipeMessageId = kRunOrClosePipeMessageId;
|
| + exports.RunMessageParams = RunMessageParams;
|
| + exports.RunResponseMessageParams = RunResponseMessageParams;
|
| + exports.QueryVersion = QueryVersion;
|
| + exports.QueryVersionResult = QueryVersionResult;
|
| + exports.FlushForTesting = FlushForTesting;
|
| + exports.RunOrClosePipeMessageParams = RunOrClosePipeMessageParams;
|
| + exports.RequireVersion = RequireVersion;
|
| + exports.RunInput = RunInput;
|
| + exports.RunOutput = RunOutput;
|
| + exports.RunOrClosePipeInput = RunOrClosePipeInput;
|
| +})();// 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 = 'mojo/public/interfaces/bindings/new_bindings/pipe_control_messages.mojom';
|
| + if (mojo.internal.isMojomLoaded(mojomId)) {
|
| + console.warn('The following mojom is loaded multiple times: ' + mojomId);
|
| + return;
|
| + }
|
| + mojo.internal.markMojomLoaded(mojomId);
|
| +
|
| + // TODO(yzshen): Define these aliases to minimize the differences between the
|
| + // old/new modes. Remove them when the old mode goes away.
|
| + var bindings = mojo;
|
| + var associatedBindings = mojo;
|
| + var codec = mojo.internal;
|
| + var validator = mojo.internal;
|
| +
|
| +
|
| + var kRunOrClosePipeMessageId = 0xFFFFFFFE;
|
| +
|
| + function RunOrClosePipeMessageParams(values) {
|
| + this.initDefaults_();
|
| + this.initFields_(values);
|
| + }
|
| +
|
| +
|
| + RunOrClosePipeMessageParams.prototype.initDefaults_ = function() {
|
| + this.input = null;
|
| + };
|
| + RunOrClosePipeMessageParams.prototype.initFields_ = function(fields) {
|
| + for(var field in fields) {
|
| + if (this.hasOwnProperty(field))
|
| + this[field] = fields[field];
|
| + }
|
| + };
|
| +
|
| + RunOrClosePipeMessageParams.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 RunOrClosePipeMessageParams.input
|
| + err = messageValidator.validateUnion(offset + codec.kStructHeaderSize + 0, RunOrClosePipeInput, false);
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| +
|
| + return validator.validationError.NONE;
|
| + };
|
| +
|
| + RunOrClosePipeMessageParams.encodedSize = codec.kStructHeaderSize + 16;
|
| +
|
| + RunOrClosePipeMessageParams.decode = function(decoder) {
|
| + var packed;
|
| + var val = new RunOrClosePipeMessageParams();
|
| + var numberOfBytes = decoder.readUint32();
|
| + var version = decoder.readUint32();
|
| + val.input = decoder.decodeStruct(RunOrClosePipeInput);
|
| + return val;
|
| + };
|
| +
|
| + RunOrClosePipeMessageParams.encode = function(encoder, val) {
|
| + var packed;
|
| + encoder.writeUint32(RunOrClosePipeMessageParams.encodedSize);
|
| + encoder.writeUint32(0);
|
| + encoder.encodeStruct(RunOrClosePipeInput, val.input);
|
| + };
|
| + function DisconnectReason(values) {
|
| + this.initDefaults_();
|
| + this.initFields_(values);
|
| + }
|
| +
|
| +
|
| + DisconnectReason.prototype.initDefaults_ = function() {
|
| + this.customReason = 0;
|
| + this.description = null;
|
| + };
|
| + DisconnectReason.prototype.initFields_ = function(fields) {
|
| + for(var field in fields) {
|
| + if (this.hasOwnProperty(field))
|
| + this[field] = fields[field];
|
| + }
|
| + };
|
| +
|
| + DisconnectReason.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 DisconnectReason.description
|
| + err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 8, false)
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| +
|
| + return validator.validationError.NONE;
|
| + };
|
| +
|
| + DisconnectReason.encodedSize = codec.kStructHeaderSize + 16;
|
| +
|
| + DisconnectReason.decode = function(decoder) {
|
| + var packed;
|
| + var val = new DisconnectReason();
|
| + var numberOfBytes = decoder.readUint32();
|
| + var version = decoder.readUint32();
|
| + val.customReason = decoder.decodeStruct(codec.Uint32);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + val.description = decoder.decodeStruct(codec.String);
|
| + return val;
|
| + };
|
| +
|
| + DisconnectReason.encode = function(encoder, val) {
|
| + var packed;
|
| + encoder.writeUint32(DisconnectReason.encodedSize);
|
| + encoder.writeUint32(0);
|
| + encoder.encodeStruct(codec.Uint32, val.customReason);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + encoder.encodeStruct(codec.String, val.description);
|
| + };
|
| + function PeerAssociatedEndpointClosedEvent(values) {
|
| + this.initDefaults_();
|
| + this.initFields_(values);
|
| + }
|
| +
|
| +
|
| + PeerAssociatedEndpointClosedEvent.prototype.initDefaults_ = function() {
|
| + this.id = 0;
|
| + this.disconnectReason = null;
|
| + };
|
| + PeerAssociatedEndpointClosedEvent.prototype.initFields_ = function(fields) {
|
| + for(var field in fields) {
|
| + if (this.hasOwnProperty(field))
|
| + this[field] = fields[field];
|
| + }
|
| + };
|
| +
|
| + PeerAssociatedEndpointClosedEvent.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 PeerAssociatedEndpointClosedEvent.disconnectReason
|
| + err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 8, DisconnectReason, true);
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| +
|
| + return validator.validationError.NONE;
|
| + };
|
| +
|
| + PeerAssociatedEndpointClosedEvent.encodedSize = codec.kStructHeaderSize + 16;
|
| +
|
| + PeerAssociatedEndpointClosedEvent.decode = function(decoder) {
|
| + var packed;
|
| + var val = new PeerAssociatedEndpointClosedEvent();
|
| + var numberOfBytes = decoder.readUint32();
|
| + var version = decoder.readUint32();
|
| + val.id = decoder.decodeStruct(codec.Uint32);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + decoder.skip(1);
|
| + val.disconnectReason = decoder.decodeStructPointer(DisconnectReason);
|
| + return val;
|
| + };
|
| +
|
| + PeerAssociatedEndpointClosedEvent.encode = function(encoder, val) {
|
| + var packed;
|
| + encoder.writeUint32(PeerAssociatedEndpointClosedEvent.encodedSize);
|
| + encoder.writeUint32(0);
|
| + encoder.encodeStruct(codec.Uint32, val.id);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + encoder.skip(1);
|
| + encoder.encodeStructPointer(DisconnectReason, val.disconnectReason);
|
| + };
|
| +
|
| + function RunOrClosePipeInput(value) {
|
| + this.initDefault_();
|
| + this.initValue_(value);
|
| + }
|
| +
|
| +
|
| + RunOrClosePipeInput.Tags = {
|
| + peerAssociatedEndpointClosedEvent: 0,
|
| + };
|
| +
|
| + RunOrClosePipeInput.prototype.initDefault_ = function() {
|
| + this.$data = null;
|
| + this.$tag = undefined;
|
| + }
|
| +
|
| + RunOrClosePipeInput.prototype.initValue_ = function(value) {
|
| + if (value == undefined) {
|
| + return;
|
| + }
|
| +
|
| + var keys = Object.keys(value);
|
| + if (keys.length == 0) {
|
| + return;
|
| + }
|
| +
|
| + if (keys.length > 1) {
|
| + throw new TypeError("You may set only one member on a union.");
|
| + }
|
| +
|
| + var fields = [
|
| + "peerAssociatedEndpointClosedEvent",
|
| + ];
|
| +
|
| + if (fields.indexOf(keys[0]) < 0) {
|
| + throw new ReferenceError(keys[0] + " is not a RunOrClosePipeInput member.");
|
| +
|
| + }
|
| +
|
| + this[keys[0]] = value[keys[0]];
|
| + }
|
| + Object.defineProperty(RunOrClosePipeInput.prototype, "peerAssociatedEndpointClosedEvent", {
|
| + get: function() {
|
| + if (this.$tag != RunOrClosePipeInput.Tags.peerAssociatedEndpointClosedEvent) {
|
| + throw new ReferenceError(
|
| + "RunOrClosePipeInput.peerAssociatedEndpointClosedEvent is not currently set.");
|
| + }
|
| + return this.$data;
|
| + },
|
| +
|
| + set: function(value) {
|
| + this.$tag = RunOrClosePipeInput.Tags.peerAssociatedEndpointClosedEvent;
|
| + this.$data = value;
|
| + }
|
| + });
|
| +
|
| +
|
| + RunOrClosePipeInput.encode = function(encoder, val) {
|
| + if (val == null) {
|
| + encoder.writeUint64(0);
|
| + encoder.writeUint64(0);
|
| + return;
|
| + }
|
| + if (val.$tag == undefined) {
|
| + throw new TypeError("Cannot encode unions with an unknown member set.");
|
| + }
|
| +
|
| + encoder.writeUint32(16);
|
| + encoder.writeUint32(val.$tag);
|
| + switch (val.$tag) {
|
| + case RunOrClosePipeInput.Tags.peerAssociatedEndpointClosedEvent:
|
| + encoder.encodeStructPointer(PeerAssociatedEndpointClosedEvent, val.peerAssociatedEndpointClosedEvent);
|
| + break;
|
| + }
|
| + encoder.align();
|
| + };
|
| +
|
| +
|
| + RunOrClosePipeInput.decode = function(decoder) {
|
| + var size = decoder.readUint32();
|
| + if (size == 0) {
|
| + decoder.readUint32();
|
| + decoder.readUint64();
|
| + return null;
|
| + }
|
| +
|
| + var result = new RunOrClosePipeInput();
|
| + var tag = decoder.readUint32();
|
| + switch (tag) {
|
| + case RunOrClosePipeInput.Tags.peerAssociatedEndpointClosedEvent:
|
| + result.peerAssociatedEndpointClosedEvent = decoder.decodeStructPointer(PeerAssociatedEndpointClosedEvent);
|
| + break;
|
| + }
|
| + decoder.align();
|
| +
|
| + return result;
|
| + };
|
| +
|
| +
|
| + RunOrClosePipeInput.validate = function(messageValidator, offset) {
|
| + var size = messageValidator.decodeUnionSize(offset);
|
| + if (size != 16) {
|
| + return validator.validationError.INVALID_UNION_SIZE;
|
| + }
|
| +
|
| + var tag = messageValidator.decodeUnionTag(offset);
|
| + var data_offset = offset + 8;
|
| + var err;
|
| + switch (tag) {
|
| + case RunOrClosePipeInput.Tags.peerAssociatedEndpointClosedEvent:
|
| +
|
| +
|
| + // validate RunOrClosePipeInput.peerAssociatedEndpointClosedEvent
|
| + err = messageValidator.validateStructPointer(data_offset, PeerAssociatedEndpointClosedEvent, false);
|
| + if (err !== validator.validationError.NONE)
|
| + return err;
|
| + break;
|
| + }
|
| +
|
| + return validator.validationError.NONE;
|
| + };
|
| +
|
| + RunOrClosePipeInput.encodedSize = 16;
|
| + var exports = mojo.internal.exposeNamespace("mojo.pipeControl2");
|
| + exports.kRunOrClosePipeMessageId = kRunOrClosePipeMessageId;
|
| + exports.RunOrClosePipeMessageParams = RunOrClosePipeMessageParams;
|
| + exports.DisconnectReason = DisconnectReason;
|
| + exports.PeerAssociatedEndpointClosedEvent = PeerAssociatedEndpointClosedEvent;
|
| + exports.RunOrClosePipeInput = RunOrClosePipeInput;
|
| +})();
|
|
|
Chromium Code Reviews
Issue 2789723003:
Migrate WebUSB LayoutTests into external/wpt (Closed)
