reflow comments in modules/webdatabase

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

 /*
  * Copyright (C) 2007, 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 24 matching lines @@
 #include "modules/webdatabase/sqlite/SQLiteDatabase.h"
 #include "modules/webdatabase/sqlite/SQLiteStatement.h"
 #include "wtf/text/CString.h"
 
 // The Life-Cycle of a SQLStatement i.e. Who's keeping the SQLStatement alive?
 // ==========================================================================
 // The RefPtr chain goes something like this:
 //
 //     At birth (in SQLTransactionBackend::executeSQL()):
 //     =================================================
-//     SQLTransactionBackend           // HeapDeque<Member<SQLStatementBackend>> m_statementQueue points to ...
-//     --> SQLStatementBackend         // Member<SQLStatement> m_frontend points to ...
-//         --> SQLStatement
+//     SQLTransactionBackend
+//         // HeapDeque<Member<SQLStatementBackend>> m_statementQueue
+//         // points to ...
+//     --> SQLStatementBackend
+//         // Member<SQLStatement> m_frontend points to ...
+//     --> SQLStatement
 //
-//     After grabbing the statement for execution (in SQLTransactionBackend::getNextStatement()):
-//     =========================================================================================
-//     SQLTransactionBackend           // Member<SQLStatementBackend> m_currentStatementBackend points to ...
-//     --> SQLStatementBackend         // Member<SQLStatement> m_frontend points to ...
-//         --> SQLStatement
+//     After grabbing the statement for execution (in
+//     SQLTransactionBackend::getNextStatement()):
+//     ======================================================================
+//     SQLTransactionBackend
+//         // Member<SQLStatementBackend> m_currentStatementBackend
+//         // points to ...
+//     --> SQLStatementBackend
+//         // Member<SQLStatement> m_frontend points to ...
+//     --> SQLStatement
 //
-//     Then we execute the statement in SQLTransactionBackend::runCurrentStatementAndGetNextState().
-//     And we callback to the script in SQLTransaction::deliverStatementCallback() if
-//     necessary.
-//     - Inside SQLTransaction::deliverStatementCallback(), we operate on a raw SQLStatement*.
-//       This pointer is valid because it is owned by SQLTransactionBackend's
+//     Then we execute the statement in
+//     SQLTransactionBackend::runCurrentStatementAndGetNextState().
+//     And we callback to the script in
+//     SQLTransaction::deliverStatementCallback() if necessary.
+//     - Inside SQLTransaction::deliverStatementCallback(), we operate on a raw
+//       SQLStatement*.  This pointer is valid because it is owned by
+//       SQLTransactionBackend's
 //       SQLTransactionBackend::m_currentStatementBackend.
 //
-//     After we're done executing the statement (in SQLTransactionBackend::getNextStatement()):
-//     =======================================================================================
+//     After we're done executing the statement (in
+//     SQLTransactionBackend::getNextStatement()):
+//     ======================================================================
 //     When we're done executing, we'll grab the next statement. But before we
-//     do that, getNextStatement() nullify SQLTransactionBackend::m_currentStatementBackend.
-//     This will trigger the deletion of the SQLStatementBackend and SQLStatement.
+//     do that, getNextStatement() nullify
+//     SQLTransactionBackend::m_currentStatementBackend.
+//     This will trigger the deletion of the SQLStatementBackend and
+//     SQLStatement.
 //
-//     Note: unlike with SQLTransaction, there is no JS representation of SQLStatement.
-//     Hence, there is no GC dependency at play here.
+//     Note: unlike with SQLTransaction, there is no JS representation of
+//     SQLStatement.  Hence, there is no GC dependency at play here.
 
 namespace blink {
 
 SQLStatementBackend* SQLStatementBackend::create(
     SQLStatement* frontend,
     const String& statement,
     const Vector<SQLValue>& arguments,
     int permissions) {
   return new SQLStatementBackend(frontend, statement, arguments, permissions);
 }
@@ skipping 27 matching lines @@
   return m_error.get();
 }
 
 SQLResultSet* SQLStatementBackend::sqlResultSet() const {
   return m_resultSet->isValid() ? m_resultSet.get() : 0;
 }
 
 bool SQLStatementBackend::execute(Database* db) {
   ASSERT(!m_resultSet->isValid());
 
-  // If we're re-running this statement after a quota violation, we need to clear that error now
+  // If we're re-running this statement after a quota violation, we need to
+  // clear that error now
   clearFailureDueToQuota();
 
-  // This transaction might have been marked bad while it was being set up on the main thread,
-  // so if there is still an error, return false.
+  // This transaction might have been marked bad while it was being set up on
+  // the main thread, so if there is still an error, return false.
   if (m_error)
     return false;
 
   db->setAuthorizerPermissions(m_permissions);
 
   SQLiteDatabase* database = &db->sqliteDatabase();
 
   SQLiteStatement statement(*database, m_statement);
   int result = statement.prepare();
 
   if (result != SQLResultOk) {
     STORAGE_DVLOG(1) << "Unable to verify correctness of statement "
                      << m_statement << " - error " << result << " ("
                      << database->lastErrorMsg() << ")";
     if (result == SQLResultInterrupt)
       m_error = SQLErrorData::create(SQLError::kDatabaseErr,
                                      "could not prepare statement", result,
                                      "interrupted");
     else
       m_error = SQLErrorData::create(SQLError::kSyntaxErr,
                                      "could not prepare statement", result,
                                      database->lastErrorMsg());
     db->reportExecuteStatementResult(1, m_error->code(), result);
     return false;
   }
 
-  // FIXME: If the statement uses the ?### syntax supported by sqlite, the bind parameter count is very likely off from the number of question marks.
-  // If this is the case, they might be trying to do something fishy or malicious
+  // FIXME: If the statement uses the ?### syntax supported by sqlite, the bind
+  // parameter count is very likely off from the number of question marks.  If
+  // this is the case, they might be trying to do something fishy or malicious
   if (statement.bindParameterCount() != m_arguments.size()) {
     STORAGE_DVLOG(1)
         << "Bind parameter count doesn't match number of question marks";
     m_error = SQLErrorData::create(
         SQLError::kSyntaxErr,
         "number of '?'s in statement string does not match argument count");
     db->reportExecuteStatementResult(2, m_error->code(), 0);
     return false;
   }
 
@@ skipping 36 matching lines @@
       m_error = SQLErrorData::create(SQLError::kDatabaseErr,
                                      "could not iterate results", result,
                                      database->lastErrorMsg());
       return false;
     }
   } else if (result == SQLResultDone) {
     // Didn't find anything, or was an insert
     if (db->lastActionWasInsert())
       m_resultSet->setInsertId(database->lastInsertRowID());
   } else if (result == SQLResultFull) {
-    // Return the Quota error - the delegate will be asked for more space and this statement might be re-run
+    // Return the Quota error - the delegate will be asked for more space and
+    // this statement might be re-run.
     setFailureDueToQuota(db);
     return false;
   } else if (result == SQLResultConstraint) {
     db->reportExecuteStatementResult(6, SQLError::kConstraintErr, result);
     m_error = SQLErrorData::create(
         SQLError::kConstraintErr,
         "could not execute statement due to a constaint failure", result,
         database->lastErrorMsg());
     return false;
   } else {
     db->reportExecuteStatementResult(5, SQLError::kDatabaseErr, result);
     m_error = SQLErrorData::create(SQLError::kDatabaseErr,
                                    "could not execute statement", result,
                                    database->lastErrorMsg());
     return false;
   }
 
-  // FIXME: If the spec allows triggers, and we want to be "accurate" in a different way, we'd use
-  // sqlite3_total_changes() here instead of sqlite3_changed, because that includes rows modified from within a trigger
-  // For now, this seems sufficient
+  // FIXME: If the spec allows triggers, and we want to be "accurate" in a
+  // different way, we'd use sqlite3_total_changes() here instead of
+  // sqlite3_changed, because that includes rows modified from within a trigger.
+  // For now, this seems sufficient.
   m_resultSet->setRowsAffected(database->lastChanges());
 
   db->reportExecuteStatementResult(0, -1, 0);  // OK
   return true;
 }
 
 void SQLStatementBackend::setVersionMismatchedError(Database* database) {
   ASSERT(!m_error && !m_resultSet->isValid());
   database->reportExecuteStatementResult(7, SQLError::kVersionErr, 0);
   m_error = SQLErrorData::create(
@@ skipping 13 matching lines @@
 void SQLStatementBackend::clearFailureDueToQuota() {
   if (lastExecutionFailedDueToQuota())
     m_error = nullptr;
 }
 
 bool SQLStatementBackend::lastExecutionFailedDueToQuota() const {
   return m_error && m_error->code() == SQLError::kQuotaErr;
 }
 
 }  // namespace blink