RubyGems - middleman-core-cj - Versions diffs - 3.3.4 - Mend

middleman-core-cj 3.3.4

Files changed (1046) hide show

data/lib/middleman-core/templates/mobile/source/tools/wspl/dbworker_test.html ADDED Viewed

@@ -0,0 +1,393 @@
+<!DOCTYPE html>
+<!--
+  Copyright 2009 Google Inc.
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+<head>
+<title>Gears worker tests</title>
+<script type="text/javascript" src="../jsunit/app/jsUnitCore.js"></script>
+<script type="text/javascript" src="jsmock.js"></script>
+<script type="text/javascript" src="global_functions.js"></script>
+<script type="text/javascript" src="gearsutils.js"></script>
+<script type="text/javascript" src="dbworker.js"></script>
+</head>
+<body>
+<script type='text/javascript'>
+var mockControl;
+var db;
+var wp;
+var factory;
+var callbackId = 10;
+var transactionId = 15;
+var name = 'name';
+var userId = 'userId';
+var utils;
+function setUp() {
+  mockControl = new MockControl();
+  // Mock the Gears factory.
+  factory = mockControl.createMock();
+  factory.addMockMethod('create');
+  // Mock Google Gears.
+  google.gears = {};
+  google.gears.factory = {};
+  google.gears.factory.create = factory.create;
+  // Mock the Gears workerpool object.
+  wp = mockControl.createMock({
+    allowCrossOrigin: function(){},
+    sendMessage: function(){}
+  });
+  // Mock the Gears database object.
+  db = mockControl.createMock({
+    execute: function(){},
+    open: function(){},
+    close: function(){},
+    remove: function(){}
+  });
+  // Mock the Gears utility classes
+ utils = mockControl.createMock({
+    openDatabase: function(){},
+  });
+  google.wspl = google.wspl || {};
+  google.wspl.GearsUtils = google.wspl.GearsUtils || {};
+  google.wspl.GearsUtils.openDatabase = utils.openDatabase;
+  google.wspl.GearsUtils.resultSetToObjectArray = function(rs) {
+    return rs;
+  };
+}
+function buildWorker() {
+  wp.expects().sendMessage(TypeOf.isA(Object), 0).andStub(
+      function() {
+    var msg = arguments[0];
+    assertEquals('Wrong message type.',
+        google.wspl.gears.DbWorker.ReplyTypes.STARTED, msg.type);
+  });
+  var worker = new google.wspl.gears.DbWorker(wp);
+  worker.db_ = db;
+  worker.log_ = function() {};
+  return worker;
+}
+function testConstruction() {
+  var worker = buildWorker();
+  mockControl.verify();
+}
+function testHandleExecute_success() {
+  var worker = buildWorker();
+  var stat1 = {sql: 'sql1', params: [1, 2]};
+  var stat2 = {sql: 'sql2', params: [3, 4]};
+  var statements = [stat1, stat2];
+  var type = google.wspl.gears.DbWorker.ReplyTypes.RESULT;
+  db.expects().execute(stat1.sql, stat1.params).andReturn('result1');
+  db.expects().execute(stat2.sql, stat2.params).andReturn('result2');
+  wp.expects().sendMessage(TypeOf.isA(Object), worker.senderId_).andStub(
+      function() {
+    var msg = arguments[0];
+    assertEquals('Wrong message type.', type, msg.type);
+    assertEquals('Wrong results.length', 2, msg.results.length);
+    assertEquals('Wrong results[0].', 'result1', msg.results[0]);
+    assertEquals('Wrong results[1].', 'result2', msg.results[1]);
+    assertEquals('Wrong callbackId.', callbackId, msg.callbackId);
+    assertEquals('Wrong transactionId.', transactionId, msg.transactionId);
+  });
+  worker.handleExecute_(statements, callbackId, transactionId);
+  mockControl.verify();
+}
+function testHandleExecute_failure() {
+  var worker = buildWorker();
+  var stat1 = {sql: 'sql1', params: [1, 2]};
+  var stat2 = {sql: 'sql2', params: [3, 4]};
+  var stat3 = {sql: 'sql3', params: [5, 6]};
+  var statements = [stat1, stat2, stat3];
+  var type1 = google.wspl.gears.DbWorker.ReplyTypes.RESULT;
+  var type2 = google.wspl.gears.DbWorker.ReplyTypes.FAILURE;
+  var error = 'sql error';
+  db.expects().execute(stat1.sql, stat1.params).andReturn('result1');
+  db.expects().execute(stat2.sql, stat2.params).andThrow(error);
+  wp.expects().sendMessage(TypeOf.isA(Object), worker.senderId_).andStub(
+      function() {
+    var msg = arguments[0];
+    assertEquals('Wrong message type.', type2, msg.type);
+    assertEquals('Wrong result.', error, msg.error.message);
+    assertEquals('Wrong callbackId.', callbackId, msg.callbackId);
+    assertEquals('Wrong transactionId.', transactionId, msg.transactionId);
+  });
+  worker.handleExecute_(statements, callbackId, transactionId);
+  mockControl.verify();
+}
+function testHandleBegin() {
+  var worker = buildWorker();
+  // Expecting two transactions to begin.
+  db.expects().execute('BEGIN IMMEDIATE');
+  db.expects().execute('BEGIN IMMEDIATE');
+  worker.handleBegin_(transactionId);
+  worker.handleBegin_(22);
+  assertEquals('Did not save first transaction id', transactionId,
+      worker.transactions_[0]);
+  assertEquals('Did not save second transaction id', 22,
+      worker.transactions_[1]);
+  mockControl.verify();
+}
+function testHandleCommit() {
+  var worker = buildWorker();
+  db.expects().execute('COMMIT');
+  worker.handleCommit_(transactionId);
+  mockControl.verify();
+}
+function testHandleRollback() {
+  var worker = buildWorker();
+  db.expects().execute('ROLLBACK');
+  worker.handleRollback_(transactionId);
+  mockControl.verify();
+}
+function testHandleOpen_success() {
+  var worker = buildWorker();
+  worker.db_ = null;
+  factory.expects().create('beta.database', '1.0').andReturn(db);
+  utils.expects().openDatabase(userId, name, db, worker.log_).andReturn(db);
+  wp.expects().sendMessage(TypeOf.isA(Object), worker.senderId_).andStub(
+      function(msg) {
+    assertEquals('Type not set correctly.',
+        google.wspl.gears.DbWorker.ReplyTypes.OPEN_SUCCESSFUL, msg.type);
+  });
+  worker.handleOpen_(userId, name);
+  assertEquals('Database wrongly set', db, worker.db_);
+  mockControl.verify();
+}
+function testHandleOpen_failure_gearsfactory() {
+  var worker = buildWorker();
+  worker.db_ = null;
+  factory.expects().create('beta.database', '1.0').andThrow('blah!');
+  wp.expects().sendMessage(TypeOf.isA(Object), worker.senderId_).andStub(
+      function(msg) {
+    assertEquals('Type not set correctly.',
+        google.wspl.gears.DbWorker.ReplyTypes.OPEN_FAILED, msg.type);
+  });
+  worker.handleOpen_(userId, name);
+  mockControl.verify();
+}
+function testHandleOpen_failure_dbopen() {
+  var worker = buildWorker();
+  worker.db_ = null;
+  factory.expects().create('beta.database', '1.0').andReturn(null);
+  utils.expects().openDatabase(userId, name, null, worker.log_).andThrow('blah!');
+  wp.expects().sendMessage(TypeOf.isA(Object), worker.senderId_).andStub(
+      function(msg) {
+    assertEquals('Type not set correctly.',
+        google.wspl.gears.DbWorker.ReplyTypes.OPEN_FAILED, msg.type);
+  });
+  worker.handleOpen_(userId, name);
+  mockControl.verify();
+}
+function testPostCommit() {
+  var worker = buildWorker();
+  worker.transactions_ = [4, 5];
+  wp.expects().sendMessage(TypeOf.isA(Object), worker.senderId_).andStub(
+      function() {
+    var msg = arguments[0];
+    assertEquals('Type not set correctly.',
+        google.wspl.gears.DbWorker.ReplyTypes.COMMIT, msg.type);
+    assertEquals('Transaction id not set correctly.',
+        5, msg.transactionId);
+  });
+  wp.expects().sendMessage(TypeOf.isA(Object), worker.senderId_).andStub(
+      function() {
+    var msg = arguments[0];
+    assertEquals('Type not set correctly.',
+        google.wspl.gears.DbWorker.ReplyTypes.COMMIT, msg.type);
+    assertEquals('Transaction id not set correctly.',
+        4, msg.transactionId);
+  });
+  worker.postCommit_();
+  assertEquals('Did not clear the transactions.', 0,
+      worker.transactions_.length);
+  mockControl.verify();
+}
+function testPostRollback() {
+  var worker = buildWorker();
+  worker.transactions_ = [4, 5];
+  wp.expects().sendMessage(TypeOf.isA(Object), worker.senderId_).andStub(
+      function() {
+    var msg = arguments[0];
+    assertEquals('Type not set correctly.',
+        google.wspl.gears.DbWorker.ReplyTypes.ROLLBACK, msg.type);
+    assertEquals('Transaction id not set correctly.',
+        5, msg.transactionId);
+  });
+  wp.expects().sendMessage(TypeOf.isA(Object), worker.senderId_).andStub(
+      function() {
+    var msg = arguments[0];
+    assertEquals('Type not set correctly.',
+        google.wspl.gears.DbWorker.ReplyTypes.ROLLBACK, msg.type);
+    assertEquals('Transaction id not set correctly.',
+        4, msg.transactionId);
+  });
+  worker.postRollback_();
+  assertEquals('Did not clear the transactions.', 0,
+      worker.transactions_.length);
+  mockControl.verify();
+}
+function testOnmessage() {
+  var messageObject = {sender: 123, body: {}};
+  var worker = buildWorker();
+  worker.onMessage_(null, null, messageObject);
+  assertEquals('Wrong sender ID.', 123, worker.senderId_);
+  mockControl.verify();
+}
+function testOnmessage_open() {
+  var messageObject = {sender: 123, body: {
+    type: google.wspl.gears.DbWorker.CommandTypes.OPEN,
+    name: name,
+    userId: userId
+  }};
+  var worker = buildWorker();
+  var handler = mockControl.createMock();
+  handler.addMockMethod('open');
+  worker.handleOpen_ = handler.open;
+  handler.expects().open(userId, name);
+  worker.onMessage_(null, null, messageObject);
+  mockControl.verify();
+}
+function testOnmessage_execute() {
+  var worker = buildWorker();
+  var statements = ['stat1', 'stat2'];
+  var messageObject = {sender: 123, body: {
+    type: google.wspl.gears.DbWorker.CommandTypes.EXECUTE,
+    statements: statements,
+    callbackId: callbackId,
+    transactionId: transactionId
+  }};
+  var called = false;
+  worker.handleExecute_ = function(stat, call, trans) {
+    called = true;
+    assertEquals('Wrong statements.', statements, stat);
+    assertEquals('Wrong callback id.', callbackId, call);
+    assertEquals('Wrong transaction id.', transactionId, trans);
+  };
+  worker.onMessage_(null, null, messageObject);
+  assertTrue('handleExecute_ not called.', called);
+  mockControl.verify();
+}
+function testOnmessage_begin() {
+  var worker = buildWorker();
+  var messageObject = {sender: 123, body: {
+    type: google.wspl.gears.DbWorker.CommandTypes.BEGIN,
+    transactionId: transactionId
+  }};
+  var called = false;
+  worker.handleBegin_ = function(trans) {
+    called = true;
+    assertEquals('Wrong transaction id.', transactionId, trans);
+  };
+  worker.onMessage_(null, null, messageObject);
+  assertTrue('handleBegin_ not called.', called);
+  mockControl.verify();
+}
+function testOnmessage_commit() {
+  var worker = buildWorker();
+  var messageObject = {sender: 123, body: {
+    type: google.wspl.gears.DbWorker.CommandTypes.COMMIT,
+    transactionId: transactionId
+  }};
+  var called = false;
+  worker.handleCommit_ = function(trans) {
+    called = true;
+    assertEquals('Wrong transaction id.', transactionId, trans);
+  };
+  worker.onMessage_(null, null, messageObject);
+  assertTrue('handleCommit_ not called.', called);
+  mockControl.verify();
+}
+function testOnmessage_rollback() {
+  var worker = buildWorker();
+  var messageObject = {sender: 123, body: {
+    type: google.wspl.gears.DbWorker.CommandTypes.ROLLBACK,
+    transactionId: transactionId
+  }};
+  var called = false;
+  worker.handleRollback_ = function(trans) {
+    called = true;
+    assertEquals('Wrong transaction id.', transactionId, trans);
+  };
+  worker.onMessage_(null, null, messageObject);
+  assertTrue('handleRollback_ not called.', called);
+  mockControl.verify();
+}
+</script>
+</body>
+</html>

