@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/_shumway_flash/media/VideoCodec.ts

@@ -0,0 +1,41 @@
+import { ASObject } from '../../avm2/nat';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: VideoCodec
+export class VideoCodec extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // [];
+
+	constructor () {
+		super();
+	}
+
+	// JS -> AS Bindings
+	static H264AVC: string = 'H264Avc';
+	static SORENSON: string = 'Sorenson';
+	static VP6: string = 'VP6';
+
+	// AS -> JS Bindings
+
+}

package/lib/_shumway_flash/media/VideoStatus.ts

@@ -0,0 +1,41 @@
+import { ASObject } from '../../avm2/nat';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: VideoStatus
+export class VideoStatus extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // [];
+
+	constructor () {
+		super();
+	}
+
+	// JS -> AS Bindings
+	static UNAVAILABLE: string = 'unavailable';
+	static SOFTWARE: string = 'software';
+	static ACCELERATED: string = 'accelerated';
+
+	// AS -> JS Bindings
+
+}

package/lib/_shumway_flash/media/VideoStreamSettings.ts

@@ -0,0 +1,56 @@
+import { ASObject } from '../../avm2/nat/ASObject';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: VideoStreamSettings
+export class VideoStreamSettings extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // ["width", "height", "fps", "quality", "bandwidth", "keyFrameInterval", "codec", "setMode", "setQuality", "setKeyFrameInterval"];
+
+	constructor () {
+		super();
+	}
+
+	// JS -> AS Bindings
+
+	width: number /*int*/;
+	height: number /*int*/;
+	fps: number;
+	quality: number /*int*/;
+	bandwidth: number /*int*/;
+	keyFrameInterval: number /*int*/;
+	codec: string;
+	setMode: (width: number /*int*/, height: number /*int*/, fps: number) => void;
+	setQuality: (bandwidth: number /*int*/, quality: number /*int*/) => void;
+	setKeyFrameInterval: (keyFrameInterval: number /*int*/) => void;
+
+	// AS -> JS Bindings
+
+	// _width: number /*int*/;
+	// _height: number /*int*/;
+	// _fps: number;
+	// _quality: number /*int*/;
+	// _bandwidth: number /*int*/;
+	// _keyFrameInterval: number /*int*/;
+	// _codec: string;
+}

package/lib/_shumway_flash/net/DynamicPropertyOutput.ts

@@ -0,0 +1,45 @@
+import { ASObject } from '../../avm2/nat';
+import { axCoerceString } from '../../avm2/run';
+import { notImplemented, release } from '../../base/utilities/Debug';
+import { IDynamicPropertyOutput } from './IDynamicPropertyOutput';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: DynamicPropertyOutput
+export class DynamicPropertyOutput extends ASObject implements IDynamicPropertyOutput {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // [];
+
+	constructor () {
+		super();
+	}
+
+	// JS -> AS Bindings
+
+	// AS -> JS Bindings
+
+	writeDynamicProperty(name: string, value: any): void {
+		name = axCoerceString(name);
+		release || notImplemented('packageInternal flash.net.DynamicPropertyOutput::writeDynamicProperty'); return;
+	}
+}

package/lib/_shumway_flash/net/FileFilter.ts

@@ -0,0 +1,66 @@
+import { axCoerceString } from '../../avm2/run/axCoerceString';
+import { ASObject } from '../../avm2/nat/ASObject';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: FileFilter
+
+export class FileFilter extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // [];
+
+	constructor (description: string, extension: string, macType: string = null) {
+		super();
+	}
+
+	// JS -> AS Bindings
+
+	// AS -> JS Bindings
+
+	private _description: string;
+	private _extension: string;
+	private _macType: string;
+	get description(): string {
+		return this._description;
+	}
+
+	set description(value: string) {
+		this._description = axCoerceString(value);
+	}
+
+	get extension(): string {
+		return this._extension;
+	}
+
+	set extension(value: string) {
+		this._extension = axCoerceString(value);
+	}
+
+	get macType(): string {
+		return this._macType;
+	}
+
+	set macType(value: string) {
+		this._macType = axCoerceString(value);
+	}
+}

package/lib/_shumway_flash/net/FileReferenceList.ts

