/* jshint moz: true, esnext: true */

/* 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";

ChromeUtils.import("resource://gre/modules/AppConstants.jsm");

ChromeUtils.import("resource://gre/modules/Preferences.jsm");

ChromeUtils.import("resource://gre/modules/Services.jsm");

ChromeUtils.import("resource://gre/modules/Timer.jsm");

ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");

const {

  PushCrypto,

  getCryptoParams,

  CryptoError,

} = ChromeUtils.import("resource://gre/modules/PushCrypto.jsm");

const {PushDB} = ChromeUtils.import("resource://gre/modules/PushDB.jsm");

const CONNECTION_PROTOCOLS = (function() {

  if ('android' != AppConstants.MOZ_WIDGET_TOOLKIT) {

    const {PushServiceWebSocket} = ChromeUtils.import("resource://gre/modules/PushServiceWebSocket.jsm");

    const {PushServiceHttp2} = ChromeUtils.import("resource://gre/modules/PushServiceHttp2.jsm");

    return [PushServiceWebSocket, PushServiceHttp2];

  } else {

    const {PushServiceAndroidGCM} = ChromeUtils.import("resource://gre/modules/PushServiceAndroidGCM.jsm");

    return [PushServiceAndroidGCM];

  }

})();

XPCOMUtils.defineLazyServiceGetter(this, "gPushNotifier",

                                   "@mozilla.org/push/Notifier;1",

                                   "nsIPushNotifier");

var EXPORTED_SYMBOLS = ["PushService"];

XPCOMUtils.defineLazyGetter(this, "console", () => {

  let {ConsoleAPI} = ChromeUtils.import("resource://gre/modules/Console.jsm", {});

  return new ConsoleAPI({

    maxLogLevelPref: "dom.push.loglevel",

    prefix: "PushService",

  });

});

const prefs = new Preferences("dom.push.");

const PUSH_SERVICE_UNINIT = 0;

const PUSH_SERVICE_INIT = 1; // No serverURI

const PUSH_SERVICE_ACTIVATING = 2;//activating db

const PUSH_SERVICE_CONNECTION_DISABLE = 3;

const PUSH_SERVICE_ACTIVE_OFFLINE = 4;

const PUSH_SERVICE_RUNNING = 5;

/**

 * State is change only in couple of functions:

 *   init - change state to PUSH_SERVICE_INIT if state was PUSH_SERVICE_UNINIT

 *   changeServerURL - change state to PUSH_SERVICE_ACTIVATING if serverURL

 *                     present or PUSH_SERVICE_INIT if not present.

 *   changeStateConnectionEnabledEvent - it is call on pref change or during

 *                                       the service activation and it can

 *                                       change state to

 *                                       PUSH_SERVICE_CONNECTION_DISABLE

 *   changeStateOfflineEvent - it is called when offline state changes or during

 *                             the service activation and it change state to

 *                             PUSH_SERVICE_ACTIVE_OFFLINE or

 *                             PUSH_SERVICE_RUNNING.

 *   uninit - change state to PUSH_SERVICE_UNINIT.

 **/

// This is for starting and stopping service.

const STARTING_SERVICE_EVENT = 0;

const CHANGING_SERVICE_EVENT = 1;

const STOPPING_SERVICE_EVENT = 2;

const UNINIT_EVENT = 3;

/**

 * Annotates an error with an XPCOM result code. We use this helper

 * instead of `Components.Exception` because the latter can assert in

 * `nsXPCComponents_Exception::HasInstance` when inspected at shutdown.

 */

function errorWithResult(message, result = Cr.NS_ERROR_FAILURE) {

  let error = new Error(message);

  error.result = result;

  return error;

}

/**

 * Copied from ForgetAboutSite.jsm.

 *

 * Returns true if the string passed in is part of the root domain of the

 * current string.  For example, if this is "www.mozilla.org", and we pass in

 * "mozilla.org", this will return true.  It would return false the other way

 * around.

 */

function hasRootDomain(str, aDomain)

