gistfile1.js

// Represents what we send back to the client.
// This is handed down to each individual command
// which is allowed to manipulate it using the getters and setters.
var Response = function(respHandler, opt_msg, opt_sanitizer) {
	let sanitizer = function(map) {
		let rv = {};
		for (var [key, value] of map) {
			if ((typeof value !== undefined) || value !== null)
				rv[key] = value;
		}
		return rv;
	};

	this.respHandler = respHandler;
	this.sanitizer = opt_sanitizer || sanitizer;

	let msg = opt_msg || {};
	this.data = {
		name: msg ? msg.name : "Unknown command",
		sessionId: "sessionId" in msg ? msg["sessionId"] : null,
		status: "success",
		value: null
	};
};

Response.prototype = {
	send: function() {
		var rawData = this.sanitizer(this.data);
		this.respHandler(rawData);
	},
	
	sendError: function(exc) {
		this.status = (e instanceof WebDriverError) ? exc.code : "unknown error";
		this.value = errors.toJSON(exc);
		this.send();
	},
	
	set name(n) { this.data.name = name },
	get name() { return this.data.name },
	get sessionId() { return this.data.sessionId },
	set sessionId(id) { this.data.sessionId = sessionId },
	set status(ns) { this.data.status = ns },
	get status() { return this.data.status },
	set value(val) { this.data.value = val },
	get value() { return this.data.val }
};

// CommandProcessor receives messages on execute(…) from Dispatcher,
// processes them, and passes them along to MarionetteServer.
var CommandProcessor = function(marionetteServer) {
	this.driver = marionetteServer;
};

CommandProcessor.prototype.unmarshal = function(payload) {
	try {
		return JSON.parse(payload);
	} catch (e) {
		throw new UnknownError("Error parsing payload: " + payload);
	}
};

CommandProcessor.prototype.execute = function(payload, respHandler) {
	let msg, resp;
	try {
		msg = this.unmarshal(payload);
		resp = new Response(respHandler, msg);
		this.driver[msg.name](msg.parameters, resp);
	} catch (e) {
		response.sendError(e);
	}
};

// Responsible for handling content side commands.
function MarionetteListener() {
	this.startListeners();
}

MarionetteListener.prototype.startListeners = function() {
	addMessageListenerId("Marionette:getCurrentUrl", this.dispatch(this.getCurrentUrl));
};

MarionetteListener.prototype.dispatch = function(func) {
	return function(msg) {
		// msg is an IPC construct from the message manager
		// that contains the data passed from MarionetteServer:
		//    {commandId: "abc", data: {"value": "foo"}}
		let params = msg.data.value;
		func(params, resp);
		
		// Possibly we have to marshal resp here:
		sendAsyncMessage("Marionette:done", resp, msg.commandId);
	};
};

MarionetteListener.prototype.getCurrentUrl = function(cmd, resp) {
	resp.value = curFrame.location.href;
};

var commandSeq = 0;  // global

// Transparenly proxies any method you call on it to the listener.
var ListenerProxy = function() {
	__noSuchMethod__: function (name, args) {
		let msg = args;
		msg.commandId = commandSeq++;
		this.messageManager.sendAsyncMessage("Marionette:" + name, msg);
	}
};

// Responsible for handling chrome side commands,
// like today's MarionetteServerConnection,
// and forwarding content side things to the listener.
function MarionetteServer() {
	this.listener = new ListenerProxy();
}

MarionetteServer.prototype.getCurrentUrl = function(cmd, resp) {
	switch (this.context) {
	case Context.CHROME:
		resp.value = this.getCurrentWindow().location.href;
		break;
	case Context.B2G:
		resp.value = this.listener.getCurrentUrl();
		break;
	case Context.CONTENT:
		resp.value = this.curBrowser.tab.linkedContent.contentWindow.location.href;
		break;
	}
};

// Makes out what is currently MarionetteServerConnection.receiveMessage et.al.
function Dispatcher() {
	this.conn = …
	this.driver = new MarionetteServer();
	this.commandProcessor = new CommandProcessor(this.driver);
}

// When we receive data on the socket from the client.
// Data format is Marionette protocol,
// that is a string with a slightly modified JSON structure.
Dispatcher.prototype.onPacket: function(packet) {
	// TOOD: unmarshal transport packet
	this.commandProcessor.execute(rawData, this.send);
};

// Triggered on message from listener.
// This data comes as a stringified JSON object.
Dispatcher.prototype.receiveMessage = function(msg) {
	switch (msg.name) {
	case "Marionette:done":
		this.send(msg);
		break;
	}
};

// Callback from commands as well as messages from listener
// This message is marshaled and sent back to the client.
Dispatcher.prototype.send = function(message) {
	let payload = JSON.stringify(message);
	this.conn.send(payload);
};



// Data received on the socket _or_ from listener
var data = "{name: 'getCurrentUrl', sessionId: '666'}";

// Fake some data received on socket or via IPC from listener
var dispatcher = new Dispatcher();
dispatcher.receiveMessage(data);