rollback

Former-commit-id: e0e1df351ab7bee444c72765ce42e1d0af571fb3

extension/lib/single-file/fetch/bg/fetch.js

@@ -25,76 +25,21 @@
 
 (() => {
 
-	const MAX_CONTENT_SIZE = 8 * (1024 * 1024);
-
-	const pendingRequests = [];
-
 	browser.runtime.onMessage.addListener((message, sender) => {
-		if (message.method == "singlefile.fetchRequest"
-			|| message.method == "singlefile.fetchFrameRequest"
-			|| message.method == "singlefile.bgFetchFrameResponse") {
-			return onMessage(message, sender);
+		if (message.method && message.method.startsWith("singlefile.fetch")) {
+			return new Promise(resolve => {
+				onRequest(message, sender)
+					.then(resolve)
+					.catch(error => resolve({ error: error.toString() }));
+			});
 		}
 	});
 
-	async function onMessage(message, sender) {
-		if (message.method == "singlefile.fetchRequest") {
-			return onRequest(message, sender);
-		} else if (message.method == "singlefile.fetchFrameRequest") {
-			message.bgId = pendingRequests.length;
-			browser.tabs.sendMessage(sender.tab.id, message);
-			pendingRequests.push({ tabId: sender.tab.id });
-		} else if (message.method == "singlefile.bgFetchFrameResponse") {
-			onFrameResponse(message);
-		}
-	}
-
-	async function onRequest(message, sender) {
-		if (message.method == "singlefile.fetchRequest") {
-			try {
-				const response = await fetchResource(message.url);
-				const id = message.id;
-				for (let blockIndex = 0; blockIndex * MAX_CONTENT_SIZE < response.array.length; blockIndex++) {
-					const message = {
-						method: "singlefile.fetchResponse",
-						id
-					};
-					message.truncated = response.array.length > MAX_CONTENT_SIZE;
-					if (message.truncated) {
-						message.finished = (blockIndex + 1) * MAX_CONTENT_SIZE > response.array.length;
-						message.array = Array.from(response.array.slice(blockIndex * MAX_CONTENT_SIZE, (blockIndex + 1) * MAX_CONTENT_SIZE));
-					} else {
-						message.array = Array.from(response.array);
-					}
-					if (!message.truncated || message.finished) {
-						message.headers = response.headers;
-						message.status = response.status;
-					}
-					browser.tabs.sendMessage(sender.tab.id, message);
-				}
-			} catch (error) {
-				await browser.tabs.sendMessage(sender.tab.id, {
-					method: "singlefile.fetchResponse",
-					id: message.id,
-					error: error.toString()
-				});
-			}
-		}
-	}
-
-	function onFrameResponse(message) {
-		const pendingRequest = pendingRequests[message.bgId];
-		if (pendingRequest) {
-			if (message.error) {
-				browser.tabs.sendMessage(pendingRequest.tabId, message);
-				pendingRequests[message.bgId] = null;
-			} else {
-				message.method = "singlefile.fetchFrameResponse";
-				browser.tabs.sendMessage(pendingRequest.tabId, message);
-				if (!message.truncated || message.finished) {
-					pendingRequests[message.bgId] = null;
-				}
-			}
+	function onRequest(message, sender) {
+		if (message.method == "singlefile.fetch") {
+			return fetchResource(message.url);
+		} else if (message.method == "singlefile.fetchFrame") {
+			return browser.tabs.sendMessage(sender.tab.id, message);
 		}
 	}
 
@@ -106,15 +51,11 @@
 			xhrRequest.onerror = event => reject(new Error(event.detail));
 			xhrRequest.onreadystatechange = () => {
 				if (xhrRequest.readyState == XMLHttpRequest.DONE) {
-					if (xhrRequest.status || xhrRequest.response.byteLength) {
-						resolve({
-							array: new Uint8Array(xhrRequest.response),
-							headers: { "content-type": xhrRequest.getResponseHeader("Content-Type") },
-							status: xhrRequest.status
-						});
-					} else {
-						reject();
-					}
+					resolve({
+						array: Array.from(new Uint8Array(xhrRequest.response)),
+						headers: { "content-type": xhrRequest.getResponseHeader("Content-Type") },
+						status: xhrRequest.status
+					});
 				}
 			};
 			xhrRequest.open("GET", url, true);

extension/lib/single-file/fetch/content/content-fetch.js

@@ -25,84 +25,30 @@
 
 this.singlefile.extension.lib.fetch.content.resources = this.singlefile.extension.lib.fetch.content.resources || (() => {
 
-	const MAX_CONTENT_SIZE = 8 * (1024 * 1024);
 	const FETCH_REQUEST_EVENT = "single-file-request-fetch";
 	const FETCH_RESPONSE_EVENT = "single-file-response-fetch";
 
-	const pendingRequests = [];
-
 	browser.runtime.onMessage.addListener(message => {
-		if ((message.method == "singlefile.fetchFrameRequest" && window.frameId && window.frameId == message.frameId)
-			|| message.method == "singlefile.fetchResponse"
-			|| message.method == "singlefile.fetchFrameResponse") {
+		if (message.method == "singlefile.fetchFrame" && window.frameId && window.frameId == message.frameId) {
 			return onMessage(message);
 		}
 	});
 
 	async function onMessage(message) {
-		if (message.method == "singlefile.fetchFrameRequest") {
-			try {
-				let response = await fetch(message.url, { cache: "force-cache" });
-				if (response.status == 403 || response.status == 404) {
-					response = hostFetch(message.url);
-				}
-				const array = new Uint8Array(await response.arrayBuffer());
-				const { id, bgId } = message;
-				for (let blockIndex = 0; blockIndex * MAX_CONTENT_SIZE < array.length; blockIndex++) {
-					const message = {
-						method: "singlefile.bgFetchFrameResponse",
-						id,
-						bgId
-					};
-					message.truncated = array.length > MAX_CONTENT_SIZE;
-					if (message.truncated) {
-						message.finished = (blockIndex + 1) * MAX_CONTENT_SIZE > array.length;
-						message.array = Array.from(array.slice(blockIndex * MAX_CONTENT_SIZE, (blockIndex + 1) * MAX_CONTENT_SIZE));
-					} else {
-						message.array = Array.from(array);
-					}
-					const headers = {};
-					response.headers.forEach((value, key) => headers[key] = value);
-					if (!message.truncated || message.finished) {
-						message.headers = headers;
-						message.status = response.status;
-					}
-					browser.runtime.sendMessage(message);
-				}
-			} catch (error) {
-				await browser.runtime.sendMessage({
-					method: "singlefile.bgFetchFrameResponse",
-					id: message.id,
-					error: error.toString()
-				});
-			}
-		} else if (message.method == "singlefile.fetchResponse" || message.method == "singlefile.fetchFrameResponse") {
-			const pendingRequest = pendingRequests[message.id];
-			if (pendingRequest) {
-				if (message.error) {
-					pendingRequest.reject(new Error(message.error.toString()));
-					pendingRequests[message.id] = null;
-				} else {
-					if (message.truncated) {
-						if (!pendingRequest.responseArray) {
-							pendingRequest.responseArray = [];
-						}
-						pendingRequest.responseArray = pendingRequest.responseArray.concat(message.array);
-					} else {
-						pendingRequest.responseArray = message.array;
-					}
-					if (!message.truncated || message.finished) {
-						pendingRequest.resolve({
-							status: message.status,
-							headers: {
-								get: headerName => message.headers[headerName]
-							},
-							arrayBuffer: async () => new Uint8Array(pendingRequest.responseArray).buffer
-						});
-						pendingRequests[message.id] = null;
-					}
-				}
+		try {
+			let response = await fetch(message.url, { cache: "force-cache" });
+			if (response.status == 403) {
+				response = hostFetch(message.url);
 			}
+			return {
+				status: response.status,
+				headers: [...response.headers],
+				array: Array.from(new Uint8Array(await response.arrayBuffer()))
+			};
+		} catch (error) {
+			return {
+				error: error.toString()
+			};
 		}
 	}
 
@@ -116,16 +62,40 @@ this.singlefile.extension.lib.fetch.content.resources = this.singlefile.extensio
 				return response;
 			}
 			catch (error) {
-				browser.runtime.sendMessage({ method: "singlefile.fetchRequest", url, id: pendingRequests.length });
-				return new Promise((resolve, reject) => pendingRequests.push({ resolve, reject }));
+				const response = await sendMessage({ method: "singlefile.fetch", url });
+				return {
+					status: response.status,
+					headers: { get: headerName => response.headers[headerName] },
+					arrayBuffer: async () => new Uint8Array(response.array).buffer
+				};
 			}
 		},
 		frameFetch: async (url, frameId) => {
-			browser.runtime.sendMessage({ method: "singlefile.fetchFrameRequest", url, frameId, id: pendingRequests.length });
-			return new Promise((resolve, reject) => pendingRequests.push({ resolve, reject }));
+			const response = await sendMessage({ method: "singlefile.fetchFrame", url, frameId });
+			return {
+				status: response.status,
+				headers: {
+					get: headerName => {
+						const headerArray = response.headers.find(headerArray => headerArray[0] == headerName);
+						if (headerArray) {
+							return headerArray[1];
+						}
+					}
+				},
+				arrayBuffer: async () => new Uint8Array(response.array).buffer
+			};
 		}
 	};
 
+	async function sendMessage(message) {
+		const response = await browser.runtime.sendMessage(message);
+		if (!response || response.error) {
+			throw new Error(response && response.error.toString());
+		} else {
+			return response;
+		}
+	}
+
 	function hostFetch(url) {
 		return new Promise((resolve, reject) => {
 			dispatchEvent(new CustomEvent(FETCH_REQUEST_EVENT, { detail: url }));