The Tor Browser: dom/wifi/StateMachine.jsm@6474c204b198 (annotated)

dom/wifi/StateMachine.jsm@6474c204b198 (annotated)

dom/wifi/StateMachine.jsm

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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 / annotate

dom/wifi/StateMachine.jsm@6474c204b198 (annotated)

dom/wifi/StateMachine.jsm