Deleted X-UA-Compatible meta tag

.gitignore

@@ -19,3 +19,4 @@ coverage/
 test_data/
 test-results/
 yarn-error.log
+_package/

__sandbox__/test.js

@@ -0,0 +1,219 @@
+const cp = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const rpc = require("vscode-jsonrpc");
+
+let bootstrapForkPath = path.join(__dirname, "..", "out", "bootstrap-fork.js");
+
+// test("extension host process gets initialized", async () => {
+
+let run = async () => {
+
+    let childProcess = cp.spawn("node", [bootstrapForkPath, "--type=extensionHost"], {
+        env: {
+            ...process.env,
+            "AMD_ENTRYPOINT": "vs/workbench/services/extensions/node/extensionHostProcess",
+        },
+        stdio: ["pipe", "pipe", "inherit"]
+    });
+
+    let connection = rpc.createMessageConnection(
+        new rpc.StreamMessageReader(childProcess.stdout),
+        new rpc.StreamMessageWriter(childProcess.stdin)
+    );
+
+    let promise = new Promise((c) => {
+
+        let testNotification = new rpc.NotificationType('host/msg');
+        connection.onNotification(testNotification, (msg) => {
+            console.log("INCOMING MESSAGE: " + JSON.stringify(msg));
+
+            let message = msg;
+            if (message.reqId > 0) {
+                connection.sendNotification('ext/msg', {
+                    type: 12, /*ReplyOKJSON */
+                    reqId: message.reqId,
+                    payload: null,
+                });
+            }
+
+            c();
+        });
+
+    });
+    connection.listen();
+
+    let extensionPath = path.join(__dirname, "..", "test_extensions", "oni-lsp-extension", "package.json")
+    let testExtension = JSON.parse(fs.readFileSync(extensionPath));
+
+    testExtension.main = path.join(path.dirname(extensionPath), testExtension.main);
+
+    let extMessage = new rpc.NotificationType('ext/msg');
+    connection.sendNotification(extMessage, {
+        type: 0,
+        reqId: 1,
+        payload: {
+            // extensions: [],
+            extensions: [{
+                ...testExtension,
+                identifier: "lsp-sample",
+                extensionLocationPath: path.dirname(extensionPath),
+            }],
+            parentPid: process.pid,
+            environment: {
+                globalStorageHomePath: require("os").tmpdir(),
+            },
+            workspace: {},
+            logsLocationPath: require("os").tmpdir(),
+            autoStart: true,
+        }
+    });
+
+    connection.sendNotification(extMessage, {
+        type: 4, /* RequestJSONArgs */
+        reqId: 2,
+        payload: ["ExtHostConfiguration", "$initializeConfiguration", [{
+                defaults: {
+                    contents: {
+                        suggest: {
+                            enabled: true
+                        },
+                        terminal: {
+                            integrated: {
+                                env: {
+                                    windows: {},
+                                    linux: {},
+                                    osx: {},
+                                }
+                            }
+                    }
+                    },
+                    keys: ["suggest.enabled", "terminal.integrated"],
+                    overrides: [],
+                },
+                user: {},
+                workspace: {},
+                folders: {},
+                isComplete: true,
+                configurationScopes: {},
+
+        }]],
+    });
+
+    connection.sendNotification(extMessage, {
+        type: 4, /* RequestJSONArgs */
+        reqId: 2,
+        payload: ["ExtHostWorkspace", "$initializeWorkspace", [{
+            id: "workspace-test",
+            name: "workspace-test",
+            configuration: null,
+            folders: [],
+        }]],
+    });
+
+    await promise;
+    // setTimeout(() => {
+    //     connection.sendNotification(extMessage, {
+    //         type: 4,
+    //         reqId: 3,
+    //         payload: ["ExtHostCommands", "$executeContributedCommand", ["extension.helloWorld"]],
+    //     });
+    // }, 1000);
+
+
+    setTimeout(() => {
+
+        console.log("SENDING MESSAGE");
+        connection.sendNotification(extMessage, {
+            type: 4,
+            reqId: 3,
+            payload: ["ExtHostTerminalService", "$createProcess", [
+                    1, {
+                        name: "Terminal 1",
+                        executable: "/non-existent-item",
+                        args: [],
+                    },{
+                        //scheme: "file",
+                        //path: "/Users/bryphe"
+                    },
+                    20,
+                    20
+            ]]
+        });
+        connection.sendNotification(extMessage, {
+            type: 4,
+            reqId: 3,
+            payload: ["ExtHostTerminalService", "$acceptProcessInput", [
+                    1, "git status\n"
+            ]]
+        });
+    }, 2000);
+
+    let testModelAdded = {
+        uri: {
+            scheme: "file",
+            path: "D:/test1.txt",
+        },
+        lines: ["hello", "world"],
+        EOL: "\n",
+        modeId: "plaintext",
+        isDirty: true,
+    };
+
+    let update = {
+        removedDocuments: [],
+        addedDocuments: [testModelAdded],
+        removedEditors: [],
+        addedEditors: [],
+        newActiveEditor: null,
+    };
+
+
+    /*setTimeout(() => {
+        connection.sendNotification(extMessage, {
+            type: 4,
+            reqId: 3,
+            payload: ["ExtHostDocumentsAndEditors", "$acceptDocumentsAndEditorsDelta", [update]],
+        });
+    }, 1000);
+    setTimeout(() => {
+
+        let changedEvent = {
+            changes: [{
+                range: {
+                    startLineNumber: 1,
+                    endLineNumber: 1,
+                    startColumn: 1,
+                    endColumn: 6,
+                },
+                text: "GREETINGS",
+            }],
+            eol: "\n",
+            versionId: 100,
+        };
+
+        connection.sendNotification(extMessage, {
+            type: 4,
+            reqId: 4,
+            payload: ["ExtHostDocuments", "$acceptModelChanged", [
+                testModelAdded.uri,
+                changedEvent,
+                true,
+            ]],
+        });
+    }, 2000);*/
+
+    let closePromise = new Promise((c) => {
+        connection.onClose(() => c());
+    })
+
+    // connection.sendNotification(extMessage, {
+    //     type: 1,
+    //     payload: null,
+    // });
+
+    await closePromise;
+};
+
+run();
+// }, 10000);