@@ -0,0 +1,39 @@
+import { release, notImplemented } from '../../base/utilities/Debug';
+import { ASArray } from '../../avm2/nat/ASArray';
+import { EventDispatcher } from '../events/EventDispatcher';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: FileReferenceList
+export class FileReferenceList extends EventDispatcher {
+
+	static classInitializer: any = null;
+
+	constructor () {
+		super();
+	}
+
+	// _fileList: any [];
+	get fileList(): ASArray {
+		release || notImplemented('public flash.net.FileReferenceList::get fileList'); return;
+		// return this._fileList;
+	}
+
+	browse(typeFilter: ASArray = null): boolean {
+		typeFilter = typeFilter;
+		release || notImplemented('public flash.net.FileReferenceList::browse'); return;
+	}
+}

package/lib/_shumway_flash/net/GroupSpecifier.ts

@@ -0,0 +1,67 @@
+import { axCoerceString } from '../../avm2/run';
+import { ASObject } from '../../avm2/nat';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: GroupSpecifier
+export class GroupSpecifier extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // ["encodePostingAuthorization", "encodePublishAuthorization", "encodeIPMulticastAddressSpec", "encodeBootstrapPeerIDSpec"];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // ["makeUnique", "routingEnabled", "routingEnabled", "multicastEnabled", "multicastEnabled", "objectReplicationEnabled", "objectReplicationEnabled", "postingEnabled", "postingEnabled", "peerToPeerDisabled", "peerToPeerDisabled", "ipMulticastMemberUpdatesEnabled", "ipMulticastMemberUpdatesEnabled", "setPublishPassword", "setPostingPassword", "serverChannelEnabled", "serverChannelEnabled", "addBootstrapPeer", "addIPMulticastAddress", "toString", "groupspecWithoutAuthorizations", "groupspecWithAuthorizations", "authorizations"];
+
+	constructor (name: string) {
+		super();
+		name = axCoerceString(name);
+	}
+
+	// JS -> AS Bindings
+	static encodePostingAuthorization: (password: string) => string;
+	static encodePublishAuthorization: (password: string) => string;
+	static encodeIPMulticastAddressSpec: (address: string, port?: any, source?: string) => string;
+	static encodeBootstrapPeerIDSpec: (peerID: string) => string;
+
+	makeUnique: () => void;
+	routingEnabled: boolean;
+	multicastEnabled: boolean;
+	objectReplicationEnabled: boolean;
+	postingEnabled: boolean;
+	peerToPeerDisabled: boolean;
+	ipMulticastMemberUpdatesEnabled: boolean;
+	setPublishPassword: (password?: string, salt?: string) => void;
+	setPostingPassword: (password?: string, salt?: string) => void;
+	serverChannelEnabled: boolean;
+	addBootstrapPeer: (peerID: string) => void;
+	addIPMulticastAddress: (address: string, port?: any, source?: string) => void;
+	groupspecWithoutAuthorizations: () => string;
+	groupspecWithAuthorizations: () => string;
+	authorizations: () => string;
+
+	// AS -> JS Bindings
+
+	// _routingEnabled: boolean;
+	// _multicastEnabled: boolean;
+	// _objectReplicationEnabled: boolean;
+	// _postingEnabled: boolean;
+	// _peerToPeerDisabled: boolean;
+	// _ipMulticastMemberUpdatesEnabled: boolean;
+	// _serverChannelEnabled: boolean;
+}

package/lib/_shumway_flash/net/IDynamicPropertyOutput.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: IDynamicPropertyOutput
+export interface IDynamicPropertyOutput {
+
+	// JS -> AS Bindings
+
+	writeDynamicProperty: (name: string, value: any) => void;
+
+	// AS -> JS Bindings
+
+}

package/lib/_shumway_flash/net/IDynamicPropertyWriter.ts

@@ -0,0 +1,28 @@
+import { ASObject } from '../../avm2/nat';
+import { IDynamicPropertyOutput } from './IDynamicPropertyOutput';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: IDynamicPropertyWriter
+export interface IDynamicPropertyWriter {
+
+	// JS -> AS Bindings
+
+	writeDynamicProperties: (obj: ASObject, output: IDynamicPropertyOutput) => void;
+
+	// AS -> JS Bindings
+
+}

package/lib/_shumway_flash/net/LocalConnection.ts

