reflow comments in modules/webdatabase

third_party/WebKit/Source/modules/webdatabase/SQLTransaction.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 138 matching lines @@
   // No error callback, so fast-forward to:
   // Transaction Step 11 - Rollback the transaction.
   return SQLTransactionState::CleanupAfterTransactionErrorCallback;
 }
 
 SQLTransactionState SQLTransaction::deliverTransactionCallback() {
   bool shouldDeliverErrorCallback = false;
   InspectorInstrumentation::AsyncTask asyncTask(
       m_database->getExecutionContext(), this);
 
-  // Spec 4.3.2 4: Invoke the transaction callback with the new SQLTransaction object
+  // Spec 4.3.2 4: Invoke the transaction callback with the new SQLTransaction
+  // object.
   if (SQLTransactionCallback* callback = m_callback.release()) {
     m_executeSqlAllowed = true;
     shouldDeliverErrorCallback = !callback->handleEvent(this);
     m_executeSqlAllowed = false;
   }
 
-  // Spec 4.3.2 5: If the transaction callback was null or raised an exception, jump to the error callback
+  // Spec 4.3.2 5: If the transaction callback was null or raised an exception,
+  // jump to the error callback.
   SQLTransactionState nextState = SQLTransactionState::RunStatements;
   if (shouldDeliverErrorCallback) {
     m_database->reportStartTransactionResult(5, SQLError::kUnknownErr, 0);
     m_transactionError = SQLErrorData::create(
         SQLError::kUnknownErr,
         "the SQLTransactionCallback was null or threw an exception");
     nextState = SQLTransactionState::DeliverTransactionErrorCallback;
   }
   m_database->reportStartTransactionResult(0, -1, 0);  // OK
   return nextState;
@@ skipping 23 matching lines @@
   }
 
   clearCallbacks();
 
   // Spec 4.3.2.10: Rollback the transaction.
   return SQLTransactionState::CleanupAfterTransactionErrorCallback;
 }
 
 SQLTransactionState SQLTransaction::deliverStatementCallback() {
   DCHECK(isMainThread());
-  // Spec 4.3.2.6.6 and 4.3.2.6.3: If the statement callback went wrong, jump to the transaction error callback
-  // Otherwise, continue to loop through the statement queue
+  // Spec 4.3.2.6.6 and 4.3.2.6.3: If the statement callback went wrong, jump to
+  // the transaction error callback.  Otherwise, continue to loop through the
+  // statement queue.
   m_executeSqlAllowed = true;
 
   SQLStatement* currentStatement = m_backend->currentStatement();
   ASSERT(currentStatement);
 
   bool result = currentStatement->performCallback(this);
 
   m_executeSqlAllowed = false;
 
   if (result) {
@@ skipping 24 matching lines @@
       m_database->getExecutionContext(), this);
   InspectorInstrumentation::asyncTaskCanceled(m_database->getExecutionContext(),
                                               this);
 
   // Spec 4.3.2.8: Deliver success callback.
   if (VoidCallback* successCallback = m_successCallback.release())
     successCallback->handleEvent();
 
   clearCallbacks();
 
-  // Schedule a "post-success callback" step to return control to the database thread in case there
-  // are further transactions queued up for this Database
+  // Schedule a "post-success callback" step to return control to the database
+  // thread in case there are further transactions queued up for this Database.
   return SQLTransactionState::CleanupAndTerminate;
 }
 
 // This state function is used as a stub function to plug unimplemented states
 // in the state dispatch table. They are unimplemented because they should
 // never be reached in the course of correct execution.
 SQLTransactionState SQLTransaction::unreachableState() {
   ASSERT_NOT_REACHED();
   return SQLTransactionState::End;
 }
@@ skipping 87 matching lines @@
   m_callback.clear();
   m_successCallback.clear();
   m_errorCallback.clear();
 }
 
 SQLTransactionErrorCallback* SQLTransaction::releaseErrorCallback() {
   return m_errorCallback.release();
 }
 
 }  // namespace blink