data/lib/middleman-core/templates/mobile/source/tools/wspl/dbworkerstarter.js ADDED Viewed

@@ -0,0 +1,32 @@
+/*
+  Copyright 2009 Google Inc.
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+/**
+ * @fileoverview Starts the dbworker.
+ *
+ * When constructing the worker for execution, this needs to be the last
+ * file. The worker consists of the following source files combined together.
+ *
+ *   globalfunctions.js
+ *   gearsutils.js
+ *   dbworker.js
+ *   dbworkerstarter.js
+ *
+ * and then loaded into a Gears worker process as implemented in
+ * databasefactory.js
+ */
+google.wspl.gears.DbWorker.start();

data/lib/middleman-core/templates/mobile/source/tools/wspl/dbwrapper_gears.js ADDED Viewed

@@ -0,0 +1,595 @@
+/*
+  Copyright 2009 Google Inc.
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+/**
+ * @fileoverview A Gears implementation of dbwrapperapi Database.
+ *
+ * This implementation locks database access upon invoking the transaction's
+ * populate callback.  Statements are then asynchronously sent to a worker
+ * thread for execution.
+ */
+/**
+ * @see google.wspl.Database#Database
+ * @param {boolean} opt_sync Perform all callbacks synchronously.
+ * @constructor
+ * @extends google.wspl.Database
+ */
+google.wspl.gears.Database = function(opt_sync) {
+  google.wspl.Database.call(this);
+  /**
+   * Begin transactions synchronously.
+   * @type {boolean}
+   * @private
+   */
+  this.synchronous_ = !!opt_sync;
+};
+google.inherits(google.wspl.gears.Database, google.wspl.Database);
+/**
+ * The time to wait for the dbworker to reply with STARTED.
+ * @type {number}
+ */
+google.wspl.gears.Database.TIMEOUT = 60000;
+/**
+ * Whether the gears worker failed to reply with STARTED before TIMEOUT.
+ * @type {boolean}
+ * @private
+ */
+google.wspl.gears.Database.prototype.workerTimeout_ = false;
+/**
+ * Flag set when the worker is ready with an open database connection.
+ * @type {boolean}
+ * @private
+ */
+google.wspl.gears.Database.prototype.workerReady_ = false;
+/**
+ * Flag set when this database should use the worker to process transactions.
+ * @type {boolean}
+ * @private
+ */
+google.wspl.gears.Database.prototype.useWorker_ = false;
+/**
+ * The user for this database.
+ * @type {string}
+ * @private
+ */
+google.wspl.gears.Database.prototype.userId_;
+/**
+ * The name for this database.
+ * @type {string}
+ * @private
+ */
+google.wspl.gears.Database.prototype.name_;
+/**
+ * A map of open transactions and their callbacks.
+ * @type {Object}
+ * @private
+ */
+google.wspl.gears.Database.prototype.transactions_ = {};
+/**
+ * An array of transaction ids that should be executed in order as the lock
+ * becomes available.
+ * @type {Array.<number>}
+ * @private
+ */
+google.wspl.gears.Database.prototype.queuedTransactions_ = [];
+/**
+ * The transaction lock for this database.
+ * @type {boolean}
+ * @private
+ */
+google.wspl.gears.Database.prototype.locked_ = false;
+/**
+ * The number of transactions to be used as an index.
+ * @type {number}
+ * @private
+ */
+google.wspl.gears.Database.prototype.transCount_ = 1;
+/**
+ * The id of the transaction being executed.
+ * @type {number}
+ * @private
+ */
+google.wspl.gears.Database.prototype.currentTransactionId_;
+/**
+ * The Gears worker pool.
+ * @type {GearsWorkerPool}
+ * @private
+ */
+google.wspl.gears.Database.prototype.wp_;
+/**
+ * The worker ID.
+ * @type {number}
+ * @private
+ */
+google.wspl.gears.Database.prototype.workerId_;
+/**
+ * The Gears database object.
+ * @type {GearsDatabase}
+ * @private
+ */
+google.wspl.gears.Database.prototype.db_;
+/**
+ * Opens a new Gears database.  This operation can only be performed once.
+ * @param {string} userId The user for this database.
+ * @param {string} name The name for this database.
+ * @param {GearsDatabase} gearsDb The gears database.
+ */
+google.wspl.gears.Database.prototype.openDatabase = function(userId, name,
+    gearsDb) {
+  if (!this.db_) {
+    this.db_ = gearsDb;
+    this.userId_ = userId;
+    this.name_ = name;
+    google.wspl.GearsUtils.openDatabase(userId, name, this.db_,
+        google.logger);
+  } else {
+   google.logger('openDatabase already invoked.');
+  }
+};
+/**
+ * Starts a worker to handle the database interactions.  The worker will be
+ * asynchronously started after the specified delay and will not be used until
+ * the completion of any pending transaction.
+ * @param {GearsWorkerPool} wp The Gears worker pool.
+ * @param {string} workerUrl The URL to find the gears database worker.
+ * @return {number} The worker ID.
+ */
+google.wspl.gears.Database.prototype.startWorker = function(wp, workerUrl) {
+  this.wp_ = wp;
+  google.logger('Starting dbworker thread.');
+  this.workerId_ = wp.createWorkerFromUrl(workerUrl);
+  this.timeoutId_ = window.setTimeout(google.bind(this.handleTimeout_, this),
+      google.wspl.gears.Database.TIMEOUT);
+  return this.workerId_;
+};
+/**
+ * @see google.wspl.Transaction#createTransaction
+ * @inheritDoc
+ */
+google.wspl.gears.Database.prototype.createTransaction = function(populate,
+    opt_callback) {
+  var transactionCallback = opt_callback || {
+    onSuccess : function() {},
+    onFailure : function() {}
+  };
+  var id = this.transCount_++;
+  var transaction = new google.wspl.gears.Transaction(id, this);
+  this.saveTransaction_(transaction, transactionCallback, populate);
+  this.queuedTransactions_.push(transaction.id_);
+  this.nextTransaction_();
+};
+/**
+ * Saves the transaction and transaction callback to be accessed later when a
+ * commit or rollback is performed.
+ *
+ * @param {google.wspl.gears.Transaction} transaction The transaction that the
+ *     callback belongs to.
+ * @param {Object} callback A transaction callback with onSuccess and onFailure
+ * @private
+ */
+google.wspl.gears.Database.prototype.saveTransaction_ = function(
+    transaction, callback, populate) {
+  this.transactions_[transaction.id_] = {
+    transaction: transaction,
+    callback: callback,
+    populate: populate
+  };
+};
+/**
+ * Handles incomming messages.
+ * @param {string} a Deprecated.
+ * @param {number} b Deprecated.
+ * @param {Object} messageObject The message object.
+ * @private
+ */
+google.wspl.gears.Database.prototype.onMessage_ =
+    function(a, b, messageObject) {
+  var message = messageObject.body;
+  try {
+    switch(message['type']) {
+      case google.wspl.gears.DbWorker.ReplyTypes.RESULT:
+        this.handleResult_(message['results'], message['callbackId'],
+            message['transactionId']);
+        break;
+      case google.wspl.gears.DbWorker.ReplyTypes.FAILURE:
+        this.handleFailure_(message['error'], message['callbackId'],
+            message['transactionId']);
+        break;
+      case google.wspl.gears.DbWorker.ReplyTypes.COMMIT:
+        this.handleCommit_(message['transactionId']);
+        break;
+      case google.wspl.gears.DbWorker.ReplyTypes.ROLLBACK:
+        this.handleRollback_(message['transactionId']);
+        break;
+      case google.wspl.gears.DbWorker.ReplyTypes.STARTED:
+        this.handleStarted_();
+        break;
+      case google.wspl.gears.DbWorker.ReplyTypes.OPEN_SUCCESSFUL:
+        this.handleOpenSuccessful_();
+        break;
+      case google.wspl.gears.DbWorker.ReplyTypes.OPEN_FAILED:
+        this.handleOpenFailed_(message['error']);
+        break;
+      case google.wspl.gears.DbWorker.ReplyTypes.LOG:
+        google.logger(message['msg']);
+        break;
+    }
+  } catch (ex) {
+    google.logger('Gears database failed: ' + ex.message, ex);
+  }
+};
+/**
+ * Opens a new Gears database.
+ *
+ * @param {string} userId The user to which the database belongs.
+ * @param {string} name The name of the database.
+ */
+google.wspl.gears.Database.prototype.doOpen = function(userId, name) {
+  this.sendMessageToWorker_({
+    'type': google.wspl.gears.DbWorker.CommandTypes.OPEN,
+    'name': name,
+    'userId': userId
+  });
+};
+/**
+ * Begins a new transaction on the Gears database.
+ *
+ * @param {number} transactionId The id of the transaction being committed.
+ */
+google.wspl.gears.Database.prototype.doBegin = function(transactionId) {
+  if (!this.useWorker_) {
+    this.db_.execute('BEGIN IMMEDIATE');
+    return;
+  }
+  this.sendMessageToWorker_({
+    'type': google.wspl.gears.DbWorker.CommandTypes.BEGIN,
+    'transactionId': transactionId
+  });
+};
+/**
+ * Commits the current transaction on the Gears database.  The transactionId
+ * is used to invoke the callback associated with the transaction.
+ *
+ * @param {number} transactionId The id of the transaction being committed.
+ */
+google.wspl.gears.Database.prototype.doCommit = function(transactionId) {
+  if (!this.useWorker_) {
+    this.db_.execute('COMMIT');
+    this.postCommit_();
+    return;
+  }
+  this.sendMessageToWorker_({
+    'type': google.wspl.gears.DbWorker.CommandTypes.COMMIT,
+    'transactionId': transactionId
+  });
+};
+/**
+ * Rolls the current transaction back on the Gears database.  The transactionId
+ * is used to invoke the callback associated with the transaction.
+ *
+ * @param {number} transactionId The id of the transaction being rolled back.
+ */
+google.wspl.gears.Database.prototype.doRollback = function(transactionId) {
+  if (!this.useWorker_) {
+    this.db_.execute('ROLLBACK');
+    this.postRollback_();
+    return;
+  }
+  this.sendMessageToWorker_({
+    'type': google.wspl.gears.DbWorker.CommandTypes.ROLLBACK,
+    'transactionId': transactionId
+  });
+};
+/**
+ * Executes an array of statements on the Gears database.  The transactionId and
+ * callbackId are used to identify the callback that should be invoked when
+ * handleResult or handleFailure is called.
+ *
+ * @param {Array.<google.wspl.Statement>} statements The group of statements to
+ *     execute
+ * @param {number} callbackId The callback to invoke for each statement
+ * @param {number} transactionId The transaction that the statements belong to
+ */
+google.wspl.gears.Database.prototype.doExecute = function(statements,
+                                                          callbackId,
+                                                          transactionId) {
+  if (!this.useWorker_) {
+    this.doExecuteSynchronously_(statements, callbackId, transactionId);
+    return;
+  }
+  var newStatements = [];
+  for (var i = 0; i < statements.length; i++) {
+    newStatements[i] = {
+      'sql': statements[i].sql,
+      'params': statements[i].params
+    };
+  }
+  this.sendMessageToWorker_({
+    'type': google.wspl.gears.DbWorker.CommandTypes.EXECUTE,
+    'statements': newStatements,
+    'callbackId': callbackId,
+    'transactionId': transactionId
+  });
+};
+/**
+ * Executes an array of statements on the synchronous Gears databse.
+ * @param {Array.<google.wspl.Statement>} statements
+ * @param {number} callbackId
+ * @param {number} transactionId
+ * @private
+ */
+google.wspl.gears.Database.prototype.doExecuteSynchronously_ =
+    function(statements, callbackId, transactionId) {
+  var db = this;
+  var results = [];
+  for (var i = 0; i < statements.length; i++) {
+    try {
+      var resultset = this.db_.execute(statements[i].sql, statements[i].params);
+      var result = google.wspl.GearsUtils.resultSetToObjectArray(resultset);
+      results.push(result);
+    } catch (e) {
+      var error = e;
+      function failureCallback() {
+        db.handleFailure_(error, callbackId, transactionId);
+      };
+      this.setTimeout_(failureCallback, 0);
+      return;
+    }
+  }
+  function resultCallback() {
+    db.handleResult_(results, callbackId, transactionId);
+  };
+  this.setTimeout_(resultCallback, 0);
+};
+/**
+ * Handles a RESULT message from the worker thread.
+ *
+ * @param {!Array.<!Array.<Object>>} results A Gears result set.
+ * @param {number} callbackId The callback to invoke.
+ * @param {number} transactionId The transaction that the statement is executing
+ *     in.
+ * @private
+ */
+google.wspl.gears.Database.prototype.handleResult_ = function(results,
+    callbackId, transactionId) {
+  var transInfo = this.transactions_[transactionId];
+  if (transInfo) {
+    for (var i = 0, l = results.length; i < l; i++) {
+      var resultSet = new google.wspl.gears.ResultSet(results[i]);
+      transInfo.transaction.success(resultSet, callbackId);
+    }
+  }
+};
+/**
+ * Handles a FAILURE message from the worker thread.
+ *
+ * @param {Error} error An error produced by the Gears database
+ * @param {number} callbackId The callback to invoke
+ * @param {number} transactionId The transaction that the statement is executing
+ *     in
+ * @private
+ */
+google.wspl.gears.Database.prototype.handleFailure_ = function(error,
+    callbackId, transactionId) {
+  var transInfo = this.transactions_[transactionId];
+  if (transInfo) {
+    transInfo.error = error;
+    transInfo.transaction.failure(error, callbackId);
+  }
+};
+/**
+ * Handles a COMMIT message from the worker thread.
+ *
+ * @param {number} id The transaction id.
+ * @private
+ */
+google.wspl.gears.Database.prototype.handleCommit_ = function(id) {
+  var transaction = this.removeTransaction_(id);
+  if (transaction) {
+    transaction.callback.onSuccess();
+  }
+  this.nextTransaction_();
+};
+/**
+ * Handles the completion of a commit from the synchronous database.
+ * @private
+ */
+google.wspl.gears.Database.prototype.postCommit_ = function() {
+  this.handleCommit_(this.currentTransactionId_);
+};
+/**
+ * Handles a ROLLBACK message from the worker thread.
+ *
+ * @param {number} id The transaction id
+ * @private
+ */
+google.wspl.gears.Database.prototype.handleRollback_ = function(id) {
+  var transaction = this.removeTransaction_(id);
+  if (transaction) {
+    transaction.callback.onFailure(transaction.error);
+  }
+  this.nextTransaction_();
+};
+/**
+ * Handles the completion of a rollback from the synchronous database.
+ * @private
+ */
+google.wspl.gears.Database.prototype.postRollback_ = function() {
+  this.handleRollback_(this.currentTransactionId_);
+};
+/**
+ * Handles a STARTED message from the worker thread.
+ *
+ * @private
+ */
+google.wspl.gears.Database.prototype.handleStarted_ = function() {
+  if (!this.workerTimeout_) {
+    google.logger('Dbworker started.');
+    window.clearTimeout(this.timeoutId_);
+    this.timeoutId_ = 0;
+    this.doOpen(this.userId_, this.name_);
+  }
+};
+/**
+ * Handles a timeout of waiting for a STARTED message from the worker thread.
+ *
+ * @private
+ */
+google.wspl.gears.Database.prototype.handleTimeout_ = function() {
+  this.workerTimeout_ = true;
+  google.logger('Timed out while waiting for the dbworker to start.');
+};
+/**
+ * Handles a OPEN_SUCCESSFUL message from the worker thread.
+ *
+ * @private
+ */
+google.wspl.gears.Database.prototype.handleOpenSuccessful_ = function() {
+  this.workerReady_ = true;
+};
+/**
+ * Handles a OPEN_FAILED message from the worker thread.
+ * @param {string} error
+ * @private
+ */
+google.wspl.gears.Database.prototype.handleOpenFailed_ = function(error) {
+  google.logger('Worker failed to open Gears database.');
+};
+/**
+ * Executes the next transaction if there is one queued.
+ *
+ * @private
+ */
+google.wspl.gears.Database.prototype.nextTransaction_ = function() {
+  if (this.queuedTransactions_.length && !this.locked_) {
+    this.locked_ = true;
+    if (this.workerReady_ && !this.useWorker_) {
+      this.useWorker_ = true;
+      google.logger('Switching to asynchronous database interface.');
+    }
+    var id = this.queuedTransactions_.shift();
+    this.currentTransactionId_ = id;
+    var transactionData = this.transactions_[id];
+    var db = this;
+    function populate() {
+      transactionData.populate(transactionData.transaction);
+      // If populate did not execute statements on the database, invoke the
+      // success callback and process the next transaction.
+      if (!transactionData.transaction.isExecuting()) {
+        db.handleCommit_(id);
+      }
+    };
+    this.setTimeout_(populate, 0);
+  }
+};
+/**
+ * Cleans up the transaction and transaction callback for the id specified.
+ *
+ * @param {number} id The transaction id.
+ * @return {google.wspl.Transaction} The transaction and callback in an object.
+ * @private
+ */
+google.wspl.gears.Database.prototype.removeTransaction_ = function(id) {
+  this.locked_ = false;
+  var transaction = this.transactions_[id];
+  if (transaction) {
+    delete this.transactions_[id];
+  }
+  return transaction;
+};
+/**
+ * Execute a function using window's setTimeout.
+ * @param {Function} func The function to execute.
+ * @param {number} time The time delay before invocation.
+ * @private
+ */
+google.wspl.gears.Database.prototype.setTimeout_ = function(func, time) {
+  if (this.synchronous_) {
+    func();
+  } else {
+    window.setTimeout(func, time);
+  }
+};
+/**
+ * Sends a message to the database worker thread.
+ * @param {Object} msg The message object to send.
+ * @private
+ */
+google.wspl.gears.Database.prototype.sendMessageToWorker_ = function(msg) {
+  this.wp_.sendMessage(msg, this.workerId_);
+};