The Tor Browser: comparison dom/wifi/StateMachine.jsm

--1:000000000000
+:c8605ed10317
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this file,
+* You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+Cu.import("resource://gre/modules/Services.jsm");
+this.EXPORTED_SYMBOLS = ["StateMachine"];
+const DEBUG = false;
+this.StateMachine = function(aDebugTag) {
+function debug(aMsg) {
+dump('-------------- StateMachine:' + aDebugTag + ': ' + aMsg);
+}
+var sm = {};
+var _initialState;
+var _curState;
+var _prevState;
+var _paused;
+var _eventQueue = [];
+var _deferredEventQueue = [];
+var _defaultEventHandler;
+// Public interfaces.
+sm.setDefaultEventHandler = function(aDefaultEventHandler) {
+_defaultEventHandler = aDefaultEventHandler;
+};
+sm.start = function(aInitialState) {
+_initialState = aInitialState;
+sm.gotoState(_initialState);
+};
+sm.sendEvent = function (aEvent) {
+if (!_initialState) {
+if (DEBUG) {
+debug('StateMachine is not running. Call StateMachine.start() first.');
+}
+return;
+}
+_eventQueue.push(aEvent);
+asyncCall(handleFirstEvent);
+};
+sm.getPreviousState = function() {
+return _prevState;
+};
+sm.getCurrentState = function() {
+return _curState;
+};
+// State object maker.
+// @param aName string for this state's name.
+// @param aDelegate object:
+//    .handleEvent: required.
+//    .enter: called before entering this state (optional).
+//    .exit: called before exiting this state (optional).
+sm.makeState = function (aName, aDelegate) {
+if (!aDelegate.handleEvent) {
+throw "handleEvent is a required delegate function.";
+}
+var nop = function() {};
+return {
+name: aName,
+enter: (aDelegate.enter || nop),
+exit: (aDelegate.exit || nop),
+handleEvent: aDelegate.handleEvent
+};
+};
+sm.deferEvent = function (aEvent) {
+// The definition of a 'deferred event' is:
+//     We are not able to handle this event now but after receiving
+//     certain event or entering a new state, we might be able to handle
+//     it. For example, we couldn't handle CONNECT_EVENT in the
+//     diconnecting state. But once we finish doing "disconnecting", we
+//     could then handle CONNECT_EVENT!
+//
+// So, the deferred event may be handled in the following cases:
+//     1. Once we entered a new state.
+//     2. Once we handled a regular event.
+if (DEBUG) {
+debug('Deferring event: ' + JSON.stringify(aEvent));
+}
+_deferredEventQueue.push(aEvent);
+};
+// Goto the new state. If the current state is null, the exit
+// function won't be called.
+sm.gotoState = function (aNewState) {
+if (_curState) {
+if (DEBUG) {
+debug("exiting state: " + _curState.name);
+}
+_curState.exit();
+}
+_prevState = _curState;
+_curState = aNewState;
+if (DEBUG) {
+debug("entering state: " + _curState.name);
+}
+_curState.enter();
+// We are in the new state now. We got a chance to handle the
+// deferred events.
+handleDeferredEvents();
+sm.resume();
+};
+// No incoming event will be handled after you call pause().
+// (But they will be queued.)
+sm.pause = function() {
+_paused = true;
+};
+// Continue to handle incoming events.
+sm.resume = function() {
+_paused = false;
+asyncCall(handleFirstEvent);
+};
+//----------------------------------------------------------
+// Private stuff
+//----------------------------------------------------------
+function asyncCall(f) {
+Services.tm.currentThread.dispatch(f, Ci.nsIThread.DISPATCH_NORMAL);
+}
+function handleFirstEvent() {
+var hadDeferredEvents;
+if (0 === _eventQueue.length) {
+return;
+}
+if (_paused) {
+return; // The state machine is paused now.
+}
+hadDeferredEvents = _deferredEventQueue.length > 0;
+handleOneEvent(_eventQueue.shift()); // The handler may defer this event.
+// We've handled one event. If we had deferred events before, now is
+// a good chance to handle them.
+if (hadDeferredEvents) {
+handleDeferredEvents();
+}
+// Continue to handle the next regular event.
+handleFirstEvent();
+}
+function handleDeferredEvents() {
+if (_deferredEventQueue.length && DEBUG) {
+debug('Handle deferred events: ' + _deferredEventQueue.length);
+}
+for (let i = 0; i < _deferredEventQueue.length; i++) {
+handleOneEvent(_deferredEventQueue.shift());
+}
+}
+function handleOneEvent(aEvent)
+{
+if (DEBUG) {
+debug('Handling event: ' + JSON.stringify(aEvent));
+}
+var handled = _curState.handleEvent(aEvent);
+if (undefined === handled) {
+throw "handleEvent returns undefined: " + _curState.name;
+}
+if (!handled) {
+// Event is not handled in the current state. Try handleEventCommon().
+handled = (_defaultEventHandler ? _defaultEventHandler(aEvent) : handled);
+}
+if (undefined === handled) {
+throw "handleEventCommon returns undefined: " + _curState.name;
+}
+if (!handled) {
+if (DEBUG) {
+debug('!!!!!!!!! FIXME !!!!!!!!! Event not handled: ' + JSON.stringify(aEvent));
+}
+}
+return handled;
+}
+return sm;
+};

The Tor Browser / file comparison

comparison: dom/wifi/StateMachine.jsm

dom/wifi/StateMachine.jsm