Add m-esr52 at 52.6.0

1 files changed, 1649 insertions, 0 deletions

diff --git a/dom/wifi/WifiP2pManager.jsm b/dom/wifi/WifiP2pManager.jsm
new file mode 100644
index 000000000..c1b687438
--- /dev/null
+++ b/dom/wifi/WifiP2pManager.jsm
@@ -0,0 +1,1649 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 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/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/StateMachine.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/systemlibs.js");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gSysMsgr",
+                                   "@mozilla.org/system-message-internal;1",
+                                   "nsISystemMessagesInternal");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gNetworkManager",
+                                   "@mozilla.org/network/manager;1",
+                                   "nsINetworkManager");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gNetworkService",
+                                   "@mozilla.org/network/service;1",
+                                   "nsINetworkService");
+
+this.EXPORTED_SYMBOLS = ["WifiP2pManager"];
+
+const EVENT_IGNORED                      = -1;
+const EVENT_UNKNOWN                      = -2;
+
+// Events from supplicant for p2p.
+const EVENT_P2P_DEVICE_FOUND             = 0;
+const EVENT_P2P_DEVICE_LOST              = 1;
+const EVENT_P2P_GROUP_STARTED            = 2;
+const EVENT_P2P_GROUP_REMOVED            = 3;
+const EVENT_P2P_PROV_DISC_PBC_REQ        = 4;
+const EVENT_P2P_PROV_DISC_PBC_RESP       = 5;
+const EVENT_P2P_PROV_DISC_SHOW_PIN       = 6;
+const EVENT_P2P_PROV_DISC_ENTER_PIN      = 7;
+const EVENT_P2P_GO_NEG_REQUEST           = 8;
+const EVENT_P2P_GO_NEG_SUCCESS           = 9;
+const EVENT_P2P_GO_NEG_FAILURE           = 10;
+const EVENT_P2P_GROUP_FORMATION_SUCCESS  = 11;
+const EVENT_P2P_GROUP_FORMATION_FAILURE  = 12;
+const EVENT_P2P_FIND_STOPPED             = 13;
+const EVENT_P2P_INVITATION_RESULT        = 14;
+const EVENT_P2P_INVITATION_RECEIVED      = 15;
+const EVENT_P2P_PROV_DISC_FAILURE        = 16;
+
+// Events from supplicant but not p2p specific.
+const EVENT_AP_STA_DISCONNECTED          = 100;
+const EVENT_AP_STA_CONNECTED             = 101;
+
+// Events from DOM.
+const EVENT_P2P_SET_PAIRING_CONFIRMATION = 1000;
+const EVENT_P2P_CMD_CONNECT              = 1001;
+const EVENT_P2P_CMD_DISCONNECT           = 1002;
+const EVENT_P2P_CMD_ENABLE               = 1003;
+const EVENT_P2P_CMD_DISABLE              = 1004;
+const EVENT_P2P_CMD_ENABLE_SCAN          = 1005;
+const EVENT_P2P_CMD_DISABLE_SCAN         = 1006;
+const EVENT_P2P_CMD_BLOCK_SCAN           = 1007;
+const EVENT_P2P_CMD_UNBLOCK_SCAN         = 1008;
+
+// Internal events.
+const EVENT_TIMEOUT_PAIRING_CONFIRMATION = 10000;
+const EVENT_TIMEOUT_NEG_REQ              = 10001;
+const EVENT_TIMEOUT_CONNECTING           = 10002;
+const EVENT_P2P_ENABLE_SUCCESS           = 10003;
+const EVENT_P2P_ENABLE_FAILED            = 10004;
+const EVENT_P2P_DISABLE_SUCCESS          = 10005;
+
+// WPS method string.
+const WPS_METHOD_PBC     = "pbc";
+const WPS_METHOD_DISPLAY = "display";
+const WPS_METHOD_KEYPAD  = "keypad";
+
+// Role string.
+const P2P_ROLE_GO     = "GO";
+const P2P_ROLE_CLIENT = "client";
+
+// System message for pairing request.
+const PAIRING_REQUEST_SYS_MSG = "wifip2p-pairing-request";
+
+// Configuration.
+const P2P_INTERFACE_NAME = "p2p0";
+const DEFAULT_GO_INTENT = 15;
+const DEFAULT_P2P_DEVICE_NAME = "FirefoxPhone";
+const P2P_SCAN_TIMEOUT_SEC = 120;
+const DEFAULT_P2P_WPS_METHODS = "virtual_push_button physical_display keypad"; // For wpa_supplicant.
+const DEFAULT_P2P_DEVICE_TYPE = "10-0050F204-5"; // For wpa_supplicant.
+
+const GO_NETWORK_INTERFACE = {
+  ip:         "192.168.2.1",
+  maskLength: 24,
+  gateway:    "192.168.2.1",
+  dns1:       "0.0.0.0",
+  dns2:       "0.0.0.0",
+  dhcpServer: "192.168.2.1"
+};
+
+const GO_DHCP_SERVER_IP_RANGE = {
+  startIp: "192.168.2.10",
+  endIp:   "192.168.2.30"
+};
+
+var gDebug = false;
+
+// Device Capability bitmap
+const DEVICE_CAPAB_SERVICE_DISCOVERY         = 1;
+const DEVICE_CAPAB_CLIENT_DISCOVERABILITY    = 1<<1;
+const DEVICE_CAPAB_CONCURRENT_OPER           = 1<<2;
+const DEVICE_CAPAB_INFRA_MANAGED             = 1<<3;
+const DEVICE_CAPAB_DEVICE_LIMIT              = 1<<4;
+const DEVICE_CAPAB_INVITATION_PROCEDURE      = 1<<5;
+
+// Group Capability bitmap
+const GROUP_CAPAB_GROUP_OWNER                = 1;
+const GROUP_CAPAB_PERSISTENT_GROUP           = 1<<1;
+const GROUP_CAPAB_GROUP_LIMIT                = 1<<2;
+const GROUP_CAPAB_INTRA_BSS_DIST             = 1<<3;
+const GROUP_CAPAB_CROSS_CONN                 = 1<<4;
+const GROUP_CAPAB_PERSISTENT_RECONN          = 1<<5;
+const GROUP_CAPAB_GROUP_FORMATION            = 1<<6;
+
+// Constants defined in wpa_supplicants.
+const DEV_PW_REGISTRAR_SPECIFIED = 5;
+const DEV_PW_USER_SPECIFIED      = 1;
+const DEV_PW_PUSHBUTTON          = 4;
+
+this.WifiP2pManager = function (aP2pCommand, aNetUtil) {
+  function debug(aMsg) {
+    if (gDebug) {
+      dump('-------------- WifiP2pManager: ' + aMsg);
+    }
+  }
+
+  let manager = {};
+
+  let _stateMachine = P2pStateMachine(aP2pCommand, aNetUtil);
+
+  // Set debug flag to true or false.
+  //
+  // @param aDebug Boolean to indicate enabling or disabling the debug flag.
+  manager.setDebug = function(aDebug) {
+    gDebug = aDebug;
+  };
+
+  // Set observer of observing internal state machine events.
+  //
+  // @param aObserver Used to notify WifiWorker what's happening
+  //        in the internal p2p state machine.
+  manager.setObserver = function(aObserver) {
+    _stateMachine.setObserver(aObserver);
+  };
+
+  // Handle wpa_supplicant events.
+  //
+  // @param aEventString string from wpa_supplicant.
+  manager.handleEvent = function(aEventString) {
+    let event = parseEventString(aEventString);
+    if (EVENT_UNKNOWN === event.id || EVENT_IGNORED === event.id) {
+      debug('Unknow or ignored event: ' + aEventString);
+      return false;
+    }
+    return _stateMachine.sendEvent(event);
+  };
+
+  // Set the confirmation of pairing request.
+  //
+  // @param aResult Object of confirmation result which contains:
+  //    .accepted: user granted.
+  //    .pin: pin code which is displaying or input by user.
+  //    .wpsMethod: string of "pbc" or "display" or "keypad".
+  manager.setPairingConfirmation = function(aResult) {
+    let event = {
+      id: EVENT_P2P_SET_PAIRING_CONFIRMATION,
+      info: {
+        accepted: aResult.accepted,
+        pin: aResult.pin
+      }
+    };
+    _stateMachine.sendEvent(event);
+  };
+
+  // Connect to a known peer.
+  //
+  // @param aAddress MAC address of the peer to connect.
+  // @param aWpsMethod String of "pbc" or "display" or "keypad".
+  // @param aGoIntent Number from 0 to 15.
+  // @param aCallback Callback |true| on attempting to connect.
+  //                          |false| on failed to connect.
+  manager.connect = function(aAddress, aWpsMethod, aGoIntent, aCallback) {
+    let event = {
+      id: EVENT_P2P_CMD_CONNECT,
+      info: {
+        wpsMethod: aWpsMethod,
+        address: aAddress,
+        goIntent: aGoIntent,
+        onDoConnect: aCallback
+      }
+    };
+    _stateMachine.sendEvent(event);
+  };
+
+  // Disconnect with a known peer.
+  //
+  // @param aAddress The address the user desires to disconect.
+  // @param aCallback Callback |true| on "attempting" to disconnect.
+  //                           |false| on failed to disconnect.
+  manager.disconnect = function(aAddress, aCallback) {
+    let event = {
+      id: EVENT_P2P_CMD_DISCONNECT,
+      info: {
+        address: aAddress,
+        onDoDisconnect: aCallback
+      }
+    };
+    _stateMachine.sendEvent(event);
+  };
+
+  // Enable/disable wifi p2p.
+  //
+  // @param aEnabled |true| to enable, |false| to disable.
+  // @param aCallbacks object for callbacks:
+  //   .onEnabled
+  //   .onDisabled
+  //   .onSupplicantConnected
+  manager.setEnabled = function(aEnabled, aCallbacks) {
+    let event = {
+      id: (aEnabled ? EVENT_P2P_CMD_ENABLE : EVENT_P2P_CMD_DISABLE),
+      info: {
+        onEnabled: aCallbacks.onEnabled,
+        onDisabled: aCallbacks.onDisabled,
+        onSupplicantConnected: aCallbacks.onSupplicantConnected
+      }
+    };
+    _stateMachine.sendEvent(event);
+  };
+
+  // Enable/disable the wifi p2p scan.
+  //
+  // @param aEnabled |true| to enable scan, |false| to disable scan.
+  // @param aCallback Callback |true| on success to enable/disable scan.
+  //                           |false| on failed to enable/disable scan.
+  manager.setScanEnabled = function(aEnabled, aCallback) {
+    let event = {
+      id: (aEnabled ? EVENT_P2P_CMD_ENABLE_SCAN : EVENT_P2P_CMD_DISABLE_SCAN),
+      info: { callback: aCallback }
+    };
+    _stateMachine.sendEvent(event);
+  };
+
+  // Block wifi p2p scan.
+  manager.blockScan = function() {
+    _stateMachine.sendEvent({ id: EVENT_P2P_CMD_BLOCK_SCAN });
+  };
+
+  // Un-block and do the pending scan if any.
+  manager.unblockScan = function() {
+    _stateMachine.sendEvent({ id: EVENT_P2P_CMD_UNBLOCK_SCAN });
+  };
+
+  // Set the p2p device name.
+  manager.setDeviceName = function(newDeivceName, callback) {
+    aP2pCommand.setDeviceName(newDeivceName, callback);
+  };
+
+  // Parse wps_supplicant event string.
+  //
+  // @param aEventString The raw event string from wpa_supplicant.
+  //
+  // @return Object:
+  //   .id: a number to represent an event.
+  //   .info: the additional information carried by this event string.
+  function parseEventString(aEventString) {
+    if (isIgnoredEvent(aEventString)) {
+      return { id: EVENT_IGNORED };
+    }
+
+    let match = RegExp("p2p_dev_addr=([0-9a-fA-F:]+) " +
+                       "pri_dev_type=([0-9a-zA-Z-]+) " +
+                       "name='(.*)' " +
+                       "config_methods=0x([0-9a-fA-F]+) " +
+                       "dev_capab=0x([0-9a-fA-F]+) " +
+                       "group_capab=0x([0-9a-fA-F]+) ").exec(aEventString + ' ');
+
+    let tokens = aEventString.split(" ");
+
+    let id = EVENT_UNKNOWN;
+
+    // general info.
+    let info = {};
+
+    if (match) {
+      info = {
+        address:   match[1] ? match[1] : null,
+        type:      match[2] ? match[2] : null,
+        name:      match[3] ? match[3] : null,
+        wpsFlag:   match[4] ? parseInt(match[4], 16) : null,
+        devFlag:   match[5] ? parseInt(match[5], 16) : null,
+        groupFlag: match[6] ? parseInt(match[6], 16) : null
+      };
+    }
+
+    if (0 === aEventString.indexOf("P2P-DEVICE-FOUND")) {
+      id = EVENT_P2P_DEVICE_FOUND;
+      info.wpsCapabilities = wpsFlagToCapabilities(info.wpsFlag);
+      info.isGroupOwner = isPeerGroupOwner(info.groupFlag);
+    } else if (0 === aEventString.indexOf("P2P-DEVICE-LOST")) {
+      // e.g. "P2P-DEVICE-LOST p2p_dev_addr=5e:0a:5b:15:1f:80".
+      id = EVENT_P2P_DEVICE_LOST;
+      info.address = /p2p_dev_addr=([0-9a-f:]+)/.exec(aEventString)[1];
+    } else if (0 === aEventString.indexOf("P2P-GROUP-STARTED")) {
+      // e.g. "P2P-GROUP-STARTED wlan0-p2p-0 GO ssid="DIRECT-3F Testing
+      //       passphrase="12345678" go_dev_addr=02:40:61:c2:f3:b7 [PERSISTENT]".
+
+      id = EVENT_P2P_GROUP_STARTED;
+      let groupMatch = RegExp('ssid="(.*)" ' +
+                              'freq=([0-9]*) ' +
+                              '(passphrase|psk)=([^ ]+) ' +
+                              'go_dev_addr=([0-9a-f:]+)').exec(aEventString);
+      info.ssid = groupMatch[1];
+      info.freq = groupMatch[2];
+      if ('passphrase' === groupMatch[3]) {
+        let s = groupMatch[4]; // e.g. "G7jHkkz9".
+        info.passphrase = s.substring(1, s.length-1); // Trim the double quote.
+      } else { // psk
+        info.psk = groupMatch[4];
+      }
+      info.goAddress = groupMatch[5];
+      info.ifname = tokens[1];
+      info.role = tokens[2];
+    } else if (0 === aEventString.indexOf("P2P-GROUP-REMOVED")) {
+      id = EVENT_P2P_GROUP_REMOVED;
+      // e.g. "P2P-GROUP-REMOVED wlan0-p2p-0 GO".
+      info.ifname = tokens[1];
+      info.role = tokens[2];
+    } else if (0 === aEventString.indexOf("P2P-PROV-DISC-PBC-REQ")) {
+      id = EVENT_P2P_PROV_DISC_PBC_REQ;
+      info.wpsMethod = WPS_METHOD_PBC;
+    } else if (0 === aEventString.indexOf("P2P-PROV-DISC-PBC-RESP")) {
+      id = EVENT_P2P_PROV_DISC_PBC_RESP;
+      // The address is different from the general pattern.
+      info.address = aEventString.split(" ")[1];
+      info.wpsMethod = WPS_METHOD_PBC;
+    } else if (0 === aEventString.indexOf("P2P-PROV-DISC-SHOW-PIN")) {
+      id = EVENT_P2P_PROV_DISC_SHOW_PIN;
+      // Obtain peer address and pin from tokens.
+      info.address = tokens[1];
+      info.pin     = tokens[2];
+      info.wpsMethod = WPS_METHOD_DISPLAY;
+    } else if (0 === aEventString.indexOf("P2P-PROV-DISC-ENTER-PIN")) {
+      id = EVENT_P2P_PROV_DISC_ENTER_PIN;
+      // Obtain peer address from tokens.
+      info.address = tokens[1];
+      info.wpsMethod = WPS_METHOD_KEYPAD;
+    } else if (0 === aEventString.indexOf("P2P-GO-NEG-REQUEST")) {
+      id = EVENT_P2P_GO_NEG_REQUEST;
+      info.address = tokens[1];
+      switch (parseInt(tokens[2].split("=")[1], 10)) {
+        case DEV_PW_REGISTRAR_SPECIFIED: // (5) Peer is display.
+          info.wpsMethod = WPS_METHOD_KEYPAD;
+          break;
+        case DEV_PW_USER_SPECIFIED: // (1) Peer is keypad.
+          info.wpsMethod = WPS_METHOD_DISPLAY;
+          break;
+        case DEV_PW_PUSHBUTTON: // (4) Peer is pbc.
+          info.wpsMethod = WPS_METHOD_PBC;
+          break;
+        default:
+          debug('Unknown wps method from event P2P-GO-NEG-REQUEST');
+          break;
+      }
+    } else if (0 === aEventString.indexOf("P2P-GO-NEG-SUCCESS")) {
+      id = EVENT_P2P_GO_NEG_SUCCESS;
+    } else if (0 === aEventString.indexOf("P2P-GO-NEG-FAILURE")) {
+      id = EVENT_P2P_GO_NEG_FAILURE;
+    } else if (0 === aEventString.indexOf("P2P-GROUP-FORMATION-FAILURE")) {
+      id = EVENT_P2P_GROUP_FORMATION_FAILURE;
+    } else if (0 === aEventString.indexOf("P2P-GROUP-FORMATION-SUCCESS")) {
+      id = EVENT_P2P_GROUP_FORMATION_SUCCESS;
+    } else if (0 === aEventString.indexOf("P2P-FIND-STOPPED")) {
+      id = EVENT_P2P_FIND_STOPPED;
+    } else if (0 === aEventString.indexOf("P2P-INVITATION-RESULT")) {
+      id = EVENT_P2P_INVITATION_RESULT;
+      info.status = /status=([0-9]+)/.exec(aEventString)[1];
+    } else if (0 === aEventString.indexOf("P2P-INVITATION-RECEIVED")) {
+      // e.g. "P2P-INVITATION-RECEIVED sa=32:85:a9:da:e6:1f persistent=7".
+      id = EVENT_P2P_INVITATION_RECEIVED;
+      info.address = /sa=([0-9a-f:]+)/.exec(aEventString)[1];
+      info.netId = /persistent=([0-9]+)/.exec(aEventString)[1];
+    } else if (0 === aEventString.indexOf("P2P-PROV-DISC-FAILURE")) {
+      id = EVENT_P2P_PROV_DISC_FAILURE;
+    } else {
+      // Not P2P event but we do receive it. Try to recognize it.
+      if (0 === aEventString.indexOf("AP-STA-DISCONNECTED")) {
+        id = EVENT_AP_STA_DISCONNECTED;
+        info.address = tokens[1];
+      } else if (0 === aEventString.indexOf("AP-STA-CONNECTED")) {
+        id = EVENT_AP_STA_CONNECTED;
+        info.address = tokens[1];
+      } else {
+        // Neither P2P event nor recognized supplicant event.
+        debug('Unknwon event string: ' + aEventString);
+      }
+    }
+
+    let event = {id: id, info: info};
+    debug('Event parsing result: ' + aEventString + ": " + JSON.stringify(event));
+
+    return event;
+  }
+
+  function isIgnoredEvent(aEventString) {
+    const IGNORED_EVENTS = [
+      "CTRL-EVENT-BSS-ADDED",
+      "CTRL-EVENT-BSS-REMOVED",
+      "CTRL-EVENT-SCAN-RESULTS",
+      "CTRL-EVENT-STATE-CHANGE",
+      "WPS-AP-AVAILABLE",
+      "WPS-ENROLLEE-SEEN"
+    ];
+    for(let i = 0; i < IGNORED_EVENTS.length; i++) {
+      if (0 === aEventString.indexOf(IGNORED_EVENTS[i])) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function isPeerGroupOwner(aGroupFlag) {
+    return (aGroupFlag & GROUP_CAPAB_GROUP_OWNER) !== 0;
+  }
+
+  // Convert flag to a wps capability array.
+  //
+  // @param aWpsFlag Number that represents the wps capabilities.
+  // @return Array of WPS flag.
+  function wpsFlagToCapabilities(aWpsFlag) {
+    let wpsCapabilities = [];
+    if (aWpsFlag & 0x8) {
+      wpsCapabilities.push(WPS_METHOD_DISPLAY);
+    }
+    if (aWpsFlag & 0x80) {
+      wpsCapabilities.push(WPS_METHOD_PBC);
+    }
+    if (aWpsFlag & 0x100) {
+      wpsCapabilities.push(WPS_METHOD_KEYPAD);
+    }
+    return wpsCapabilities;
+  }
+
+  _stateMachine.start();
+  return manager;
+};
+
+function P2pStateMachine(aP2pCommand, aNetUtil) {
+  function debug(aMsg) {
+    if (gDebug) {
+      dump('-------------- WifiP2pStateMachine: ' + aMsg);
+    }
+  }
+
+  let p2pSm = {};  // The state machine to return.
+
+  let _sm = StateMachine('WIFIP2P'); // The general purpose state machine.
+
+  // Information we need to keep track across states.
+  let _observer;
+
+  let _onEnabled;
+  let _onDisabled;
+  let _onSupplicantConnected;
+  let _savedConfig = {}; // Configuration used to do P2P_CONNECT.
+  let _groupInfo = {};   // The information of the group we have formed.
+  let _removedGroupInfo = {}; // Used to store the group info we are going to remove.
+
+  let _scanBlocked = false;
+  let _scanPostponded = false;
+
+  let _localDevice = {
+    address: "",
+    deviceName: DEFAULT_P2P_DEVICE_NAME + "_" + libcutils.property_get("ro.build.product"),
+    wpsCapabilities: [WPS_METHOD_PBC, WPS_METHOD_KEYPAD, WPS_METHOD_DISPLAY]
+  };
+
+  let _p2pNetworkInterface = {
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsINetworkInterface]),
+
+    info: {
+      QueryInterface: XPCOMUtils.generateQI([Ci.nsINetworkInfo]),
+
+      state: Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED,
+      type: Ci.nsINetworkInfo.NETWORK_TYPE_WIFI_P2P,
+      name: P2P_INTERFACE_NAME,
+      ips: [],
+      prefixLengths: [],
+      dnses: [],
+      gateways: [],
+
+      getAddresses: function (ips, prefixLengths) {
+        ips.value = this.ips.slice();
+        prefixLengths.value = this.prefixLengths.slice();
+
+        return this.ips.length;
+      },
+
+      getGateways: function (count) {
+        if (count) {
+          count.value = this.gateways.length;
+        }
+        return this.gateways.slice();
+      },
+
+      getDnses: function (count) {
+        if (count) {
+          count.value = this.dnses.length;
+        }
+        return this.dnses.slice();
+      }
+    },
+
+    httpProxyHost: null,
+    httpProxyPort: null,
+
+    // help
+    registered: false
+  };
+
+  //---------------------------------------------------------
+  // State machine APIs.
+  //---------------------------------------------------------
+
+  // Register the observer which is implemented in WifiP2pWorkerObserver.jsm.
+  //
+  // @param aObserver:
+  //   .onEnabled
+  //   .onDisbaled
+  //   .onPeerFound
+  //   .onPeerLost
+  //   .onConnecting
+  //   .onConnected
+  //   .onDisconnected
+  //   .onLocalDeviceChanged
+  p2pSm.setObserver = function(aObserver) {
+    _observer = aObserver;
+  };
+
+  p2pSm.start = function() {
+    _sm.start(stateDisabled);
+  };
+
+  p2pSm.sendEvent = function(aEvent) {
+    let willBeHandled = isInP2pManagedState(_sm.getCurrentState());
+    _sm.sendEvent(aEvent);
+    return willBeHandled;
+  };
+
+  // Initialize internal state machine _sm.
+  _sm.setDefaultEventHandler(handleEventCommon);
+
+  //----------------------------------------------------------
+  // State definition.
+  //----------------------------------------------------------
+
+  // The initial state.
+  var stateDisabled = _sm.makeState("DISABLED", {
+    enter: function() {
+      _onEnabled = null;
+      _onSupplicantConnected = null;
+      _savedConfig = null;
+      _groupInfo = null;
+      _removedGroupInfo = null;
+      _scanBlocked = false;
+      _scanPostponded = false;
+
+      unregisterP2pNetworkInteface();
+    },
+
+    handleEvent: function(aEvent) {
+      switch (aEvent.id) {
+        case EVENT_P2P_CMD_ENABLE:
+          _onEnabled = aEvent.info.onEnabled;
+          _onSupplicantConnected = aEvent.info.onSupplicantConnected;
+          _sm.gotoState(stateEnabling);
+          break;
+
+        default:
+          return false;
+      } // End of switch.
+      return true;
+    }
+  });
+
+  // The state where we are trying to enable wifi p2p.
+  var stateEnabling = _sm.makeState("ENABLING", {
+    enter: function() {
+
+      function onFailure()
+      {
+        _onEnabled(false);
+        _observer.onDisabled();
+        _sm.gotoState(stateDisabled);
+      }
+
+      function onSuccess()
+      {
+        _onEnabled(true);
+        _observer.onEnabled();
+        _sm.gotoState(stateInactive);
+      }
+
+      _sm.pause();
+
+      // This function will only call back on success.
+      function connectToSupplicantIfNeeded(callback) {
+        if (aP2pCommand.getSdkVersion() >= 19) {
+          // No need to connect to supplicant on KK. Call back directly.
+          callback();
+          return;
+        }
+        aP2pCommand.connectToSupplicant(function (status) {
+          if (0 !== status) {
+            debug('Failed to connect to p2p0');
+            onFailure();
+            return;
+          }
+          debug('wpa_supplicant p2p0 connected!');
+          _onSupplicantConnected();
+          callback();
+        });
+      }
+
+      // Step 1: Connect to p2p0 if needed.
+      connectToSupplicantIfNeeded(function callback () {
+        let detail;
+
+        // Step 2: Get MAC address.
+        if (!_localDevice.address) {
+          aP2pCommand.getMacAddress(function (address) {
+            if (!address) {
+              debug('Failed to get MAC address....');
+              onFailure();
+              return;
+            }
+            debug('Got mac address: ' + address);
+            _localDevice.address = address;
+            _observer.onLocalDeviceChanged(_localDevice);
+          });
+        }
+
+        // Step 3: Enable p2p with the device name and wps methods.
+        detail = { deviceName: _localDevice.deviceName,
+                   deviceType: libcutils.property_get("ro.moz.wifi.p2p_device_type") || DEFAULT_P2P_DEVICE_TYPE,
+                   wpsMethods: libcutils.property_get("ro.moz.wifi.p2p_wps_methods") || DEFAULT_P2P_WPS_METHODS };
+
+        aP2pCommand.p2pEnable(detail, function (success) {
+          if (!success) {
+            debug('Failed to enable p2p');
+            onFailure();
+            return;
+          }
+
+          debug('P2P is enabled! Enabling net interface...');
+
+          // Step 4: Enable p2p0 net interface. wpa_supplicant may have
+          //         already done it for us.
+          gNetworkService.enableInterface(P2P_INTERFACE_NAME, function (success) {
+            onSuccess();
+          });
+        });
+      });
+    },
+
+    handleEvent: function(aEvent) {
+      // We won't receive any event since all of them will be blocked.
+      return true;
+    }
+  });
+
+  // The state just after enabling wifi direct.
+  var stateInactive = _sm.makeState("INACTIVE", {
+    enter: function() {
+      registerP2pNetworkInteface();
+
+      if (_sm.getPreviousState() !== stateEnabling) {
+        _observer.onDisconnected(_savedConfig);
+      }
+
+      _savedConfig = null; // Used to connect p2p peer.
+      _groupInfo   = null; // The information of the formed group.
+    },
+
+    handleEvent: function(aEvent) {
+      switch (aEvent.id) {
+        // Receiving the following 3 states implies someone is trying to
+        // connect to me.
+        case EVENT_P2P_PROV_DISC_PBC_REQ:
+        case EVENT_P2P_PROV_DISC_SHOW_PIN:
+        case EVENT_P2P_PROV_DISC_ENTER_PIN:
+          debug('Someone is trying to connect to me: ' + JSON.stringify(aEvent.info));
+
+          _savedConfig = {
+            name:      aEvent.info.name,
+            address:   aEvent.info.address,
+            wpsMethod: aEvent.info.wpsMethod,
+            goIntent:  DEFAULT_GO_INTENT,
+            pin:       aEvent.info.pin // EVENT_P2P_PROV_DISC_SHOW_PIN only.
+          };
+
+          _sm.gotoState(stateWaitingForConfirmation);
+          break;
+
+        // Connect to a peer.
+        case EVENT_P2P_CMD_CONNECT:
+          debug('Trying to connect to peer: ' + JSON.stringify(aEvent.info));
+
+          _savedConfig = {
+            address:   aEvent.info.address,
+            wpsMethod: aEvent.info.wpsMethod,
+            goIntent:  aEvent.info.goIntent
+          };
+
+          _sm.gotoState(stateProvisionDiscovery);
+          aEvent.info.onDoConnect(true);
+          break;
+
+        case EVENT_P2P_INVITATION_RECEIVED:
+          _savedConfig = {
+            address: aEvent.info.address,
+            wpsMethod: WPS_METHOD_PBC,
+            goIntent: DEFAULT_GO_INTENT,
+            netId: aEvent.info.netId
+          };
+          _sm.gotoState(stateWaitingForInvitationConfirmation);
+          break;
+
+        case EVENT_P2P_GROUP_STARTED:
+          // Most likely the peer just reinvoked a peristen group and succeeeded.
+
+          _savedConfig = { address: aEvent.info.goAddress };
+
+          _sm.pause();
+          handleGroupStarted(aEvent.info, function (success) {
+            _sm.resume();
+          });
+          break;
+
+        case EVENT_AP_STA_DISCONNECTED:
+          // We will hit this case when we used to be a group owner and
+          // requested to remove the group we owned.
+          break;
+
+        default:
+          return false;
+      } // End of switch.
+      return true;
+    },
+  });
+
+  // Waiting for user's confirmation.
+  var stateWaitingForConfirmation = _sm.makeState("WAITING_FOR_CONFIRMATION", {
+    timeoutTimer: null,
+
+    enter: function() {
+      gSysMsgr.broadcastMessage(PAIRING_REQUEST_SYS_MSG, _savedConfig);
+      this.timeoutTimer = initTimeoutTimer(30000, EVENT_TIMEOUT_PAIRING_CONFIRMATION);
+    },
+
+    handleEvent: function(aEvent) {
+      switch (aEvent.id) {
+        case EVENT_P2P_SET_PAIRING_CONFIRMATION:
+          if (!aEvent.info.accepted) {
+            debug('User rejected this request');
+            _sm.gotoState(stateInactive); // Reset to inactive state.
+            break;
+          }
+
+          debug('User accepted this request');
+
+          // The only information we may have to grab from user.
+          _savedConfig.pin = aEvent.info.pin;
+
+          // The case that user requested to form a group ealier on.
+          // Just go to connecting state and do p2p_connect.
+          if (_sm.getPreviousState() === stateProvisionDiscovery) {
+            _sm.gotoState(stateConnecting);
+            break;
+          }
+
+          // Otherwise, wait for EVENT_P2P_GO_NEG_REQUEST.
+          _sm.gotoState(stateWaitingForNegReq);
+          break;
+
+        case EVENT_TIMEOUT_PAIRING_CONFIRMATION:
+          debug('Confirmation timeout!');
+          _sm.gotoState(stateInactive);
+          break;
+
+        case EVENT_P2P_GO_NEG_REQUEST:
+          _sm.deferEvent(aEvent);
+          break;
+
+        default:
+          return false;
+      } // End of switch.
+
+      return true;
+    },
+
+    exit: function() {
+      this.timeoutTimer.cancel();
+      this.timeoutTimer = null;
+    }
+  });
+
+  var stateWaitingForNegReq = _sm.makeState("WAITING_FOR_NEG_REQ", {
+    timeoutTimer: null,
+
+    enter: function() {
+      debug('Wait for EVENT_P2P_GO_NEG_REQUEST');
+      this.timeoutTimer = initTimeoutTimer(30000, EVENT_TIMEOUT_NEG_REQ);
+    },
+
+    handleEvent: function(aEvent) {
+      switch (aEvent.id) {
+        case EVENT_P2P_GO_NEG_REQUEST:
+          if (aEvent.info.wpsMethod !== _savedConfig.wpsMethod) {
+            debug('Unmatched wps method: ' + aEvent.info.wpsMethod + ", " + _savedConfig.wpsMetho);
+          }
+          _sm.gotoState(stateConnecting);
+          break;
+
+        case EVENT_TIMEOUT_NEG_REQ:
+          debug("Waiting for NEG-REQ timeout");
+          _sm.gotoState(stateInactive);
+          break;
+
+        default:
+          return false;
+      } // End of switch.
+      return true;
+    },
+
+    exit: function() {
+      this.timeoutTimer.cancel();
+      this.timeoutTimer = null;
+    }
+  });
+
+  // Waiting for user's confirmation for invitation.
+  var stateWaitingForInvitationConfirmation = _sm.makeState("WAITING_FOR_INV_CONFIRMATION", {
+    timeoutTimer: null,
+
+    enter: function() {
+      gSysMsgr.broadcastMessage(PAIRING_REQUEST_SYS_MSG, _savedConfig);
+      this.timeoutTimer = initTimeoutTimer(30000, EVENT_TIMEOUT_PAIRING_CONFIRMATION);
+    },
+
+    handleEvent: function(aEvent) {
+      switch (aEvent.id) {
+        case EVENT_P2P_SET_PAIRING_CONFIRMATION:
+          if (!aEvent.info.accepted) {
+            debug('User rejected this request');
+            _sm.gotoState(stateInactive); // Reset to inactive state.
+            break;
+          }
+
+          debug('User accepted this request');
+          _sm.pause();
+          aP2pCommand.p2pGetGroupCapab(_savedConfig.address, function (gc) {
+            let isPeeGroupOwner = gc & GROUP_CAPAB_GROUP_OWNER;
+            _sm.gotoState(isPeeGroupOwner ? stateGroupAdding : stateReinvoking);
+          });
+
+          break;
+
+        case EVENT_TIMEOUT_PAIRING_CONFIRMATION:
+          debug('Confirmation timeout!');
+          _sm.gotoState(stateInactive);
+          break;
+
+        default:
+          return false;
+      } // End of switch.
+
+      return true;
+    },
+
+    exit: function() {
+      this.timeoutTimer.cancel();
+      this.timeoutTimer = null;
+    }
+  });
+
+  var stateGroupAdding = _sm.makeState("GROUP_ADDING", {
+    timeoutTimer: null,
+
+    enter: function() {
+      let self = this;
+
+      _observer.onConnecting(_savedConfig);
+
+      _sm.pause();
+      aP2pCommand.p2pGroupAdd(_savedConfig.netId, function (success) {
+        if (!success) {
+          _sm.gotoState(stateInactive);
+          return;
+        }
+        // Waiting for EVENT_P2P_GROUP_STARTED.
+        self.timeoutTimer = initTimeoutTimer(60000, EVENT_TIMEOUT_CONNECTING);
+        _sm.resume();
+      });
+    },
+
+    handleEvent: function(aEvent) {
+      switch (aEvent.id) {
+        case EVENT_P2P_GROUP_STARTED:
+          _sm.pause();
+          handleGroupStarted(aEvent.info, function (success) {
+            _sm.resume();
+          });
+          break;
+
+        case EVENT_P2P_GO_NEG_FAILURE:
+          debug('Negotiation failure. Go back to inactive state');
+          _sm.gotoState(stateInactive);
+          break;
+
+        case EVENT_TIMEOUT_CONNECTING:
+          debug('Connecting timeout! Go back to inactive state');
+          _sm.gotoState(stateInactive);
+          break;
+
+        case EVENT_P2P_GROUP_FORMATION_SUCCESS:
+        case EVENT_P2P_GO_NEG_SUCCESS:
+          break;
+
+        case EVENT_P2P_GROUP_FORMATION_FAILURE:
+          debug('Group formation failure');
+          _sm.gotoState(stateInactive);
+          break;
+
+        case EVENT_P2P_GROUP_REMOVED:
+          debug('Received P2P-GROUP-REMOVED due to previous failed handleGroupdStarted()');
+          _removedGroupInfo = {
+            role:   aEvent.info.role,
+            ifname: aEvent.info.ifname
+          };
+          _sm.gotoState(stateDisconnecting);
+          break;
+
+        default:
+          return false;
+      } // End of switch.
+
+      return true;
+    },
+
+    exit: function() {
+      this.timeoutTimer.cancel();
+      this.timeoutTimer = null;
+    }
+  });
+
+  var stateReinvoking = _sm.makeState("REINVOKING", {
+    timeoutTimer: null,
+
+    enter: function() {
+      let self = this;
+
+      _observer.onConnecting(_savedConfig);
+      _sm.pause();
+      aP2pCommand.p2pReinvoke(_savedConfig.netId, _savedConfig.address, function(success) {
+        if (!success) {
+          _sm.gotoState(stateInactive);
+          return;
+        }
+        // Waiting for EVENT_P2P_GROUP_STARTED.
+        self.timeoutTimer = initTimeoutTimer(60000, EVENT_TIMEOUT_CONNECTING);
+        _sm.resume();
+      });
+    },
+
+    handleEvent: function(aEvent) {
+      switch (aEvent.id) {
+        case EVENT_P2P_GROUP_STARTED:
+          _sm.pause();
+          handleGroupStarted(aEvent.info, function(success) {
+            _sm.resume();
+          });
+          break;
+
+        case EVENT_P2P_GO_NEG_FAILURE:
+          debug('Negotiation failure. Go back to inactive state');
+          _sm.gotoState(stateInactive);
+          break;
+
+        case EVENT_TIMEOUT_CONNECTING:
+          debug('Connecting timeout! Go back to inactive state');
+          _sm.gotoState(stateInactive);
+          break;
+
+        case EVENT_P2P_GROUP_FORMATION_SUCCESS:
+        case EVENT_P2P_GO_NEG_SUCCESS:
+          break;
+
+        case EVENT_P2P_GROUP_FORMATION_FAILURE:
+          debug('Group formation failure');
+          _sm.gotoState(stateInactive);
+          break;
+
+        case EVENT_P2P_GROUP_REMOVED:
+          debug('Received P2P-GROUP-REMOVED due to previous failed handleGroupdStarted()');
+          _removedGroupInfo = {
+            role:   aEvent.info.role,
+            ifname: aEvent.info.ifname
+          };
+          _sm.gotoState(stateDisconnecting);
+          break;
+
+        default:
+          return false;
+      } // End of switch.
+
+      return true;
+    },
+
+    exit: function() {
+      this.timeoutTimer.cancel();
+    }
+  });
+
+  var stateProvisionDiscovery = _sm.makeState("PROVISION_DISCOVERY", {
+    enter: function() {
+      function onDiscoveryCommandSent(success) {
+        if (!success) {
+          _sm.gotoState(stateInactive);
+          debug('Failed to send p2p_prov_disc. Go back to inactive state.');
+          return;
+        }
+
+        debug('p2p_prov_disc has been sent.');
+
+        _sm.resume();
+        // Waiting for EVENT_P2P_PROV_DISC_PBC_RESP or
+        //             EVENT_P2P_PROV_DISC_SHOW_PIN or
+        //             EVENT_P2P_PROV_DISC_ENTER_PIN.
+      }
+
+      _sm.pause();
+      aP2pCommand.p2pProvDiscovery(_savedConfig.address,
+                                   toPeerWpsMethod(_savedConfig.wpsMethod),
+                                   onDiscoveryCommandSent);
+    },
+
+    handleEvent: function(aEvent) {
+      switch (aEvent.id) {
+        case EVENT_P2P_PROV_DISC_PBC_RESP:
+          _sm.gotoState(stateConnecting); // No need for local user grant.
+          break;
+        case EVENT_P2P_PROV_DISC_SHOW_PIN:
+        case EVENT_P2P_PROV_DISC_ENTER_PIN:
+          if (aEvent.info.wpsMethod !== _savedConfig.wpsMethod) {
+            debug('Unmatched wps method: ' + aEvent.info.wpsMethod + ":" + _savedConfig.wpsMethod);
+          }
+          if (EVENT_P2P_PROV_DISC_SHOW_PIN === aEvent.id) {
+            _savedConfig.pin = aEvent.info.pin;
+          }
+          _sm.gotoState(stateWaitingForConfirmation);
+          break;
+
+        case EVENT_P2P_PROV_DISC_FAILURE:
+          _sm.gotoState(stateInactive);
+          break;
+
+        default:
+          return false;
+      } // End of switch.
+      return true;
+    }
+  });
+
+  // We are going to connect to the peer.
+  // |_savedConfig| is supposed to have been filled properly.
+  var stateConnecting = _sm.makeState("CONNECTING", {
+    timeoutTimer: null,
+
+    enter: function() {
+      let self = this;
+
+      if (null === _savedConfig.goIntent) {
+        _savedConfig.goIntent = DEFAULT_GO_INTENT;
+      }
+
+      _observer.onConnecting(_savedConfig);
+
+      let wpsMethodWithPin;
+      if (WPS_METHOD_KEYPAD === _savedConfig.wpsMethod ||
+          WPS_METHOD_DISPLAY === _savedConfig.wpsMethod) {
+        // e.g. '12345678 display or '12345678 keypad'.
+        wpsMethodWithPin = (_savedConfig.pin + ' ' + _savedConfig.wpsMethod);
+      } else {
+        // e.g. 'pbc'.
+        wpsMethodWithPin = _savedConfig.wpsMethod;
+      }
+
+      _sm.pause();
+
+      aP2pCommand.p2pGetGroupCapab(_savedConfig.address, function(gc) {
+        debug('group capabilities of ' + _savedConfig.address + ': ' + gc);
+
+        let isPeerGroupOwner = gc & GROUP_CAPAB_GROUP_OWNER;
+        let config = { address:           _savedConfig.address,
+                       wpsMethodWithPin:  wpsMethodWithPin,
+                       goIntent:          _savedConfig.goIntent,
+                       joinExistingGroup: isPeerGroupOwner };
+
+        aP2pCommand.p2pConnect(config, function (success) {
+          if (!success) {
+            debug('Failed to send p2p_connect');
+            _sm.gotoState(stateInactive);
+            return;
+          }
+          debug('Waiting for EVENT_P2P_GROUP_STARTED.');
+          self.timeoutTimer = initTimeoutTimer(60000, EVENT_TIMEOUT_CONNECTING);
+          _sm.resume();
+        });
+      });
+    },
+
+    handleEvent: function(aEvent) {
+      switch (aEvent.id) {
+        case EVENT_P2P_GROUP_STARTED:
+          _sm.pause();
+          handleGroupStarted(aEvent.info, function (success) {
+            _sm.resume();
+          });
+          break;
+
+        case EVENT_P2P_GO_NEG_FAILURE:
+          debug('Negotiation failure. Go back to inactive state');
+          _sm.gotoState(stateInactive);
+          break;
+
+        case EVENT_TIMEOUT_CONNECTING:
+          debug('Connecting timeout! Go back to inactive state');
+          _sm.gotoState(stateInactive);
+          break;
+
+        case EVENT_P2P_GROUP_FORMATION_SUCCESS:
+        case EVENT_P2P_GO_NEG_SUCCESS:
+          break;
+
+        case EVENT_P2P_GROUP_FORMATION_FAILURE:
+          debug('Group formation failure');
+          _sm.gotoState(stateInactive);
+          break;
+
+        case EVENT_P2P_GROUP_REMOVED:
+          debug('Received P2P-GROUP-REMOVED due to previous failed ' +
+                'handleGroupdStarted()');
+          _removedGroupInfo = {
+            role:   aEvent.info.role,
+            ifname: aEvent.info.ifname
+          };
+          _sm.gotoState(stateDisconnecting);
+          break;
+
+        default:
+          return false;
+      } // End of switch.
+
+      return true;
+    },
+
+    exit: function() {
+      this.timeoutTimer.cancel();
+    }
+  });
+
+  var stateConnected = _sm.makeState("CONNECTED", {
+    groupOwner: null,
+
+    enter: function() {
+      this.groupOwner = {
+        macAddress: _groupInfo.goAddress,
+        ipAddress:  _groupInfo.networkInterface.info.gateways[0],
+        passphrase: _groupInfo.passphrase,
+        ssid:       _groupInfo.ssid,
+        freq:       _groupInfo.freq,
+        isLocal:    _groupInfo.isGroupOwner
+      };
+
+      if (!_groupInfo.isGroupOwner) {
+        _observer.onConnected(this.groupOwner, _savedConfig);
+      } else {
+        // If I am a group owner, notify onConnected until EVENT_AP_STA_CONNECTED
+        // is received.
+      }
+
+      _removedGroupInfo = null;
+    },
+
+    handleEvent: function(aEvent) {
+      switch (aEvent.id) {
+        case EVENT_AP_STA_CONNECTED:
+          if (_groupInfo.isGroupOwner) {
+            _observer.onConnected(this.groupOwner, _savedConfig);
+          }
+          break;
+
+        case EVENT_P2P_GROUP_REMOVED:
+          _removedGroupInfo = {
+            role:   aEvent.info.role,
+            ifname: aEvent.info.ifname
+          };
+          _sm.gotoState(stateDisconnecting);
+          break;
+
+        case EVENT_AP_STA_DISCONNECTED:
+          debug('Client disconnected: ' + aEvent.info.address);
+
+          // Now we suppose it's the only client. Remove my group.
+          _sm.pause();
+          aP2pCommand.p2pGroupRemove(_groupInfo.ifname, function (success) {
+            debug('Requested to remove p2p group. Wait for EVENT_P2P_GROUP_REMOVED.');
+            _sm.resume();
+          });
+          break;
+
+        case EVENT_P2P_CMD_DISCONNECT:
+          // Since we only support single connection, we can ignore
+          // the given peer address.
+          _sm.pause();
+          aP2pCommand.p2pGroupRemove(_groupInfo.ifname, function(success) {
+            aEvent.info.onDoDisconnect(true);
+            _sm.resume();
+          });
+
+          debug('Sent disconnect command. Wait for EVENT_P2P_GROUP_REMOVED.');
+          break;
+
+        case EVENT_P2P_PROV_DISC_PBC_REQ:
+        case EVENT_P2P_PROV_DISC_SHOW_PIN:
+        case EVENT_P2P_PROV_DISC_ENTER_PIN:
+          debug('Someone is trying to connect to me: ' + JSON.stringify(aEvent.info));
+
+          _savedConfig = {
+            name:      aEvent.info.name,
+            address:   aEvent.info.address,
+            wpsMethod: aEvent.info.wpsMethod,
+            pin:       aEvent.info.pin
+          };
+
+          _sm.gotoState(stateWaitingForJoiningConfirmation);
+          break;
+
+        default:
+          return false;
+      } // end of switch
+      return true;
+    }
+  });
+
+  var stateWaitingForJoiningConfirmation = _sm.makeState("WAITING_FOR_JOINING_CONFIRMATION", {
+    timeoutTimer: null,
+
+    enter: function() {
+      gSysMsgr.broadcastMessage(PAIRING_REQUEST_SYS_MSG, _savedConfig);
+      this.timeoutTimer = initTimeoutTimer(30000, EVENT_TIMEOUT_PAIRING_CONFIRMATION);
+    },
+
+    handleEvent: function (aEvent) {
+      switch (aEvent.id) {
+        case EVENT_P2P_SET_PAIRING_CONFIRMATION:
+          if (!aEvent.info.accepted) {
+            debug('User rejected invitation!');
+            _sm.gotoState(stateConnected);
+            break;
+          }
+
+          let onWpsCommandSent = function(success) {
+            _observer.onConnecting(_savedConfig);
+            _sm.gotoState(stateConnected);
+          };
+
+          _sm.pause();
+          if (WPS_METHOD_PBC === _savedConfig.wpsMethod) {
+            aP2pCommand.wpsPbc(onWpsCommandSent, _groupInfo.ifname);
+          } else {
+            let detail = { pin: _savedConfig.pin, iface: _groupInfo.ifname };
+            aP2pCommand.wpsPin(detail, onWpsCommandSent);
+          }
+          break;
+
+        case EVENT_TIMEOUT_PAIRING_CONFIRMATION:
+          debug('WAITING_FOR_JOINING_CONFIRMATION timeout!');
+          _sm.gotoState(stateConnected);
+          break;
+
+        default:
+          return false;
+      } // End of switch.
+      return true;
+    },
+
+    exit: function() {
+      this.timeoutTimer.cancel();
+      this.timeoutTimer = null;
+    }
+  });
+
+  var stateDisconnecting = _sm.makeState("DISCONNECTING", {
+    enter: function() {
+      _sm.pause();
+      handleGroupRemoved(_removedGroupInfo, function (success) {
+        if (!success) {
+          debug('Failed to handle group removed event. What can I do?');
+        }
+        _sm.gotoState(stateInactive);
+      });
+    },
+
+    handleEvent: function(aEvent) {
+      return false; // We will not receive any event in this state.
+    }
+  });
+
+  var stateDisabling = _sm.makeState("DISABLING", {
+    enter: function() {
+      _sm.pause();
+      aNetUtil.stopDhcpServer(function (success) { // Stopping DHCP server is harmless.
+        debug('Stop DHCP server result: ' + success);
+        aP2pCommand.p2pDisable(function(success) {
+          debug('P2P function disabled');
+          closeSupplicantConnectionIfNeeded(function() {
+            debug('Supplicant connection closed');
+            gNetworkService.disableInterface(P2P_INTERFACE_NAME, function (success){
+              debug('Disabled interface: ' + P2P_INTERFACE_NAME);
+              _onDisabled(true);
+              _observer.onDisabled();
+              _sm.gotoState(stateDisabled);
+            });
+          });
+        });
+      });
+
+      function closeSupplicantConnectionIfNeeded(callback) {
+        // No need to connect to supplicant on KK. Call back directly.
+        if (aP2pCommand.getSdkVersion() >= 19) {
+          callback();
+          return;
+        }
+        aP2pCommand.closeSupplicantConnection(callback);
+      }
+    },
+
+    handleEvent: function(aEvent) {
+      return false; // We will not receive any event in this state.
+    }
+  });
+
+  //----------------------------------------------------------
+  // Helper functions.
+  //----------------------------------------------------------
+
+  // Handle 'P2P_GROUP_STARTED' event. Note that this function
+  // will also do the state transitioning and error handling.
+  //
+  // @param aInfo Information carried by "P2P_GROUP_STARTED" event:
+  //   .role: P2P_ROLE_GO or P2P_ROLE_CLIENT
+  //   .ssid:
+  //   .freq:
+  //   .passphrase: Used to connect to GO for legacy device.
+  //   .goAddress:
+  //   .ifname: e.g. p2p-p2p0
+  //
+  // @param aCallback Callback function.
+  function handleGroupStarted(aInfo, aCallback) {
+    debug('handleGroupStarted: ' + JSON.stringify(aInfo));
+
+    function onSuccess()
+    {
+      _sm.gotoState(stateConnected);
+      aCallback(true);
+    }
+
+    function onFailure()
+    {
+      debug('Failed to handleGroupdStarted(). Remove the group...');
+      aP2pCommand.p2pGroupRemove(aInfo.ifname, function (success) {
+        aCallback(false);
+
+        if (success) {
+          return; // Stay in current state and wait for EVENT_P2P_GROUP_REMOVED.
+        }
+
+        debug('p2pGroupRemove command error!');
+        _sm.gotoState(stateInactive);
+      });
+    }
+
+    // Save this group information.
+    _groupInfo = aInfo;
+    _groupInfo.isGroupOwner = (P2P_ROLE_GO === aInfo.role);
+
+    if (_groupInfo.isGroupOwner) {
+      debug('Group owner. Start DHCP server');
+      let dhcpServerConfig = { ifname: aInfo.ifname,
+                               startIp: GO_DHCP_SERVER_IP_RANGE.startIp,
+                               endIp: GO_DHCP_SERVER_IP_RANGE.endIp,
+                               serverIp: GO_NETWORK_INTERFACE.ip,
+                               maskLength: GO_NETWORK_INTERFACE.maskLength };
+
+      aNetUtil.startDhcpServer(dhcpServerConfig, function (success) {
+        if (!success) {
+          debug('Failed to start DHCP server');
+          onFailure();
+          return;
+        }
+
+        // Update p2p network interface.
+        _p2pNetworkInterface.info.state = Ci.nsINetworkInfo.NETWORK_STATE_CONNECTED;
+        _p2pNetworkInterface.info.ips = [GO_NETWORK_INTERFACE.ip];
+        _p2pNetworkInterface.info.prefixLengths = [GO_NETWORK_INTERFACE.maskLength];
+        _p2pNetworkInterface.info.gateways = [GO_NETWORK_INTERFACE.ip];
+        handleP2pNetworkInterfaceStateChanged();
+
+        _groupInfo.networkInterface = _p2pNetworkInterface;
+
+        debug('Everything is done. Happy p2p GO~');
+        onSuccess();
+      });
+
+      return;
+    }
+
+    // We are the client.
+
+    debug("Client. Request IP from DHCP server on interface: " + _groupInfo.ifname);
+
+    aNetUtil.runDhcp(aInfo.ifname, 0, function(dhcpData) {
+      if(!dhcpData || !dhcpData.info) {
+        debug('Failed to run DHCP client');
+        onFailure();
+        return;
+      }
+
+      // Save network interface.
+      debug("DHCP request success: " + JSON.stringify(dhcpData.info));
+
+      // Update p2p network interface.
+      let maskLength =
+        netHelpers.getMaskLength(netHelpers.stringToIP(dhcpData.info.mask_str));
+      if (!maskLength) {
+        maskLength = 32; // max prefix for IPv4.
+      }
+      _p2pNetworkInterface.info.state = Ci.nsINetworkInfo.NETWORK_STATE_CONNECTED;
+      _p2pNetworkInterface.info.ips = [dhcpData.info.ipaddr_str];
+      _p2pNetworkInterface.info.prefixLengths = [maskLength];
+      if (typeof dhcpData.info.dns1_str == "string" &&
+          dhcpData.info.dns1_str.length) {
+        _p2pNetworkInterface.info.dnses.push(dhcpData.info.dns1_str);
+      }
+      if (typeof dhcpData.info.dns2_str == "string" &&
+          dhcpData.info.dns2_str.length) {
+        _p2pNetworkInterface.info.dnses.push(dhcpData.info.dns2_str);
+      }
+      _p2pNetworkInterface.info.gateways = [dhcpData.info.gateway_str];
+      handleP2pNetworkInterfaceStateChanged();
+
+      _groupInfo.networkInterface = _p2pNetworkInterface;
+
+      debug('Happy p2p client~');
+      onSuccess();
+    });
+  }
+
+  function resetP2pNetworkInterface() {
+    _p2pNetworkInterface.info.state = Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED;
+    _p2pNetworkInterface.info.ips = [];
+    _p2pNetworkInterface.info.prefixLengths = [];
+    _p2pNetworkInterface.info.dnses = [];
+    _p2pNetworkInterface.info.gateways = [];
+  }
+
+  function registerP2pNetworkInteface() {
+    if (!_p2pNetworkInterface.registered) {
+      resetP2pNetworkInterface();
+      gNetworkManager.registerNetworkInterface(_p2pNetworkInterface);
+      _p2pNetworkInterface.registered = true;
+    }
+  }
+
+  function unregisterP2pNetworkInteface() {
+    if (_p2pNetworkInterface.registered) {
+      resetP2pNetworkInterface();
+      gNetworkManager.unregisterNetworkInterface(_p2pNetworkInterface);
+      _p2pNetworkInterface.registered = false;
+    }
+  }
+
+  function handleP2pNetworkInterfaceStateChanged() {
+    gNetworkManager.updateNetworkInterface(_p2pNetworkInterface);
+  }
+
+  // Handle 'P2P_GROUP_STARTED' event.
+  //
+  // @param aInfo information carried by "P2P_GROUP_REMOVED" event:
+  //   .ifname
+  //   .role: "GO" or "client".
+  //
+  // @param aCallback Callback function.
+  function handleGroupRemoved(aInfo, aCallback) {
+    if (!_groupInfo) {
+      debug('No group info. Why?');
+      aCallback(true);
+      return;
+    }
+    if (_groupInfo.ifname !== aInfo.ifname ||
+        _groupInfo.role   !== aInfo.role) {
+      debug('Unmatched group info: ' + JSON.stringify(_groupInfo) +
+            ' v.s. ' + JSON.stringify(aInfo));
+    }
+
+    // Update p2p network interface.
+    _p2pNetworkInterface.info.state = Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED;
+    handleP2pNetworkInterfaceStateChanged();
+
+    if (P2P_ROLE_GO === aInfo.role) {
+      aNetUtil.stopDhcpServer(function(success) {
+        debug('Stop DHCP server result: ' + success);
+        aCallback(true);
+      });
+    } else {
+      aNetUtil.stopDhcp(aInfo.ifname, function() {
+        aCallback(true);
+      });
+    }
+  }
+
+  // Non state-specific event handler.
+  function handleEventCommon(aEvent) {
+    switch (aEvent.id) {
+      case EVENT_P2P_DEVICE_FOUND:
+        _observer.onPeerFound(aEvent.info);
+        break;
+
+      case EVENT_P2P_DEVICE_LOST:
+        _observer.onPeerLost(aEvent.info);
+        break;
+
+      case EVENT_P2P_CMD_DISABLE:
+        _onDisabled = aEvent.info.onDisabled;
+        _sm.gotoState(stateDisabling);
+        break;
+
+      case EVENT_P2P_CMD_ENABLE_SCAN:
+        if (_scanBlocked) {
+          _scanPostponded = true;
+          aEvent.info.callback(true);
+          break;
+        }
+        aP2pCommand.p2pEnableScan(P2P_SCAN_TIMEOUT_SEC, aEvent.info.callback);
+        break;
+
+      case EVENT_P2P_CMD_DISABLE_SCAN:
+        aP2pCommand.p2pDisableScan(aEvent.info.callback);
+        break;
+
+      case EVENT_P2P_FIND_STOPPED:
+        break;
+
+      case EVENT_P2P_CMD_BLOCK_SCAN:
+        _scanBlocked = true;
+        aP2pCommand.p2pDisableScan(function(success) {});
+        break;
+
+      case EVENT_P2P_CMD_UNBLOCK_SCAN:
+        _scanBlocked = false;
+        if (_scanPostponded) {
+          aP2pCommand.p2pEnableScan(P2P_SCAN_TIMEOUT_SEC, function(success) {});
+        }
+        break;
+
+      case EVENT_P2P_CMD_CONNECT:
+      case EVENT_P2P_CMD_DISCONNECT:
+        debug("The current state couldn't handle connect/disconnect request. Ignore it.");
+        break;
+
+      default:
+        return false;
+    } // End of switch.
+    return true;
+  }
+
+  function isInP2pManagedState(aState) {
+    let p2pManagedStates = [stateWaitingForConfirmation,
+                            stateWaitingForNegReq,
+                            stateProvisionDiscovery,
+                            stateWaitingForInvitationConfirmation,
+                            stateGroupAdding,
+                            stateReinvoking,
+                            stateConnecting,
+                            stateConnected,
+                            stateDisconnecting];
+
+    for (let i = 0; i < p2pManagedStates.length; i++) {
+      if (aState === p2pManagedStates[i]) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  function initTimeoutTimer(aTimeoutMs, aTimeoutEvent) {
+    let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+    function onTimerFired() {
+      _sm.sendEvent({ id: aTimeoutEvent });
+      timer = null;
+    }
+    timer.initWithCallback(onTimerFired.bind(this), aTimeoutMs,
+                           Ci.nsITimer.TYPE_ONE_SHOT);
+    return timer;
+  }
+
+  // Converts local WPS method to peer WPS method.
+  function toPeerWpsMethod(aLocalWpsMethod) {
+    switch (aLocalWpsMethod) {
+      case WPS_METHOD_DISPLAY:
+        return WPS_METHOD_KEYPAD;
+      case WPS_METHOD_KEYPAD:
+        return WPS_METHOD_DISPLAY;
+      case WPS_METHOD_PBC:
+        return WPS_METHOD_PBC;
+      default:
+        return WPS_METHOD_PBC; // Use "push button" as the default method.
+    }
+  }
+
+  return p2pSm;
+}
+
+this.WifiP2pManager.INTERFACE_NAME = P2P_INTERFACE_NAME;