Rename OwnPtr::clear() to reset() in modules/.

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 374 matching lines @@
 
     MutexLocker locker(m_statementMutex);
     m_statementQueue.clear();
 
     if (m_sqliteTransaction) {
         // In the event we got here because of an interruption or error (i.e. if
         // the transaction is in progress), we should roll it back here. Clearing
         // m_sqliteTransaction invokes SQLiteTransaction's destructor which does
         // just that. We might as well do this unconditionally and free up its
         // resources because we're already terminating.
-        m_sqliteTransaction.clear();
+        m_sqliteTransaction.reset();
     }
 
     // Release the lock on this database
     if (m_lockAcquired)
         m_database->transactionCoordinator()->releaseLock(this);
 
     // Do some aggresive clean up here except for m_database.
     //
     // We can't clear m_database here because the frontend may asynchronously
     // invoke SQLTransactionBackend::requestTransitToState(), and that function
@@ skipping 86 matching lines @@
     if (m_nextState == SQLTransactionState::End)
         return;
     m_nextState = SQLTransactionState::End;
 
     // If the database was stopped, don't do anything and cancel queued work
     WTF_LOG(StorageAPI, "Database was stopped or interrupted - cancelling work for this transaction");
 
     // The current SQLite transaction should be stopped, as well
     if (m_sqliteTransaction) {
         m_sqliteTransaction->stop();
-        m_sqliteTransaction.clear();
+        m_sqliteTransaction.reset();
     }
 
     // Terminate the frontend state machine. This also gets the frontend to
     // call computeNextStateAndCleanupIfNeeded() and clear its wrappers
     // if needed.
     m_frontend->requestTransitToState(SQLTransactionState::End);
 
     // Redirect to the end state to abort, clean up, and end the transaction.
     doCleanup();
 }
@@ skipping 52 matching lines @@
     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->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
-        m_sqliteTransaction.clear();
+        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->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
         m_database->disableAuthorizer();
-        m_sqliteTransaction.clear();
+        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.clear();
+        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");
         }
         return nextStateForTransactionError();
     }
 
@@ skipping 173 matching lines @@
 {
     ASSERT(m_lockAcquired);
 
     WTF_LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
     m_database->disableAuthorizer();
     if (m_sqliteTransaction) {
         // Spec 4.3.2.10: Rollback the transaction.
         m_sqliteTransaction->rollback();
 
         ASSERT(!m_database->sqliteDatabase().transactionInProgress());
-        m_sqliteTransaction.clear();
+        m_sqliteTransaction.reset();
     }
     m_database->enableAuthorizer();
 
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
 
     return SQLTransactionState::CleanupAndTerminate;
 }
 
 // requestTransitToState() can be called from the frontend. Hence, it should
 // NOT be modifying SQLTransactionBackend in general. The only safe field to
@@ skipping 16 matching lines @@
 }
 
 SQLTransactionState SQLTransactionBackend::sendToFrontendState()
 {
     ASSERT(m_nextState != SQLTransactionState::Idle);
     m_frontend->requestTransitToState(m_nextState);
     return SQLTransactionState::Idle;
 }
 
 } // namespace blink