gecko/dom/datastore/DataStoreCursorImpl.jsm

439 lines
13 KiB
JavaScript
Raw Normal View History

/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
/* 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'
this.EXPORTED_SYMBOLS = ['DataStoreCursor'];
function debug(s) {
//dump('DEBUG DataStoreCursor: ' + s + '\n');
}
const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
const STATE_INIT = 0;
const STATE_REVISION_INIT = 1;
const STATE_REVISION_CHECK = 2;
const STATE_SEND_ALL = 3;
const STATE_REVISION_SEND = 4;
const STATE_DONE = 5;
const REVISION_ADDED = 'added';
const REVISION_UPDATED = 'updated';
const REVISION_REMOVED = 'removed';
const REVISION_VOID = 'void';
const REVISION_SKIP = 'skip'
Cu.import('resource://gre/modules/Services.jsm');
Cu.import('resource://gre/modules/XPCOMUtils.jsm');
/**
* legend:
* - RID = revision ID
* - R = revision object (with the internalRevisionId that is a number)
* - X = current object ID.
* - L = the list of revisions that we have to send
*
* State: init: do you have RID ?
* YES: state->initRevision; loop
* NO: get R; X=0; state->sendAll; send a 'clear'
*
* State: initRevision. Get R from RID. Done?
* YES: state->revisionCheck; loop
* NO: RID = null; state->init; loop
*
* State: revisionCheck: get all the revisions between R and NOW. Done?
* YES and R == NOW: state->done; loop
* YES and R != NOW: Store this revisions in L; state->revisionSend; loop
* NO: R = NOW; X=0; state->sendAll; send a 'clear'
*
* State: sendAll: is R still the last revision?
* YES get the first object with id > X. Done?
* YES: X = object.id; send 'add'
* NO: state->revisionCheck; loop
* NO: R = NOW; X=0; send a 'clear'
*
* State: revisionSend: do you have something from L to send?
* YES and L[0] == 'removed': R=L[0]; send 'remove' with ID
* YES and L[0] == 'added': R=L[0]; get the object; found?
* NO: loop
* YES: send 'add' with ID and object
* YES and L[0] == 'updated': R=L[0]; get the object; found?
* NO: loop
* YES and object.R > R: continue
* YES and object.R <= R: send 'update' with ID and object
* YES L[0] == 'void': R=L[0]; state->init; loop
* NO: state->revisionCheck; loop
*
* State: done: send a 'done' with R
*/
/* Helper functions */
function createDOMError(aWindow, aEvent) {
return new aWindow.DOMError(aEvent.target.error.name);
}
/* DataStoreCursor object */
this.DataStoreCursor = function(aWindow, aDataStore, aRevisionId) {
debug("DataStoreCursor created");
this.init(aWindow, aDataStore, aRevisionId);
}
this.DataStoreCursor.prototype = {
classDescription: 'DataStoreCursor XPCOM Component',
classID: Components.ID('{b6d14349-1eab-46b8-8513-584a7328a26b}'),
contractID: '@mozilla.org/dom/datastore-cursor-impl;1',
QueryInterface: XPCOMUtils.generateQI([Components.interfaces.nsISupports]),
_shuttingdown: false,
_window: null,
_dataStore: null,
_revisionId: null,
_revision: null,
_revisionsList: null,
_objectId: 0,
_state: STATE_INIT,
init: function(aWindow, aDataStore, aRevisionId) {
debug('DataStoreCursor init');
this._window = aWindow;
this._dataStore = aDataStore;
this._revisionId = aRevisionId;
Services.obs.addObserver(this, "inner-window-destroyed", false);
let util = aWindow.QueryInterface(Ci.nsIInterfaceRequestor)
.getInterface(Ci.nsIDOMWindowUtils);
this._innerWindowID = util.currentInnerWindowID;
},
observe: function(aSubject, aTopic, aData) {
let wId = aSubject.QueryInterface(Ci.nsISupportsPRUint64).data;
if (wId == this._innerWindowID) {
Services.obs.removeObserver(this, "inner-window-destroyed");
this._shuttingdown = true;
}
},
// This is the implementation of the state machine.
// Read the comments at the top of this file in order to follow what it does.
stateMachine: function(aStore, aRevisionStore, aResolve, aReject) {
debug('StateMachine: ' + this._state);
// If the window has been destroyed we cannot create the Promise object.
if (this._shuttingdown) {
return;
}
switch (this._state) {
case STATE_INIT:
this.stateMachineInit(aStore, aRevisionStore, aResolve, aReject);
break;
case STATE_REVISION_INIT:
this.stateMachineRevisionInit(aStore, aRevisionStore, aResolve, aReject);
break;
case STATE_REVISION_CHECK:
this.stateMachineRevisionCheck(aStore, aRevisionStore, aResolve, aReject);
break;
case STATE_SEND_ALL:
this.stateMachineSendAll(aStore, aRevisionStore, aResolve, aReject);
break;
case STATE_REVISION_SEND:
this.stateMachineRevisionSend(aStore, aRevisionStore, aResolve, aReject);
break;
case STATE_DONE:
this.stateMachineDone(aStore, aRevisionStore, aResolve, aReject);
break;
}
},
stateMachineInit: function(aStore, aRevisionStore, aResolve, aReject) {
debug('StateMachineInit');
if (this._revisionId) {
this._state = STATE_REVISION_INIT;
this.stateMachine(aStore, aRevisionStore, aResolve, aReject);
return;
}
let self = this;
let request = aRevisionStore.openCursor(null, 'prev');
request.onsuccess = function(aEvent) {
self._revision = aEvent.target.result.value;
self._objectId = 0;
self._state = STATE_SEND_ALL;
aResolve(self.createTask('clear', null, '', null));
}
},
stateMachineRevisionInit: function(aStore, aRevisionStore, aResolve, aReject) {
debug('StateMachineRevisionInit');
let self = this;
let request = this._dataStore._db.getInternalRevisionId(
self._revisionId,
aRevisionStore,
function(aInternalRevisionId) {
// This revision doesn't exist.
if (aInternalRevisionId == undefined) {
self._revisionId = null;
self._objectId = 0;
self._state = STATE_INIT;
self.stateMachine(aStore, aRevisionStore, aResolve, aReject);
return;
}
self._revision = { revisionId: self._revisionId,
internalRevisionId: aInternalRevisionId };
self._state = STATE_REVISION_CHECK;
self.stateMachine(aStore, aRevisionStore, aResolve, aReject);
}
);
},
stateMachineRevisionCheck: function(aStore, aRevisionStore, aResolve, aReject) {
debug('StateMachineRevisionCheck');
let changes = {
addedIds: {},
updatedIds: {},
removedIds: {}
};
let self = this;
let request = aRevisionStore.mozGetAll(
self._window.IDBKeyRange.lowerBound(this._revision.internalRevisionId, true));
request.onsuccess = function(aEvent) {
// Optimize the operations.
for (let i = 0; i < aEvent.target.result.length; ++i) {
let data = aEvent.target.result[i];
switch (data.operation) {
case REVISION_ADDED:
changes.addedIds[data.objectId] = data.internalRevisionId;
break;
case REVISION_UPDATED:
// We don't consider an update if this object has been added
// or if it has been already modified by a previous
// operation.
if (!(data.objectId in changes.addedIds) &&
!(data.objectId in changes.updatedIds)) {
changes.updatedIds[data.objectId] = data.internalRevisionId;
}
break;
case REVISION_REMOVED:
let id = data.objectId;
// If the object has been added in this range of revisions
// we can ignore it and remove it from the list.
if (id in changes.addedIds) {
delete changes.addedIds[id];
} else {
changes.removedIds[id] = data.internalRevisionId;
}
if (id in changes.updatedIds) {
delete changes.updatedIds[id];
}
break;
case REVISION_VOID:
if (i != 0) {
dump('Internal error: Revision "' + REVISION_VOID + '" should not be found!!!\n');
return;
}
self._revisionId = null;
self._objectId = 0;
self._state = STATE_INIT;
self.stateMachine(aStore, aRevisionStore, aResolve, aReject);
return;
}
}
// From changes to a map of internalRevisionId.
let revisions = {};
function addRevisions(obj) {
for (let key in obj) {
revisions[obj[key]] = true;
}
}
addRevisions(changes.addedIds);
addRevisions(changes.updatedIds);
addRevisions(changes.removedIds);
// Create the list of revisions.
let list = [];
for (let i = 0; i < aEvent.target.result.length; ++i) {
let data = aEvent.target.result[i];
// If this revision doesn't contain useful data, we still need to keep
// it in the list because we need to update the internal revision ID.
if (!(data.internalRevisionId in revisions)) {
data.operation = REVISION_SKIP;
}
list.push(data);
}
if (list.length == 0) {
self._state = STATE_DONE;
self.stateMachine(aStore, aRevisionStore, aResolve, aReject);
return;
}
// Some revision has to be sent.
self._revisionsList = list;
self._state = STATE_REVISION_SEND;
self.stateMachine(aStore, aRevisionStore, aResolve, aReject);
};
},
stateMachineSendAll: function(aStore, aRevisionStore, aResolve, aReject) {
debug('StateMachineSendAll');
let self = this;
let request = aRevisionStore.openCursor(null, 'prev');
request.onsuccess = function(aEvent) {
if (self._revision.revisionId != aEvent.target.result.value.revisionId) {
self._revision = aEvent.target.result.value;
self._objectId = 0;
aResolve(self.createTask('clear', null, '', null));
return;
}
let request = aStore.openCursor(self._window.IDBKeyRange.lowerBound(self._objectId, true));
request.onsuccess = function(aEvent) {
let cursor = aEvent.target.result;
if (!cursor) {
self._state = STATE_REVISION_CHECK;
self.stateMachine(aStore, aRevisionStore, aResolve, aReject);
return;
}
self._objectId = cursor.key;
aResolve(self.createTask('add', self._objectId, '', cursor.value));
};
};
},
stateMachineRevisionSend: function(aStore, aRevisionStore, aResolve, aReject) {
debug('StateMachineRevisionSend');
if (!this._revisionsList.length) {
this._state = STATE_REVISION_CHECK;
this.stateMachine(aStore, aRevisionStore, aResolve, aReject);
return;
}
this._revision = this._revisionsList.shift();
switch (this._revision.operation) {
case REVISION_REMOVED:
aResolve(this.createTask('remove', this._revision.objectId, '', null));
break;
case REVISION_ADDED: {
let request = aStore.get(this._revision.objectId);
let self = this;
request.onsuccess = function(aEvent) {
if (aEvent.target.result == undefined) {
self.stateMachine(aStore, aRevisionStore, aResolve, aReject);
return;
}
aResolve(self.createTask('add', self._revision.objectId, '',
aEvent.target.result));
}
break;
}
case REVISION_UPDATED: {
let request = aStore.get(this._revision.objectId);
let self = this;
request.onsuccess = function(aEvent) {
if (aEvent.target.result == undefined) {
self.stateMachine(aStore, aRevisionStore, aResolve, aReject);
return;
}
if (aEvent.target.result.revisionId > self._revision.internalRevisionId) {
self.stateMachine(aStore, aRevisionStore, aResolve, aReject);
return;
}
aResolve(self.createTask('update', self._revision.objectId, '',
aEvent.target.result));
}
break;
}
case REVISION_VOID:
// Internal error!
dump('Internal error: Revision "' + REVISION_VOID + '" should not be found!!!\n');
break;
case REVISION_SKIP:
// This revision contains data that has already been sent by another one.
this.stateMachine(aStore, aRevisionStore, aResolve, aReject);
break;
}
},
stateMachineDone: function(aStore, aRevisionStore, aResolve, aReject) {
this.close();
aResolve(this.createTask('done', null, this._revision.revisionId, null));
},
// public interface
get store() {
return this._dataStore.exposedObject;
},
next: function() {
debug('Next');
// If the window has been destroyed we cannot create the Promise object.
if (this._shuttingdown) {
throw Cr.NS_ERROR_FAILURE;
}
let self = this;
return new this._window.Promise(function(aResolve, aReject) {
self._dataStore._db.cursorTxn(
function(aTxn, aStore, aRevisionStore) {
self.stateMachine(aStore, aRevisionStore, aResolve, aReject);
},
function(aEvent) {
aReject(createDOMError(self._window, aEvent));
}
);
});
},
close: function() {
this._dataStore.syncTerminated(this);
},
createTask: function(aOperation, aId, aRevisionId, aData) {
return Cu.cloneInto({ operation: aOperation, id: aId,
revisionId: aRevisionId, data: aData }, this._window);
}
};