Rename Blink constants generated from IDL files.

third_party/WebKit/Source/modules/webdatabase/SQLTransactionBackend.cpp

 /*
  * Copyright (C) 2007, 2008, 2013 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 555 matching lines @@
     m_sqliteTransaction = wrapUnique(new SQLiteTransaction(m_database->sqliteDatabase(), m_readOnly));
 
     m_database->resetDeletes();
     m_database->disableAuthorizer();
     m_sqliteTransaction->begin();
     m_database->enableAuthorizer();
 
     // Spec 4.3.2.1+2: Open a transaction to the database, jumping to the error callback if that fails
     if (!m_sqliteTransaction->inProgress()) {
         ASSERT(!m_database->sqliteDatabase().transactionInProgress());
-        m_database->reportStartTransactionResult(2, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
-        m_transactionError = SQLErrorData::create(SQLError::DATABASE_ERR, "unable to begin transaction",
+        m_database->reportStartTransactionResult(2, SQLError::kDatabaseErr, m_database->sqliteDatabase().lastError());
+        m_transactionError = SQLErrorData::create(SQLError::kDatabaseErr, "unable to begin transaction",
             m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
         m_sqliteTransaction.reset();
         return nextStateForTransactionError();
     }
 
     // Note: We intentionally retrieve the actual version even with an empty expected version.
     // In multi-process browsers, we take this opportinutiy to update the cached value for
     // the actual version. In single-process browsers, this is just a map lookup.
     String actualVersion;
     if (!m_database->getActualVersionForTransaction(actualVersion)) {
-        m_database->reportStartTransactionResult(3, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
-        m_transactionError = SQLErrorData::create(SQLError::DATABASE_ERR, "unable to read version",
+        m_database->reportStartTransactionResult(3, SQLError::kDatabaseErr, m_database->sqliteDatabase().lastError());
+        m_transactionError = SQLErrorData::create(SQLError::kDatabaseErr, "unable to read version",
             m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
         m_database->disableAuthorizer();
         m_sqliteTransaction.reset();
         m_database->enableAuthorizer();
         return nextStateForTransactionError();
     }
     m_hasVersionMismatch = !m_database->expectedVersion().isEmpty() && (m_database->expectedVersion() != actualVersion);
 
     // Spec 4.3.2.3: Perform preflight steps, jumping to the error callback if they fail
     if (m_wrapper && !m_wrapper->performPreflight(this)) {
         m_database->disableAuthorizer();
         m_sqliteTransaction.reset();
         m_database->enableAuthorizer();
         if (m_wrapper->sqlError()) {
             m_transactionError = SQLErrorData::create(*m_wrapper->sqlError());
         } else {
-            m_database->reportStartTransactionResult(4, SQLError::UNKNOWN_ERR, 0);
-            m_transactionError = SQLErrorData::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction preflight");
+            m_database->reportStartTransactionResult(4, SQLError::kUnknownErr, 0);
+            m_transactionError = SQLErrorData::create(SQLError::kUnknownErr, "unknown error occurred during transaction preflight");
         }
         return nextStateForTransactionError();
     }
 
     // Spec 4.3.2.4: Invoke the transaction callback with the new SQLTransaction object
     if (m_hasCallback)
         return SQLTransactionState::DeliverTransactionCallback;
 
     // If we have no callback to make, skip pass to the state after:
     return SQLTransactionState::RunStatements;
@@ skipping 81 matching lines @@
 SQLTransactionState SQLTransactionBackend::nextStateForCurrentStatementError()
 {
     // Spec 4.3.2.6.6: error - Call the statement's error callback, but if there was no error callback,
     // or the transaction was rolled back, jump to the transaction error callback
     if (m_currentStatementBackend->hasStatementErrorCallback() && !m_sqliteTransaction->wasRolledBackBySqlite())
         return SQLTransactionState::DeliverStatementCallback;
 
     if (m_currentStatementBackend->sqlError()) {
         m_transactionError = SQLErrorData::create(*m_currentStatementBackend->sqlError());
     } else {
-        m_database->reportCommitTransactionResult(1, SQLError::DATABASE_ERR, 0);
-        m_transactionError = SQLErrorData::create(SQLError::DATABASE_ERR, "the statement failed to execute");
+        m_database->reportCommitTransactionResult(1, SQLError::kDatabaseErr, 0);
+        m_transactionError = SQLErrorData::create(SQLError::kDatabaseErr, "the statement failed to execute");
     }
     return nextStateForTransactionError();
 }
 
 SQLTransactionState SQLTransactionBackend::postflightAndCommit()
 {
     ASSERT(m_lockAcquired);
 
     // Spec 4.3.2.7: Perform postflight steps, jumping to the error callback if they fail.
     if (m_wrapper && !m_wrapper->performPostflight(this)) {
         if (m_wrapper->sqlError()) {
             m_transactionError = SQLErrorData::create(*m_wrapper->sqlError());
         } else {
-            m_database->reportCommitTransactionResult(3, SQLError::UNKNOWN_ERR, 0);
-            m_transactionError = SQLErrorData::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction postflight");
+            m_database->reportCommitTransactionResult(3, SQLError::kUnknownErr, 0);
+            m_transactionError = SQLErrorData::create(SQLError::kUnknownErr, "unknown error occurred during transaction postflight");
         }
         return nextStateForTransactionError();
     }
 
     // Spec 4.3.2.7: Commit the transaction, jumping to the error callback if that fails.
     ASSERT(m_sqliteTransaction);
 
     m_database->disableAuthorizer();
     m_sqliteTransaction->commit();
     m_database->enableAuthorizer();
 
     // If the commit failed, the transaction will still be marked as "in progress"
     if (m_sqliteTransaction->inProgress()) {
         if (m_wrapper)
             m_wrapper->handleCommitFailedAfterPostflight(this);
-        m_database->reportCommitTransactionResult(4, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
-        m_transactionError = SQLErrorData::create(SQLError::DATABASE_ERR, "unable to commit transaction",
+        m_database->reportCommitTransactionResult(4, SQLError::kDatabaseErr, m_database->sqliteDatabase().lastError());
+        m_transactionError = SQLErrorData::create(SQLError::kDatabaseErr, "unable to commit transaction",
             m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
         return nextStateForTransactionError();
     }
 
     m_database->reportCommitTransactionResult(0, -1, 0); // OK
 
     // Vacuum the database if anything was deleted.
     if (m_database->hadDeletes())
         m_database->incrementalVacuumIfNeeded();
 
@@ skipping 71 matching lines @@
 }
 
 SQLTransactionState SQLTransactionBackend::sendToFrontendState()
 {
     ASSERT(m_nextState != SQLTransactionState::Idle);
     m_frontend->requestTransitToState(m_nextState);
     return SQLTransactionState::Idle;
 }
 
 } // namespace blink