refactored syntax

chromium.js

-
 class HeadlessChromium
 {
-	constructor(websocketUrl)
+	constructor(websocket)
 	{
-		this.websocketUrl = websocketUrl
-		this.websocket = new WebSocket(websocketUrl)
+		this.websocket = websocket
 	}
 
-	isConnected()
+	async runCommand(command, params = {})
 	{
-		return this.websocket.readyState == WebSocket.OPEN
+		return new Promise((resolve, reject) => {
+			var server = new WebSocket(this.websocket)
+
+			server.onopen = () => {
+				var message = {id: 0, method: command, params: params}
+				server.send(JSON.stringify(message))
 			}
 
-	runCommand(method, params = {}, callback)
+			server.onmessage = (response) => {
+				server.close()
+				var data = JSON.parse(response.data)
+
+				if ('result' in data)
 				{
-		var command = {id: 0, method: method, params: params}
-		this.websocket.send(JSON.stringify(command))
-		this.websocket.onmessage = (response) => {		
-			callback(JSON.parse(response.data))
-		}
+					resolve(data.result)
 				}
 	
-	openNewPage(url, callback)
+				if ('error' in data)
 				{
-		this.runCommand("Target.createTarget", {url: url}, (response) => {
-			callback(response.result.targetId)
+					reject(data.error)
+				}
+
+				reject(data)
+			}
+
+			server.onerror = (error) => {
+				server.close()
+				reject(error)
+			}
 		})
 	}
 
-	closePage(page, callback)
+	async getVersion()
 	{
-		this.runCommand("Target.closeTarget", {targetId: page}, (response) => {
-			callback()
-		})
+		return await this.runCommand("Browser.getVersion")
 	}
 
-	focusPage(page, callback)
+	async enableDOM()
 	{
-		this.runCommand("Target.activateTarget", {targetId: page}, (response) => {
-			this.runCommand("Target.attachToTarget", {targetId:page}, (response) => {
-				callback()
-			})
-		})
+		return await this.runCommand("DOM.enable")
 	}
 
-	// todo: does not work yet
-	printToPdf(callback)
+	async enableNetwork()
 	{
-		this.runCommand("Page.enable", {}, (ignored) => {
-			console.log("Page.enable: " + JSON.stringify(ignored))
-			this.runCommand("Page.printToPDF", {}, (response) => {
-				console.log("Page.printToPDF:" +  JSON.stringify(response))
-			})
-		})
+		return await this.runCommand("Network.enable")
 	}
-}
 
+	async enablePage()
+	{
+		return await this.runCommand("Page.enable")
+	}
+
+	async openNewPage(url)
+	{
+		var response = await this.runCommand("Target.createTarget", {url: url})
+		return response.targetId
+	}
+
+	async closePage(page)
+	{
+		var response = await this.runCommand("Target.closeTarget", {targetId: page})
+		return response.success
+	}
+
+	async focusPage(page)
+	{
+		await this.runCommand("Target.activateTarget", {targetId: page})
+	}
+
+	async printToPdf()
+	{
+		var response = await this.runCommand("Page.printToPDF")
+		return response
+	}
+}

connection.js

-
-function test()
-{
-	return "test"
-}
-

index.html

@@ -10,34 +10,28 @@
     		var searchParams = (new URL(window.location.href)).searchParams
     		var websocketUrl = searchParams.get("websocket")
     		var browser = new HeadlessChromium(websocketUrl)
+			var urls = ["https://www.example.com"] 
 
-    		function html2pdf(url, callback)
+    		async function html2pdf(url)
     		{
-    			if (!browser.isConnected())
-    			{
-    				console.log("Browser is not connected!")
-    				callback(null)
-    				return
+				var page = await browser.openNewPage(url)
+				await browser.focusPage(page)
+				var pdf = browser.printToPdf()
+				await browser.closePage(page)
+				return pdf
     		}
     		
-    			browser.openNewPage(url, (page) => {
-    				browser.focusPage(page, () => {
-    					browser.printToPdf(() => {
-					 		browser.closePage(page, () => {
-					 			console.log("close")
-					 		})
-					 	})
-       				})
-    			})
+    		async function mainloop()
+    		{
+				if (urls.length == 0)
+				{
+					setTimeout(mainloop, 30 /* seconds */ * 1000)
+					return
 				}
 
-    		function mainloop()
-    		{
-				html2pdf("http://www.example.com", (pdf) => {
+				var pdf = await html2pdf(urls.pop())
 				console.log(pdf)
-					
-					setTimeout(mainloop, 5 /* seconds */ * 1000) 
-				})
+				setTimeout(mainloop, 3 /* seconds */ * 1000)
     		}
     		mainloop()
     	</script>