@@ -0,0 +1,249 @@
+import { EventDispatcher } from '../events/EventDispatcher';
+import { ILocalConnectionReceiver, LocalConnectionService, LocalConnectionConnectResult } from '../../base/utilities/LocalConnectionService';
+import { getCurrentABC } from '../../avm2/run/getCurrentABC';
+import { axCoerceString } from '../../avm2/run/axCoerceString';
+import { axIsCallable } from '../../avm2/run/axIsCallable';
+import { axIsTypeString } from '../../avm2/run/axIsTypeString';
+import { ASObject } from '../../avm2/nat/ASObject';
+import { ASError } from '../../avm2/nat/ASError';
+import { ASArray } from '../../avm2/nat/ASArray';
+import { Errors } from '../../avm2/errors';
+import { assert, release, warning } from '../../base/utilities/Debug';
+import { ByteArray } from '../../avm2/natives/byteArray';
+import { AsyncErrorEvent } from '../events/AsyncErrorEvent';
+
+/**
+ * Copyright 2015 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const forbiddenNames = ['send', 'connect', 'close', 'allowDomain', 'allowInsecureDomain', 'client',
+	'domain'];
+Object.freeze(forbiddenNames);
+
+export class LocalConnection extends EventDispatcher
+	implements ILocalConnectionReceiver {
+
+	static classInitializer = null;
+
+	constructor () {
+		super();
+		this._client = this;
+		this._connectionName = null;
+		this._allowedInsecureDomains = [];
+		this._allowedSecureDomains = [];
+
+		// tsc contains a definition for URL that's non-constructible.
+		const url = new (<any>URL)(getCurrentABC().env.url);
+		this._domain = url.hostname;
+		this._secure = url.protocol === 'https:';
+	}
+
+	static get isSupported() {
+		return true;
+	}
+
+	private _domain: string;
+	private _secure: boolean;
+
+	private _client: ASObject;
+	private _connectionName: string;
+
+	// Required because allowDomain can be called before a connection is made.
+	private _allowedInsecureDomains: string[];
+	private _allowedSecureDomains: string[];
+
+	close(): void {
+		const connectionName = this._connectionName;
+		if (!connectionName) {
+			this.sec.throwError('ArgumentError', Errors.CloseNotConnectedError);
+		}
+		release || assert(typeof connectionName === 'string' && connectionName.length > 0);
+		this._connectionName = null;
+		// TODO: verify that these really are reset. For now, we aim to err on the safe side.
+		this._allowedInsecureDomains = [];
+		this._allowedSecureDomains = [];
+		LocalConnectionService.closeConnection(connectionName, this);
+	}
+
+	connect(connectionName: string): void {
+		connectionName = axCoerceString(connectionName);
+		if (connectionName === null) {
+			this.sec.throwError('TypeError', Errors.NullPointerError, 'connectionName');
+		}
+		if (connectionName === '') {
+			this.sec.throwError('TypeError', Errors.EmptyStringError, 'connectionName');
+		}
+		// The only disallowed character for the connection name is ":".
+		if (connectionName.indexOf(':') > -1) {
+			this.sec.throwError('ArgumentError', Errors.InvalidParamError);
+		}
+		if (this._connectionName) {
+			this.sec.throwError('ArgumentError', Errors.AlreadyConnectedError);
+		}
+		const result = LocalConnectionService.createConnection(connectionName, this);
+		if (result === LocalConnectionConnectResult.AlreadyTaken) {
+			this.sec.throwError('ArgumentError', Errors.AlreadyConnectedError);
+		}
+		this._connectionName = connectionName;
+		release || assert(result === LocalConnectionConnectResult.Success);
+		if (this._allowedInsecureDomains.length) {
+			LocalConnectionService.allowDomains(connectionName, this,
+				this._allowedInsecureDomains, false);
+		}
+		if (this._allowedSecureDomains.length) {
+			LocalConnectionService.allowDomains(connectionName, this,
+				this._allowedSecureDomains, true);
+		}
+	}
+
+	send(connectionName: string, methodName: string, ...args): void {
+		connectionName = axCoerceString(connectionName);
+		methodName = axCoerceString(methodName);
+		if (connectionName === null) {
+			this.sec.throwError('TypeError', Errors.NullPointerError, 'connectionName');
+		}
+		if (connectionName === '') {
+			this.sec.throwError('TypeError', Errors.EmptyStringError, 'connectionName');
+		}
+		if (methodName === null) {
+			this.sec.throwError('TypeError', Errors.NullPointerError, 'methodName');
+		}
+		if (methodName === '') {
+			this.sec.throwError('TypeError', Errors.EmptyStringError, 'methodName');
+		}
+		if (forbiddenNames.indexOf(methodName) > -1) {
+			this.sec.throwError('ArgumentError', Errors.InvalidParamError);
+		}
+		const serializedArgs = new ByteArray();
+		serializedArgs.writeObject(this.sec.createArrayUnsafe(args));
+		if (serializedArgs.length > 40 * 1024) {
+			this.sec.throwError('ArgumentError', Errors.ArgumentSizeError);
+		}
+		const argsBuffer = serializedArgs.getBytes().buffer;
+		try {
+			LocalConnectionService.send(connectionName, methodName, argsBuffer, this,
+				this._domain, this._secure);
+		} catch (e) {
+			// Not sure what to do here, this shouldn't happen. We'll just ignore it with a warning.
+			warning('Unknown error occurred in LocalConnection#send', e);
+		}
+	}
+
+	get client(): ASObject {
+		return this._client;
+	}
+
+	set client(client: ASObject) {
+		if (!this.sec.AXObject.axIsType(client)) {
+			this.sec.throwError('ArgumentError', Errors.InvalidParamError);
+		}
+		this._client = client;
+	}
+
+	allowDomain(...domains: string[]): void {
+		this._allowDomains(domains, true);
+	}
+
+	allowInsecureDomain(...domains: string[]): void {
+		// allowInsecureDomain also allows secure domains.
+		this._allowDomains(domains, true);
+		this._allowDomains(domains, false);
+	}
+
+	private _allowDomains(domains: string[], secure: boolean) {
+		let result: string[] = [];
+		// If no connection has been made yet, store the domains for later retrieval.
+		if (!this._connectionName) {
+			result = secure ? this._allowedSecureDomains : this._allowedInsecureDomains;
+		}
+		for (let i = 0; i < domains.length; i++) {
+			const domain = domains[i];
+			if (!axIsTypeString(domain)) {
+				this.sec.throwError('ArgumentError', Errors.AllowDomainArgumentError);
+			}
+			if (result.indexOf(domain) === -1) {
+				result.push(domain);
+			}
+		}
+		if (this._connectionName) {
+			LocalConnectionService.allowDomains(this._connectionName, this, domains, secure);
+		}
+	}
+
+	public handleMessage(methodName: string, argsBuffer: ArrayBuffer): void {
+		const client = this._client;
+		let error: ASError;
+		if (!client.axHasPublicProperty(methodName) || forbiddenNames.indexOf(methodName) > -1) {
+			// Forbidden names really shouldn't reach this point, but should everything else fail,
+			// we just pretend not to have found them here.
+			error = <any> this.sec.createError('ReferenceError', Errors.ReadSealedError, methodName,
+				client.axClass.name.name);
+		} else {
+			const handler = client.axGetPublicProperty(methodName);
+			if (!axIsCallable(handler)) {
+				// Non-callable handlers are just ignored.
+				return;
+			}
+
+			const ba: ByteArray = new ByteArray(argsBuffer);
+			const args: ASArray = ba.readObject();
+			if (!this.sec.AXArray.axIsType(args)) {
+				error =
+          <any> this.sec.createError('TypeError', Errors.CheckTypeFailedError, args, 'Array');
+			} else {
+				try {
+					handler.apply(client, args.value);
+				} catch (e) {
+					error = e;
+				}
+			}
+		}
+		if (!error) {
+			return;
+		}
+		const errorEvent = new AsyncErrorEvent('asyncError', false, false,
+			'Error #2095: flash.net.LocalConnection was' +
+                                              ' unable to invoke' +
+                                              ' callback ' + methodName + '.', error);
+		if (this.hasEventListener('asyncError')) {
+			try {
+				this.dispatchEvent(errorEvent);
+			} catch (e) {
+				console.warn('Exception encountered during asyncErrorEvent handling in ' +
+                      'LocalConnection sender.');
+			}
+		} else {
+			// TODO: add the error to the LoaderInfo#uncaughtErrorEvents list.
+			console.warn('No handler for asyncError on LocalConnection sender, not sending event',
+				errorEvent);
+		}
+	}
+
+	get domain(): string {
+		return this._domain;
+	}
+
+	get isPerUser(): boolean {
+		// We always return true, because everything else would be a lie.
+		return true;
+	}
+
+	set isPerUser(newValue: boolean) {
+		!!newValue;
+		// Ignored. See
+		// https://blogs.adobe.com/simplicity/2009/08/localconnectionisperuser_in_ai.html for an
+		// explanation.
+	}
+}