chrome native messaging: how to receive > 1MB

问题

What would be a good way to work with Chrome's incoming 1MB limit for native messaging extensions? The data that we would be sending to the extension is json-serialized gpx, if that matters.

When the original message is >1MB, it seems like this question really has two parts:

1. how to partition the data on the sending end (i.e. the client)

   this part should be pretty trivial. Even if we need to split into separate self-contained complete gpx strings, that is pretty straightforward.

2. how to join the <1MB messages back in to the original >1MB

   is there a standard known solution for this question? We can call background.js (ie. the function passed to chrome.runtime.onMessageExternal.addListener) once for each <1MB incoming message, but, how would we combine the strings from those repeated calls in to one response for the extension?

UPDATE 8-18-16: what we've been doing is just appending each message 'chunk' on a buffer variable in background.js, and not send it back to Chrome until disconnection:

		var gpxText="";
		port.onMessage.addListener(function(msg) {
			// msg must be a JSON-serialized simple string;
			//  append each incoming msg to the collective gpxText string
			//  but do not send it to Chrome until disconnection
//			console.log("received " + msg);
			gpxText+=msg;
		});
		port.onDisconnect.addListener(function(msg) {
			if (gpxText!="") {
				sendResponse(JSON.parse(gpxText));
				gpxText="";
			} else {
				sendResponse({status: 'error', message: 'something really bad happened'});
			}
// build the response object here with msg, status, error tokens, and always send it
			console.log("disconnected");
         });

We will have to make that appending a bit smarter to handle and send both status and message keys/values, but that should be easy.

回答1:

I have this same issue and have been scouring the web for the past couple days to figure out something to do. In my application, I am currently shipping a JSON string over to the background script in chunks, having to create a subprotocol to handle this special case. e.g. my initial question might look like:

{action:"getImage",guid:"123"}

and the response for <1MB might look like:

{action:"getImage",guid:"123",status:"success",return:"ABBA..."}

where ABBA... represents a base64 encoding of the bytes. when >1MB, however, the response will look like:

{action:"getStream",guid:"123",status:"success",return:"{action:\"getImage\",guid:\"123\",return:\"ABBA...",more:true}

and upon receipt of the payload with method==='stream', the background page will immediately issue a new request like:

{action:"getStream",guid:"123"}

and the next response might look like:

{action:"getStream",guid:"123",status:"success",return:"...DEAF==",more:false}

so your onMessage handler would look something like:

var streams;

function onMessage( e ) {
   var guid = e.guid;

   if ( e.action === 'getStream' ) {
      if ( !streams[ guid ] ) streams[ guid ] = '';
      streams[ guid ] += e[ 'return' ];

      if ( e.more ) {
         postMessage( { action: 'getStream', guid: guid } );
         // no more processing to do here, bail
         return;
      }

      e = JSON.parse( streams[ guid ] );
      streams[ guid ] = null;
   }

   // do something with e as if it was never chunked
   ...
}

it works, but I am somewhat convinced that it is slower than it should be (though this could be due to the slow feeling of the STDIO signaling and, in my particular app, additional signaling that has to happen for each new chunk).

Ideally I'd like to stream the file in a more efficient protocol supported natively by Chrome. I looked into WebRTC, but it would mean that I'd need to implement the API into my native messaging host (as best I can tell), which is not an option I'm willing to take on. I played with 'passing' the contents by file as such:

if ( e.action = 'getFile' ) {
   xhr = new XMLHttpRequest();
   xhr.onreadystatechange = function( e ) {
      if ( e.target.readyState === 4 ) {
         onMessage( e.target.responseText );
      }
   };
   xhr.open( 'GET', chrome.extension.getURL( '/' + e.file ), true );
   xhr.send();

   return;
}

where I have my native message host write a .json file out to extension's install directory and it seems to work, but there is no way for me to reliably derive the path (without fudging things and hoping for the best), because as best I can the location of the extensions install path is determined by your Chrome user profile and there's no API I could find to give me that path. Additionally, there's a 'version' folder created under your extension id which includes an _0 that I don't know how to calculate (is the _0 constant for some future use? does it tick up when an extension is published anew to the web store, but the version is not adjusted?).

At this point I'm out of ideas and I'm hoping someone will stumble across this question with some guidance.

来源：https://stackoverflow.com/questions/35640924/chrome-native-messaging-how-to-receive-1mb