Rename es => exceptionState in other than bindings/

Source/modules/webdatabase/DatabaseSync.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 56 matching lines @@
 DatabaseSync::~DatabaseSync()
 {
     ASSERT(m_executionContext->isContextThread());
 }
 
 PassRefPtr<DatabaseBackendSync> DatabaseSync::backend()
 {
     return this;
 }
 
-void DatabaseSync::changeVersion(const String& oldVersion, const String& newVersion, PassRefPtr<SQLTransactionSyncCallback> changeVersionCallback, ExceptionState& es)
+void DatabaseSync::changeVersion(const String& oldVersion, const String& newVersion, PassRefPtr<SQLTransactionSyncCallback> changeVersionCallback, ExceptionState& exceptionState)
 {
     ASSERT(m_executionContext->isContextThread());
 
     if (sqliteDatabase().transactionInProgress()) {
         reportChangeVersionResult(1, SQLError::DATABASE_ERR, 0);
         setLastErrorMessage("unable to changeVersion from within a transaction");
-        es.throwUninformativeAndGenericDOMException(SQLDatabaseError);
+        exceptionState.throwUninformativeAndGenericDOMException(SQLDatabaseError);
         return;
     }
 
     RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, changeVersionCallback, false);
-    transaction->begin(es);
-    if (es.hadException()) {
+    transaction->begin(exceptionState);
+    if (exceptionState.hadException()) {
         ASSERT(!lastErrorMessage().isEmpty());
         return;
     }
 
     String actualVersion;
     if (!getVersionFromDatabase(actualVersion)) {
         reportChangeVersionResult(2, SQLError::UNKNOWN_ERR, sqliteDatabase().lastError());
         setLastErrorMessage("unable to read the current version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
-        es.throwDOMException(UnknownError, SQLError::unknownErrorMessage);
+        exceptionState.throwDOMException(UnknownError, SQLError::unknownErrorMessage);
         return;
     }
 
     if (actualVersion != oldVersion) {
         reportChangeVersionResult(3, SQLError::VERSION_ERR, 0);
         setLastErrorMessage("current version of the database and `oldVersion` argument do not match");
-        es.throwDOMException(VersionError, SQLError::versionErrorMessage);
+        exceptionState.throwDOMException(VersionError, SQLError::versionErrorMessage);
         return;
     }
 
 
-    transaction->execute(es);
-    if (es.hadException()) {
+    transaction->execute(exceptionState);
+    if (exceptionState.hadException()) {
         ASSERT(!lastErrorMessage().isEmpty());
         return;
     }
 
     if (!setVersionInDatabase(newVersion)) {
         reportChangeVersionResult(4, SQLError::UNKNOWN_ERR, sqliteDatabase().lastError());
         setLastErrorMessage("unable to set the new version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
-        es.throwDOMException(UnknownError, SQLError::unknownErrorMessage);
+        exceptionState.throwDOMException(UnknownError, SQLError::unknownErrorMessage);
         return;
     }
 
-    transaction->commit(es);
-    if (es.hadException()) {
+    transaction->commit(exceptionState);
+    if (exceptionState.hadException()) {
         ASSERT(!lastErrorMessage().isEmpty());
         setCachedVersion(oldVersion);
         return;
     }
 
     reportChangeVersionResult(0, -1, 0); // OK
 
     setExpectedVersion(newVersion);
     setLastErrorMessage("");
 }
 
-void DatabaseSync::transaction(PassRefPtr<SQLTransactionSyncCallback> callback, ExceptionState& es)
+void DatabaseSync::transaction(PassRefPtr<SQLTransactionSyncCallback> callback, ExceptionState& exceptionState)
 {
-    runTransaction(callback, false, es);
+    runTransaction(callback, false, exceptionState);
 }
 
-void DatabaseSync::readTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, ExceptionState& es)
+void DatabaseSync::readTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, ExceptionState& exceptionState)
 {
-    runTransaction(callback, true, es);
+    runTransaction(callback, true, exceptionState);
 }
 
 void DatabaseSync::rollbackTransaction(PassRefPtr<SQLTransactionSync> transaction)
 {
     ASSERT(!lastErrorMessage().isEmpty());
     transaction->rollback();
     setLastErrorMessage("");
     return;
 }
 
-void DatabaseSync::runTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, bool readOnly, ExceptionState& es)
+void DatabaseSync::runTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, bool readOnly, ExceptionState& exceptionState)
 {
     ASSERT(m_executionContext->isContextThread());
 
     if (sqliteDatabase().transactionInProgress()) {
         setLastErrorMessage("unable to start a transaction from within a transaction");
-        es.throwUninformativeAndGenericDOMException(SQLDatabaseError);
+        exceptionState.throwUninformativeAndGenericDOMException(SQLDatabaseError);
         return;
     }
 
     RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, callback, readOnly);
-    transaction->begin(es);
-    if (es.hadException()) {
+    transaction->begin(exceptionState);
+    if (exceptionState.hadException()) {
         rollbackTransaction(transaction);
         return;
     }
 
-    transaction->execute(es);
-    if (es.hadException()) {
+    transaction->execute(exceptionState);
+    if (exceptionState.hadException()) {
         rollbackTransaction(transaction);
         return;
     }
 
-    transaction->commit(es);
-    if (es.hadException()) {
+    transaction->commit(exceptionState);
+    if (exceptionState.hadException()) {
         rollbackTransaction(transaction);
         return;
     }
 
     setLastErrorMessage("");
 }
 
 void DatabaseSync::markAsDeletedAndClose()
 {
     // FIXME: need to do something similar to closeImmediately(), but in a sync way
@@ skipping 25 matching lines @@
     ASSERT(m_executionContext->isContextThread());
 
     if (!opened())
         return;
 
     logErrorMessage("forcibly closing database");
     closeDatabase();
 }
 
 } // namespace WebCore