DevTools: move recurring flag into AsyncTask, control cancelation from embedder only.

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 54 matching lines @@
                                SQLTransactionErrorCallback* errorCallback,
                                bool readOnly)
     : m_database(db),
       m_callback(callback),
       m_successCallback(successCallback),
       m_errorCallback(errorCallback),
       m_executeSqlAllowed(false),
       m_readOnly(readOnly) {
   DCHECK(isMainThread());
   ASSERT(m_database);
-  probe::asyncTaskScheduled(db->getExecutionContext(), "SQLTransaction", this,
-                            true);
+  probe::asyncTaskScheduled(db->getExecutionContext(), "SQLTransaction", this);
 }
 
 SQLTransaction::~SQLTransaction() {}
 
 DEFINE_TRACE(SQLTransaction) {
   visitor->trace(m_database);
   visitor->trace(m_backend);
   visitor->trace(m_callback);
   visitor->trace(m_successCallback);
   visitor->trace(m_errorCallback);
@@ skipping 59 matching lines @@
   if (hasErrorCallback())
     return SQLTransactionState::DeliverTransactionErrorCallback;
 
   // No error callback, so fast-forward to:
   // Transaction Step 11 - Rollback the transaction.
   return SQLTransactionState::CleanupAfterTransactionErrorCallback;
 }
 
 SQLTransactionState SQLTransaction::deliverTransactionCallback() {
   bool shouldDeliverErrorCallback = false;
-  probe::AsyncTask asyncTask(m_database->getExecutionContext(), this);
+  probe::AsyncTask asyncTask(m_database->getExecutionContext(), this,
+                             "transaction");
 
   // 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.
   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;
 }
 
 SQLTransactionState SQLTransaction::deliverTransactionErrorCallback() {
   probe::AsyncTask asyncTask(m_database->getExecutionContext(), this);
-  probe::asyncTaskCanceled(m_database->getExecutionContext(), this);
 
   // Spec 4.3.2.10: If exists, invoke error callback with the last
   // error to have occurred in this transaction.
   if (SQLTransactionErrorCallback* errorCallback = m_errorCallback.release()) {
     // If we get here with an empty m_transactionError, then the backend
     // must be waiting in the idle state waiting for this state to finish.
     // Hence, it's thread safe to fetch the backend transactionError without
     // a lock.
     if (!m_transactionError) {
       ASSERT(m_backend->transactionError());
@@ skipping 43 matching lines @@
   bool shouldRetryCurrentStatement =
       m_database->transactionClient()->didExceedQuota(database());
   m_backend->setShouldRetryCurrentStatement(shouldRetryCurrentStatement);
 
   return SQLTransactionState::RunStatements;
 }
 
 SQLTransactionState SQLTransaction::deliverSuccessCallback() {
   DCHECK(isMainThread());
   probe::AsyncTask asyncTask(m_database->getExecutionContext(), this);
-  probe::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.
   return SQLTransactionState::CleanupAndTerminate;
@@ skipping 96 matching lines @@
   m_callback.clear();
   m_successCallback.clear();
   m_errorCallback.clear();
 }
 
 SQLTransactionErrorCallback* SQLTransaction::releaseErrorCallback() {
   return m_errorCallback.release();
 }
 
 }  // namespace blink