{

  let index = str.indexOf(aDomain);

  // If aDomain is not found, we know we do not have it as a root domain.

  if (index == -1)

    return false;

  // If the strings are the same, we obviously have a match.

  if (str == aDomain)

    return true;

  // Otherwise, we have aDomain as our root domain iff the index of aDomain is

  // aDomain.length subtracted from our length and (since we do not have an

  // exact match) the character before the index is a dot or slash.

  let prevChar = str[index - 1];

  return (index == (str.length - aDomain.length)) &&

         (prevChar == "." || prevChar == "/");

}

/**

 * The implementation of the push system. It uses WebSockets

 * (PushServiceWebSocket) to communicate with the server and PushDB (IndexedDB)

 * for persistence.

 */

var PushService = {

  _service: null,

  _state: PUSH_SERVICE_UNINIT,

  _db: null,

  _options: null,

  _visibleNotifications: new Map(),

  // Callback that is called after attempting to

  // reduce the quota for a record. Used for testing purposes.

  _updateQuotaTestCallback: null,

  // Set of timeout ID of tasks to reduce quota.

  _updateQuotaTimeouts: new Set(),

  // When serverURI changes (this is used for testing), db is cleaned up and a

  // a new db is started. This events must be sequential.

  _stateChangeProcessQueue: null,

  _stateChangeProcessEnqueue: function(op) {

    if (!this._stateChangeProcessQueue) {

      this._stateChangeProcessQueue = Promise.resolve();

    }

    this._stateChangeProcessQueue = this._stateChangeProcessQueue

      .then(op)

      .catch(error => {

        console.error(

          "stateChangeProcessEnqueue: Error transitioning state", error);

        return this._shutdownService();

      })

      .catch(error => {

        console.error(

          "stateChangeProcessEnqueue: Error shutting down service", error);

      });

    return this._stateChangeProcessQueue;

  },

  // Pending request. If a worker try to register for the same scope again, do

  // not send a new registration request. Therefore we need queue of pending

  // register requests. This is the list of scopes which pending registration.

  _pendingRegisterRequest: {},

  _notifyActivated: null,

  _activated: null,

  _checkActivated: function() {

    if (this._state < PUSH_SERVICE_ACTIVATING) {

      return Promise.reject(new Error("Push service not active"));

    } else if (this._state > PUSH_SERVICE_ACTIVATING) {

      return Promise.resolve();

    } else {

      return (this._activated) ? this._activated :

                                 this._activated = new Promise((res, rej) =>

                                   this._notifyActivated = {resolve: res,

                                                            reject: rej});

    }

  },

  _makePendingKey: function(aPageRecord) {

    return aPageRecord.scope + "|" + aPageRecord.originAttributes;

  },

  _lookupOrPutPendingRequest: function(aPageRecord) {

    let key = this._makePendingKey(aPageRecord);

    if (this._pendingRegisterRequest[key]) {

      return this._pendingRegisterRequest[key];

    }

    return this._pendingRegisterRequest[key] = this._registerWithServer(aPageRecord);

  },

  _deletePendingRequest: function(aPageRecord) {

    let key = this._makePendingKey(aPageRecord);

    if (this._pendingRegisterRequest[key]) {

      delete this._pendingRegisterRequest[key];

    }

  },

  _setState: function(aNewState) {

    console.debug("setState()", "new state", aNewState, "old state", this._state);

    if (this._state == aNewState) {

      return;

    }

    if (this._state == PUSH_SERVICE_ACTIVATING) {

      // It is not important what is the new state as soon as we leave

      // PUSH_SERVICE_ACTIVATING

      if (this._notifyActivated) {

        if (aNewState < PUSH_SERVICE_ACTIVATING) {

          this._notifyActivated.reject(new Error("Push service not active"));

        } else {

          this._notifyActivated.resolve();

        }

      }

      this._notifyActivated = null;

      this._activated = null;

    }

    this._state = aNewState;

  },

  async _changeStateOfflineEvent(offline, calledFromConnEnabledEvent) {

    console.debug("changeStateOfflineEvent()", offline);

    if (this._state < PUSH_SERVICE_ACTIVE_OFFLINE &&

        this._state != PUSH_SERVICE_ACTIVATING &&

        !calledFromConnEnabledEvent) {

      return;

    }

    if (offline) {

      if (this._state == PUSH_SERVICE_RUNNING) {

        this._service.disconnect();

      }

      this._setState(PUSH_SERVICE_ACTIVE_OFFLINE);

      return;

    }

    if (this._state == PUSH_SERVICE_RUNNING) {

      // PushService was not in the offline state, but got notification to

      // go online (a offline notification has not been sent).

      // Disconnect first.

      this._service.disconnect();

    }

    let records = await this.getAllUnexpired();

    this._setState(PUSH_SERVICE_RUNNING);

    if (records.length > 0 || prefs.get("alwaysConnect")) {

      // Connect if we have existing subscriptions, or if the always-on pref

      // is set.

      this._service.connect(records);

    }

  },

  _changeStateConnectionEnabledEvent: function(enabled) {

    console.debug("changeStateConnectionEnabledEvent()", enabled);

    if (this._state < PUSH_SERVICE_CONNECTION_DISABLE &&

        this._state != PUSH_SERVICE_ACTIVATING) {

      return Promise.resolve();

    }

    if (enabled) {

      return this._changeStateOfflineEvent(Services.io.offline, true);

    }

    if (this._state == PUSH_SERVICE_RUNNING) {

      this._service.disconnect();

    }

    this._setState(PUSH_SERVICE_CONNECTION_DISABLE);

    return Promise.resolve();

  },

  // Used for testing.

  changeTestServer(url, options = {}) {

    console.debug("changeTestServer()");

    return this._stateChangeProcessEnqueue(_ => {

      if (this._state < PUSH_SERVICE_ACTIVATING) {

        console.debug("changeTestServer: PushService not activated?");

        return Promise.resolve();

      }

      return this._changeServerURL(url, CHANGING_SERVICE_EVENT, options);

    });

  },

  observe: function observe(aSubject, aTopic, aData) {

    switch (aTopic) {

      /*

       * We need to call uninit() on shutdown to clean up things that modules

       * aren't very good at automatically cleaning up, so we don't get shutdown

       * leaks on browser shutdown.

       */

      case "quit-application":

        this.uninit();

        break;

      case "network:offline-status-changed":

        this._stateChangeProcessEnqueue(_ =>

          this._changeStateOfflineEvent(aData === "offline", false)

        );

        break;

      case "nsPref:changed":

        if (aData == "dom.push.serverURL") {

          console.debug("observe: dom.push.serverURL changed for websocket",

                prefs.get("serverURL"));

          this._stateChangeProcessEnqueue(_ =>

            this._changeServerURL(prefs.get("serverURL"),

                                  CHANGING_SERVICE_EVENT)

          );

        } else if (aData == "dom.push.connection.enabled") {

          this._stateChangeProcessEnqueue(_ =>

            this._changeStateConnectionEnabledEvent(prefs.get("connection.enabled"))

          );

        }

        break;

      case "idle-daily":

        this._dropExpiredRegistrations().catch(error => {

          console.error("Failed to drop expired registrations on idle", error);

        });

        break;

      case "perm-changed":

        this._onPermissionChange(aSubject, aData).catch(error => {

          console.error("onPermissionChange: Error updating registrations:",

            error);

        })

        break;

      case "clear-origin-attributes-data":

        this._clearOriginData(aData).catch(error => {

          console.error("clearOriginData: Error clearing origin data:", error);

        });

        break;

    }

  },

  _clearOriginData: function(data) {

    console.log("clearOriginData()");

    if (!data) {

      return Promise.resolve();

    }

    let pattern = JSON.parse(data);

    return this._dropRegistrationsIf(record =>

      record.matchesOriginAttributes(pattern));

  },

  /**

   * Sends an unregister request to the server in the background. If the

   * service is not connected, this function is a no-op.

   *

   * @param {PushRecord} record The record to unregister.

   * @param {Number} reason An `nsIPushErrorReporter` unsubscribe reason,

   *  indicating why this record was removed.

   */

  _backgroundUnregister(record, reason) {

    console.debug("backgroundUnregister()");

    if (!this._service.isConnected() || !record) {

      return;

    }

    console.debug("backgroundUnregister: Notifying server", record);

    this._sendUnregister(record, reason).then(() => {

      gPushNotifier.notifySubscriptionModified(record.scope, record.principal);

    }).catch(e => {

      console.error("backgroundUnregister: Error notifying server", e);

    });

  },

  _findService: function(serverURL) {

    console.debug("findService()");

    let uri;

    let service;

    if (!serverURL) {

      console.warn("findService: No dom.push.serverURL found");

      return [];

    }

    try {

      uri = Services.io.newURI(serverURL);

    } catch (e) {

      console.warn("findService: Error creating valid URI from",

        "dom.push.serverURL", serverURL);

      return [];

    }

    for (let connProtocol of CONNECTION_PROTOCOLS) {

      if (connProtocol.validServerURI(uri)) {

        service = connProtocol;

        break;

      }

    }

    return [service, uri];

  },

  _changeServerURL: function(serverURI, event, options = {}) {

    console.debug("changeServerURL()");

    switch(event) {

      case UNINIT_EVENT:

        return this._stopService(event);

      case STARTING_SERVICE_EVENT:

      {

        let [service, uri] = this._findService(serverURI);

        if (!service) {

          this._setState(PUSH_SERVICE_INIT);

          return Promise.resolve();

        }

        return this._startService(service, uri, options)

          .then(_ => this._changeStateConnectionEnabledEvent(prefs.get("connection.enabled"))

          );

      }

      case CHANGING_SERVICE_EVENT:

        let [service, uri] = this._findService(serverURI);

        if (service) {

          if (this._state == PUSH_SERVICE_INIT) {

            this._setState(PUSH_SERVICE_ACTIVATING);

            // The service has not been running - start it.

            return this._startService(service, uri, options)

              .then(_ => this._changeStateConnectionEnabledEvent(prefs.get("connection.enabled"))

              );

          } else {

            this._setState(PUSH_SERVICE_ACTIVATING);

            // If we already had running service - stop service, start the new

            // one and check connection.enabled and offline state(offline state

            // check is called in changeStateConnectionEnabledEvent function)

            return this._stopService(CHANGING_SERVICE_EVENT)

              .then(_ =>

                 this._startService(service, uri, options)

              )

              .then(_ => this._changeStateConnectionEnabledEvent(prefs.get("connection.enabled"))

              );

          }

        } else {

          if (this._state == PUSH_SERVICE_INIT) {

            return Promise.resolve();

          } else {

            // The new serverUri is empty or misconfigured - stop service.

            this._setState(PUSH_SERVICE_INIT);

            return this._stopService(STOPPING_SERVICE_EVENT);

          }

        }

      default:

        console.error("Unexpected event in _changeServerURL", event);

        return Promise.reject(new Error(`Unexpected event ${event}`));

    }

  },

  /**

   * PushService initialization is divided into 4 parts:

   * init() - start listening for quit-application and serverURL changes.

   *          state is change to PUSH_SERVICE_INIT

   * startService() - if serverURL is present this function is called. It starts

   *                  listening for broadcasted messages, starts db and

   *                  PushService connection (WebSocket).

   *                  state is change to PUSH_SERVICE_ACTIVATING.

   * startObservers() - start other observers.

   * changeStateConnectionEnabledEvent  - checks prefs and offline state.

   *                                      It changes state to:

   *                                        PUSH_SERVICE_RUNNING,

   *                                        PUSH_SERVICE_ACTIVE_OFFLINE or

   *                                        PUSH_SERVICE_CONNECTION_DISABLE.

   */

  init: function(options = {}) {

    console.debug("init()");

    if (this._state > PUSH_SERVICE_UNINIT) {

      return;

    }

    this._setState(PUSH_SERVICE_ACTIVATING);

    prefs.observe("serverURL", this);

    Services.obs.addObserver(this, "quit-application");

    if (options.serverURI) {

      // this is use for xpcshell test.

      this._stateChangeProcessEnqueue(_ =>

        this._changeServerURL(options.serverURI, STARTING_SERVICE_EVENT, options));

    } else {

      // This is only used for testing. Different tests require connecting to

      // slightly different URLs.

      this._stateChangeProcessEnqueue(_ =>

        this._changeServerURL(prefs.get("serverURL"), STARTING_SERVICE_EVENT));

    }

  },

  _startObservers: function() {

    console.debug("startObservers()");

    if (this._state != PUSH_SERVICE_ACTIVATING) {

      return;

    }

    Services.obs.addObserver(this, "clear-origin-attributes-data");

    // The offline-status-changed event is used to know

    // when to (dis)connect. It may not fire if the underlying OS changes

    // networks; in such a case we rely on timeout.

    Services.obs.addObserver(this, "network:offline-status-changed");

    // Used to monitor if the user wishes to disable Push.

    prefs.observe("connection.enabled", this);

    // Prunes expired registrations and notifies dormant service workers.

    Services.obs.addObserver(this, "idle-daily");

    // Prunes registrations for sites for which the user revokes push

    // permissions.

    Services.obs.addObserver(this, "perm-changed");

  },

  _startService(service, serverURI, options) {

    console.debug("startService()");

    if (this._state != PUSH_SERVICE_ACTIVATING) {

      return Promise.reject();

    }

    this._service = service;

    this._db = options.db;

    if (!this._db) {

      this._db = this._service.newPushDB();

    }

    return this._service.init(options, this, serverURI)

      .then(() => {

        this._startObservers();

        return this._dropExpiredRegistrations();

      });

  },

  /**

   * PushService uninitialization is divided into 3 parts:

   * stopObservers() - stot observers started in startObservers.

   * stopService() - It stops listening for broadcasted messages, stops db and

   *                 PushService connection (WebSocket).

   *                 state is changed to PUSH_SERVICE_INIT.

   * uninit() - stop listening for quit-application and serverURL changes.

   *            state is change to PUSH_SERVICE_UNINIT

   */

  _stopService: function(event) {

    console.debug("stopService()");

    if (this._state < PUSH_SERVICE_ACTIVATING) {

      return Promise.resolve();

    }

    this._stopObservers();

    this._service.disconnect();

    this._service.uninit();

    this._service = null;

    this._updateQuotaTimeouts.forEach((timeoutID) => clearTimeout(timeoutID));

    this._updateQuotaTimeouts.clear();

    if (!this._db) {

      return Promise.resolve();

    }

    if (event == UNINIT_EVENT) {

      // If it is uninitialized just close db.

      this._db.close();

      this._db = null;

      return Promise.resolve();

    }

    return this.dropUnexpiredRegistrations()

       .then(_ => {

         this._db.close();

         this._db = null;

       }, err => {

         this._db.close();

         this._db = null;

       });

  },

  _stopObservers: function() {

    console.debug("stopObservers()");

    if (this._state < PUSH_SERVICE_ACTIVATING) {

      return;

    }

    prefs.ignore("connection.enabled", this);

    Services.obs.removeObserver(this, "network:offline-status-changed");

    Services.obs.removeObserver(this, "clear-origin-attributes-data");

    Services.obs.removeObserver(this, "idle-daily");

    Services.obs.removeObserver(this, "perm-changed");

  },

  _shutdownService() {

    let promiseChangeURL = this._changeServerURL("", UNINIT_EVENT);

    this._setState(PUSH_SERVICE_UNINIT);

    console.debug("shutdownService: shutdown complete!");

    return promiseChangeURL;

  },

  uninit: function() {

    console.debug("uninit()");

    if (this._state == PUSH_SERVICE_UNINIT) {

      return;

    }

    prefs.ignore("serverURL", this);

    Services.obs.removeObserver(this, "quit-application");

    this._stateChangeProcessEnqueue(_ => this._shutdownService());

  },

  /**

   * Drops all active registrations and notifies the associated service

   * workers. This function is called when the user switches Push servers,

   * or when the server invalidates all existing registrations.

   *

   * We ignore expired registrations because they're already handled in other

   * code paths. Registrations that expired after exceeding their quotas are

   * evicted at startup, or on the next `idle-daily` event. Registrations that

   * expired because the user revoked the notification permission are evicted

   * once the permission is reinstated.

   */

  dropUnexpiredRegistrations: function() {

    return this._db.clearIf(record => {

      if (record.isExpired()) {

        return false;

      }

      this._notifySubscriptionChangeObservers(record);

      return true;

    });

  },

  _notifySubscriptionChangeObservers: function(record) {

    if (!record) {

      return;

    }

    gPushNotifier.notifySubscriptionChange(record.scope, record.principal);

  },

  /**

   * Drops a registration and notifies the associated service worker. If the

   * registration does not exist, this function is a no-op.

   *

   * @param {String} keyID The registration ID to remove.

   * @returns {Promise} Resolves once the worker has been notified.

   */

  dropRegistrationAndNotifyApp: function(aKeyID) {

    return this._db.delete(aKeyID)

      .then(record => this._notifySubscriptionChangeObservers(record));

  },

  /**

   * Replaces an existing registration and notifies the associated service

   * worker.

   *

   * @param {String} aOldKey The registration ID to replace.

   * @param {PushRecord} aNewRecord The new record.

   * @returns {Promise} Resolves once the worker has been notified.

   */

  updateRegistrationAndNotifyApp: function(aOldKey, aNewRecord) {

    return this.updateRecordAndNotifyApp(aOldKey, _ => aNewRecord);

  },

  /**

   * Updates a registration and notifies the associated service worker.

   *

   * @param {String} keyID The registration ID to update.

   * @param {Function} updateFunc Returns the updated record.

   * @returns {Promise} Resolves with the updated record once the worker

   *  has been notified.

   */

  updateRecordAndNotifyApp: function(aKeyID, aUpdateFunc) {

    return this._db.update(aKeyID, aUpdateFunc)

      .then(record => {

        this._notifySubscriptionChangeObservers(record);

        return record;

      });

  },

  ensureCrypto: function(record) {

    if (record.hasAuthenticationSecret() &&

        record.p256dhPublicKey &&

        record.p256dhPrivateKey) {

      return Promise.resolve(record);

    }

    let keygen = Promise.resolve([]);

    if (!record.p256dhPublicKey || !record.p256dhPrivateKey) {

      keygen = PushCrypto.generateKeys();

    }

    // We do not have a encryption key. so we need to generate it. This

    // is only going to happen on db upgrade from version 4 to higher.

    return keygen

      .then(([pubKey, privKey]) => {

        return this.updateRecordAndNotifyApp(record.keyID, record => {

          if (!record.p256dhPublicKey || !record.p256dhPrivateKey) {

            record.p256dhPublicKey = pubKey;

            record.p256dhPrivateKey = privKey;

          }

          if (!record.hasAuthenticationSecret()) {

            record.authenticationSecret = PushCrypto.generateAuthenticationSecret();

          }

          return record;

        });

      }, error => {

        return this.dropRegistrationAndNotifyApp(record.keyID).then(

          () => Promise.reject(error));

      });

  },

  /**

   * Dispatches an incoming message to a service worker, recalculating the

   * quota for the associated push registration. If the quota is exceeded,

   * the registration and message will be dropped, and the worker will not

   * be notified.

   *

   * @param {String} keyID The push registration ID.

   * @param {String} messageID The message ID, used to report service worker

   *  delivery failures. For Web Push messages, this is the version. If empty,

   *  failures will not be reported.

   * @param {Object} headers The encryption headers.

   * @param {ArrayBuffer|Uint8Array} data The encrypted message data.

   * @param {Function} updateFunc A function that receives the existing

   *  registration record as its argument, and returns a new record. If the

   *  function returns `null` or `undefined`, the record will not be updated.

   *  `PushServiceWebSocket` uses this to drop incoming updates with older

   *  versions.

   * @returns {Promise} Resolves with an `nsIPushErrorReporter` ack status

   *  code, indicating whether the message was delivered successfully.

   */

  receivedPushMessage(keyID, messageID, headers, data, updateFunc) {

    console.debug("receivedPushMessage()");

    return this._updateRecordAfterPush(keyID, updateFunc).then(record => {

      if (record.quotaApplies()) {

        // Update quota after the delay, at which point

        // we check for visible notifications.

        let timeoutID = setTimeout(_ =>

          {

            this._updateQuota(keyID);

            if (!this._updateQuotaTimeouts.delete(timeoutID)) {

              console.debug("receivedPushMessage: quota update timeout missing?");

            }

          }, prefs.get("quotaUpdateDelay"));

        this._updateQuotaTimeouts.add(timeoutID);

      }

      return this._decryptAndNotifyApp(record, messageID, headers, data);

    }).catch(error => {

      console.error("receivedPushMessage: Error notifying app", error);

      return Ci.nsIPushErrorReporter.ACK_NOT_DELIVERED;

    });

  },

  /**

   * Updates a registration record after receiving a push message.

   *

   * @param {String} keyID The push registration ID.

   * @param {Function} updateFunc The function passed to `receivedPushMessage`.

   * @returns {Promise} Resolves with the updated record, or rejects if the

   *  record was not updated.

   */

  _updateRecordAfterPush(keyID, updateFunc) {

    return this.getByKeyID(keyID).then(record => {

      if (!record) {

        throw new Error("No record for key ID " + keyID);

      }

      return record.getLastVisit().then(lastVisit => {

        // As a special case, don't notify the service worker if the user

        // cleared their history.

        if (!isFinite(lastVisit)) {

          throw new Error("Ignoring message sent to unvisited origin");

        }

        return lastVisit;

      }).then(lastVisit => {

        // Update the record, resetting the quota if the user has visited the

        // site since the last push.

        return this._db.update(keyID, record => {

          let newRecord = updateFunc(record);

          if (!newRecord) {

            return null;

          }

          // Because `unregister` is advisory only, we can still receive messages

          // for stale Simple Push registrations from the server. To work around

          // this, we check if the record has expired before *and* after updating

          // the quota.

          if (newRecord.isExpired()) {

            return null;

          }

          newRecord.receivedPush(lastVisit);

          return newRecord;

        });

      });

    }).then(record => {

      gPushNotifier.notifySubscriptionModified(record.scope,

                                               record.principal);

      return record;

    });

  },

  /**

   * Decrypts an incoming message and notifies the associated service worker.

   *

   * @param {PushRecord} record The receiving registration.

   * @param {String} messageID The message ID.

   * @param {Object} headers The encryption headers.

   * @param {ArrayBuffer|Uint8Array} data The encrypted message data.

   * @returns {Promise} Resolves with an ack status code.

   */

  _decryptAndNotifyApp(record, messageID, headers, data) {

    return PushCrypto.decrypt(record.p256dhPrivateKey, record.p256dhPublicKey,

                              record.authenticationSecret, headers, data)

      .then(

        message => this._notifyApp(record, messageID, message),

        error => {

          console.warn("decryptAndNotifyApp: Error decrypting message",

            record.scope, messageID, error);

          let message = error.format(record.scope);

          gPushNotifier.notifyError(record.scope, record.principal, message,

                                    Ci.nsIScriptError.errorFlag);

          return Ci.nsIPushErrorReporter.ACK_DECRYPTION_ERROR;

        });

  },

  _updateQuota: function(keyID) {

    console.debug("updateQuota()");

    this._db.update(keyID, record => {

      // Record may have expired from an earlier quota update.

      if (record.isExpired()) {

        console.debug(

          "updateQuota: Trying to update quota for expired record", record);

        return null;

      }

      // If there are visible notifications, don't apply the quota penalty

      // for the message.

      if (record.uri && !this._visibleNotifications.has(record.uri.prePath)) {

        record.reduceQuota();

      }

      return record;

    }).then(record => {

      if (record.isExpired()) {

        // Drop the registration in the background. If the user returns to the

        // site, the service worker will be notified on the next `idle-daily`

        // event.

        this._backgroundUnregister(record,

          Ci.nsIPushErrorReporter.UNSUBSCRIBE_QUOTA_EXCEEDED);

      } else {

        gPushNotifier.notifySubscriptionModified(record.scope,

                                                 record.principal);

      }

      if (this._updateQuotaTestCallback) {

        // Callback so that test may be notified when the quota update is complete.

        this._updateQuotaTestCallback();

      }

    }).catch(error => {

      console.debug("updateQuota: Error while trying to update quota", error);

    });

  },

  notificationForOriginShown(origin) {

    console.debug("notificationForOriginShown()", origin);

    let count;

    if (this._visibleNotifications.has(origin)) {

      count = this._visibleNotifications.get(origin);

    } else {

      count = 0;