__tests__/Activation.Test.ts

@@ -0,0 +1,73 @@
+import * as path from "path";
+
+import * as ExtensionHost from "./ExtensionHost";
+
+let extensionPath = path.join(__dirname, "..", "test_extensions", "oni-api-tests", "package.json");
+let activationExtensionPath = path.join(__dirname, "..", "test_extensions", "oni-activation-events-tests", "package.json");
+
+describe("activation", () => {
+	test("get activation event for '*' activation type", async () => {
+		await ExtensionHost.withExtensionHost([extensionPath], async (api) => {
+		let promise = new Promise((c) => {
+
+				api.onMessage.subscribe(msg => {
+					const { payload } = msg;
+
+					if(payload.methodName == "$onDidActivateExtension") {
+						console.dir(payload);
+						c();
+					}
+				});
+
+			});
+
+			await api.start();
+
+			await promise;
+		});
+	});
+
+	test("activates in response to onLanguage event", async () => {
+		await ExtensionHost.withExtensionHost([activationExtensionPath], async (api) => {
+		let promise = new Promise((c) => {
+
+				api.onMessage.subscribe(msg => {
+					const { payload } = msg;
+
+					if(payload.methodName == "$onDidActivateExtension") {
+						console.dir(payload);
+						c();
+					}
+				});
+
+			});
+
+			await api.start();
+
+            api.sendNotification(["ExtHostExtensionService", "$activateByEvent", ["onLanguage:testlang"]]);
+			await promise;
+		});
+	});
+
+	test("activates in response to onLanguage event", async () => {
+		await ExtensionHost.withExtensionHost([activationExtensionPath], async (api) => {
+		let promise = new Promise((c) => {
+
+				api.onMessage.subscribe(msg => {
+					const { payload } = msg;
+
+					if(payload.methodName == "$onDidActivateExtension") {
+						console.dir(payload);
+						c();
+					}
+				});
+
+			});
+
+			await api.start();
+
+            api.sendNotification(["ExtHostExtensionService", "$activateByEvent", ["onCommand:extension.helloWorld"]]);
+			await promise;
+		});
+	});
+});

__tests__/Commands.Test.ts

@@ -0,0 +1,32 @@
+import * as path from "path";
+
+import * as ExtensionHost from "./ExtensionHost";
+
+let extensionPath = path.join(__dirname, "..", "test_extensions", "oni-api-tests", "package.json");
+
+describe("commands", () => {
+    test("execute basic command", async () => {
+        await ExtensionHost.withExtensionHost([extensionPath], async (api) => {
+
+            /*
+             * Upon activation, we should get a notification from the extension host
+             * that the 'extension.helloWorld' command is available.
+             */
+            let commandRegistrationPromise = api.waitForMessageOnce("MainThreadCommands", "$registerCommand", (args) => args.indexOf("extension.helloWorld") >= 0);
+
+            let showMessagePromise = api.waitForMessageOnce("MainThreadMessageService", "$showMessage");
+
+            await api.start();
+
+            // Wait for the 'extension.helloWorld' command to be registered...
+            await commandRegistrationPromise;
+
+            // ...otherwise this call will fail.
+            api.sendNotification(
+                ["ExtHostCommands", "$executeContributedCommand", ["extension.helloWorld"]]
+            );
+
+            await showMessagePromise;
+        });
+    });
+});