Remove OwnPtr from Blink.

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 23 matching lines @@
 #include "modules/webdatabase/DatabaseThread.h"
 #include "modules/webdatabase/DatabaseTracker.h"
 #include "modules/webdatabase/SQLError.h"
 #include "modules/webdatabase/SQLStatementBackend.h"
 #include "modules/webdatabase/SQLTransaction.h"
 #include "modules/webdatabase/SQLTransactionClient.h"
 #include "modules/webdatabase/SQLTransactionCoordinator.h"
 #include "modules/webdatabase/sqlite/SQLValue.h"
 #include "modules/webdatabase/sqlite/SQLiteTransaction.h"
 #include "platform/Logging.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
+#include <memory>
 
 
 // How does a SQLTransaction work?
 // ==============================
 // The SQLTransaction is a state machine that executes a series of states / steps.
 //
 // The work of the transaction states are defined in section of 4.3.2 of the
 // webdatabase spec: http://dev.w3.org/html5/webdatabase/#processing-model
 //
 // the State Transition Graph at a glance:
@@ skipping 191 matching lines @@
 //     After scheduling the transaction with the DatabaseThread (Database::scheduleTransaction()):
 //     ======================================================================================================
 //     DatabaseThread                         // MessageQueue<DatabaseTask> m_queue points to ...
 //     --> DatabaseTransactionTask            // Member<SQLTransactionBackend> m_transaction points to ...
 //         --> SQLTransactionBackend          // Member<SQLTransaction> m_frontend points to ...
 //             --> SQLTransaction             // Member<SQLTransactionBackend> m_backend points to ...
 //                 --> SQLTransactionBackend  // which is a circular reference.
 //
 //     When executing the transaction (in DatabaseThread::databaseThread()):
 //     ====================================================================
-//     OwnPtr<DatabaseTask> task;             // points to ...
+//     std::unique_ptr<DatabaseTask> task;             // points to ...
 //     --> DatabaseTransactionTask            // Member<SQLTransactionBackend> m_transaction points to ...
 //         --> SQLTransactionBackend          // Member<SQLTransaction> m_frontend;
 //             --> SQLTransaction             // Member<SQLTransactionBackend> m_backend points to ...
 //                 --> SQLTransactionBackend  // which is a circular reference.
 //
 //     At the end of cleanupAndTerminate():
 //     ===================================
 //     At the end of the cleanup state, the SQLTransactionBackend::m_frontend is nullified.
 //     If by then, a JSObject wrapper is referring to the SQLTransaction, then the reference
 //     chain looks like this:
 //
 //     JSObjectWrapper
 //     --> SQLTransaction             // in Member<SQLTransactionBackend> m_backend points to ...
 //         --> SQLTransactionBackend  // which no longer points back to its SQLTransaction.
 //
 //     When the GC collects the corresponding JSObject, the above chain will be cleaned up
 //     and deleted.
 //
 //     If there is no JSObject wrapper referring to the SQLTransaction when the cleanup
 //     states nullify SQLTransactionBackend::m_frontend, the SQLTransaction will deleted then.
 //     However, there will still be a DatabaseTask pointing to the SQLTransactionBackend (see
 //     the "When executing the transaction" chain above). This will keep the
 //     SQLTransactionBackend alive until DatabaseThread::databaseThread() releases its
-//     task OwnPtr.
+//     task std::unique_ptr.
 //
 //     What happens if a transaction is interrupted?
 //     ============================================
 //     If the transaction is interrupted half way, it won't get to run to state
 //     CleanupAndTerminate, and hence, would not have called SQLTransactionBackend's
 //     doCleanup(). doCleanup() is where we nullify SQLTransactionBackend::m_frontend
 //     to break the reference cycle between the frontend and backend. Hence, we need
 //     to cleanup the transaction by other means.
 //
 //     Note: calling SQLTransactionBackend::notifyDatabaseThreadIsShuttingDown()
@@ skipping 263 matching lines @@
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
     ASSERT(m_lockAcquired);
 
     WTF_LOG(StorageAPI, "Opening and preflighting transaction %p", this);
 
     // Set the maximum usage for this transaction if this transactions is not read-only
     if (!m_readOnly)
         m_database->sqliteDatabase().setMaximumSize(m_database->maximumSize());
 
     ASSERT(!m_sqliteTransaction);
-    m_sqliteTransaction = adoptPtr(new SQLiteTransaction(m_database->sqliteDatabase(), m_readOnly));
+    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());
@@ skipping 247 matching lines @@
 }
 
 SQLTransactionState SQLTransactionBackend::sendToFrontendState()
 {
     ASSERT(m_nextState != SQLTransactionState::Idle);
     m_frontend->requestTransitToState(m_nextState);
     return SQLTransactionState::Idle;
 }
 
 } // namespace blink