Changeset 203146 in webkit


Ignore:
Timestamp:
Jul 12, 2016 6:24:22 PM (8 years ago)
Author:
Gyuyoung Kim
Message:

Purge PassRefPtr in Modules/webdatabase
​https://bugs.webkit.org/show_bug.cgi?id=159255

Reviewed by Benjamin Poulain.

As a step to remove PassRefPtr use, this patch cleans it up in Modules/webdatabase.

Additionally unnecessary spaces and tabs are removed too.

  • Modules/webdatabase/ChangeVersionWrapper.cpp:
  • Modules/webdatabase/DOMWindowWebDatabase.h:
  • Modules/webdatabase/Database.cpp:

(WebCore::Database::Database):
(WebCore::Database::~Database):
(WebCore::Database::scheduleTransaction):
(WebCore::Database::runTransaction):

  • Modules/webdatabase/Database.h:
  • Modules/webdatabase/DatabaseAuthorizer.cpp:

(WebCore::DatabaseAuthorizer::allowRead):

  • Modules/webdatabase/DatabaseManager.cpp:

(WebCore::DatabaseManager::openDatabase):
(WebCore::DatabaseManager::fullPathForDatabase):
(WebCore::DatabaseManager::detailsForNameAndOrigin):

  • Modules/webdatabase/DatabaseManager.h:
  • Modules/webdatabase/DatabaseTask.cpp:

(WebCore::DatabaseTransactionTask::DatabaseTransactionTask):

  • Modules/webdatabase/DatabaseTask.h:
  • Modules/webdatabase/SQLCallbackWrapper.h:

(WebCore::SQLCallbackWrapper::SQLCallbackWrapper):

  • Modules/webdatabase/SQLResultSetRowList.h:
  • Modules/webdatabase/SQLStatement.cpp:

(WebCore::SQLStatement::SQLStatement):
(WebCore::SQLStatement::sqlError):
(WebCore::SQLStatement::sqlResultSet):

  • Modules/webdatabase/SQLStatement.h:
  • Modules/webdatabase/SQLTransaction.h:
  • Modules/webdatabase/SQLTransactionBackend.cpp:

(WebCore::SQLTransactionBackend::create):
(WebCore::SQLTransactionBackend::SQLTransactionBackend):
(WebCore::SQLTransactionBackend::transactionError):

  • Modules/webdatabase/SQLTransactionBackend.h:
Location:
trunk/Source/WebCore
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r203120 r203146  
     12016-07-12  Gyuyoung Kim  <gyuyoung.kim@webkit.org>
     2
     3        Purge PassRefPtr in Modules/webdatabase
     4        https://bugs.webkit.org/show_bug.cgi?id=159255
     5
     6        Reviewed by Benjamin Poulain.
     7
     8        As a step to remove PassRefPtr use, this patch cleans it up in Modules/webdatabase.
     9
     10        Additionally unnecessary spaces and tabs are removed too.
     11
     12        * Modules/webdatabase/ChangeVersionWrapper.cpp:
     13        * Modules/webdatabase/DOMWindowWebDatabase.h:
     14        * Modules/webdatabase/Database.cpp:
     15        (WebCore::Database::Database):
     16        (WebCore::Database::~Database):
     17        (WebCore::Database::scheduleTransaction):
     18        (WebCore::Database::runTransaction):
     19        * Modules/webdatabase/Database.h:
     20        * Modules/webdatabase/DatabaseAuthorizer.cpp:
     21        (WebCore::DatabaseAuthorizer::allowRead):
     22        * Modules/webdatabase/DatabaseManager.cpp:
     23        (WebCore::DatabaseManager::openDatabase):
     24        (WebCore::DatabaseManager::fullPathForDatabase):
     25        (WebCore::DatabaseManager::detailsForNameAndOrigin):
     26        * Modules/webdatabase/DatabaseManager.h:
     27        * Modules/webdatabase/DatabaseTask.cpp:
     28        (WebCore::DatabaseTransactionTask::DatabaseTransactionTask):
     29        * Modules/webdatabase/DatabaseTask.h:
     30        * Modules/webdatabase/SQLCallbackWrapper.h:
     31        (WebCore::SQLCallbackWrapper::SQLCallbackWrapper):
     32        * Modules/webdatabase/SQLResultSetRowList.h:
     33        * Modules/webdatabase/SQLStatement.cpp:
     34        (WebCore::SQLStatement::SQLStatement):
     35        (WebCore::SQLStatement::sqlError):
     36        (WebCore::SQLStatement::sqlResultSet):
     37        * Modules/webdatabase/SQLStatement.h:
     38        * Modules/webdatabase/SQLTransaction.h:
     39        * Modules/webdatabase/SQLTransactionBackend.cpp:
     40        (WebCore::SQLTransactionBackend::create):
     41        (WebCore::SQLTransactionBackend::SQLTransactionBackend):
     42        (WebCore::SQLTransactionBackend::transactionError):
     43        * Modules/webdatabase/SQLTransactionBackend.h:
     44
    1452016-07-11  Dean Jackson  <dino@apple.com>
    246

  • trunk/Source/WebCore/Modules/webdatabase/ChangeVersionWrapper.cpp

    r202698 r203146  
    3131#include "Database.h"
    3232#include "SQLError.h"
    33 #include <wtf/PassRefPtr.h>
    3433#include <wtf/RefPtr.h>
    3534

  • trunk/Source/WebCore/Modules/webdatabase/DOMWindowWebDatabase.h

    r202698 r203146  
    2222 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    2323 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2525 */
    2626
    … …  
    2929
    3030#include "ExceptionCode.h"
    31 #include <wtf/PassRefPtr.h>
    3231#include <wtf/RefCounted.h>
    3332#include <wtf/RefPtr.h>

  • trunk/Source/WebCore/Modules/webdatabase/Database.cpp

    r202698 r203146  
    204204}
    205205
    206 Database::Database(PassRefPtr<DatabaseContext> databaseContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
     206Database::Database(RefPtr<DatabaseContext>&& databaseContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
    207207    : m_scriptExecutionContext(databaseContext->scriptExecutionContext())
    208     , m_databaseContext(databaseContext)
     208    , m_databaseContext(WTFMove(databaseContext))
    209209    , m_deleted(false)
    210210    , m_name(name.isolatedCopy())
    … …  
    572572
    573573    if (transaction && databaseContext()->databaseThread()) {
    574         auto task = std::make_unique<DatabaseTransactionTask>(transaction);
     574        auto task = std::make_unique<DatabaseTransactionTask>(WTFMove(transaction));
    575575        LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task.get(), task->transaction());
    576576        m_transactionInProgress = true;
    … …  
    590590        wrapper = ChangeVersionWrapper::create(data->oldVersion(), data->newVersion());
    591591
    592     RefPtr<SQLTransactionBackend> transactionBackend = SQLTransactionBackend::create(this, WTFMove(transaction), wrapper, readOnly);
     592    RefPtr<SQLTransactionBackend> transactionBackend = SQLTransactionBackend::create(this, WTFMove(transaction), WTFMove(wrapper), readOnly);
    593593    m_transactionQueue.append(transactionBackend);
    594594    if (!m_transactionInProgress)

  • trunk/Source/WebCore/Modules/webdatabase/Database.h

    r202698 r203146  
    126126
    127127private:
    128     Database(PassRefPtr<DatabaseContext>, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
     128    Database(RefPtr<DatabaseContext>&&, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
    129129
    130130    void closeDatabase();

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseAuthorizer.cpp

    r202698 r203146  
    3030#include "DatabaseAuthorizer.h"
    3131
    32 #include <wtf/PassRefPtr.h>
    3332#include <wtf/text/WTFString.h>
    3433
    … …  
    345344    if (m_permissions & NoAccessMask && m_securityEnabled)
    346345        return SQLAuthDeny;
    347    
     346
    348347    return denyBasedOnTableName(tableName);
    349348}

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseManager.cpp

    r202698 r203146  
    2121 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    2222 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2424 */
    2525
    … …  
    273273RefPtr<Database> DatabaseManager::openDatabase(ScriptExecutionContext* context,
    274274    const String& name, const String& expectedVersion, const String& displayName,
    275     unsigned long estimatedSize, PassRefPtr<DatabaseCallback> creationCallback,
     275    unsigned long estimatedSize, RefPtr<DatabaseCallback>&& creationCallback,
    276276    DatabaseError& error)
    277277{
    … …  
    328328        }
    329329    }
    330    
     330
    331331    return m_server->fullPathForDatabase(origin, name, createIfDoesNotExist);
    332332}
    … …  
    351351    {
    352352        std::lock_guard<Lock> lock(m_mutex);
    353        
     353
    354354        for (auto* proposedDatabase : m_proposedDatabases) {
    355355            if (proposedDatabase->details().name() == name && proposedDatabase->origin()->equal(origin)) {
    356356                ASSERT(proposedDatabase->details().threadID() == std::this_thread::get_id() || isMainThread());
    357                
     357
    358358                return proposedDatabase->details();
    359359            }
    360360        }
    361361    }
    362    
     362
    363363    return m_server->detailsForNameAndOrigin(name, origin);
    364364}

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseManager.h

    r202698 r203146  
    2121 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    2222 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2424 */
    2525
    … …  
    3434#include <wtf/HashSet.h>
    3535#include <wtf/Lock.h>
    36 #include <wtf/PassRefPtr.h>
    3736#include <wtf/Threading.h>
    3837
    … …  
    8281    static ExceptionCode exceptionCodeForDatabaseError(DatabaseError);
    8382
    84     RefPtr<Database> openDatabase(ScriptExecutionContext*, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, PassRefPtr<DatabaseCallback>, DatabaseError&);
     83    RefPtr<Database> openDatabase(ScriptExecutionContext*, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, RefPtr<DatabaseCallback>&&, DatabaseError&);
    8584
    8685    WEBCORE_EXPORT bool hasOpenDatabases(ScriptExecutionContext*);

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseServer.cpp

    r202698 r203146  
    2121 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    2222 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2424 */
    2525
    … …  
    118118    RefPtr<Database> database;
    119119    bool success = false; // Make some older compilers happy.
    120    
     120
    121121    switch (attempt) {
    122122    case FirstTryToOpenDatabase:
    … …  
    134134RefPtr<Database> DatabaseServer::createDatabase(RefPtr<DatabaseContext>& backendContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
    135135{
    136     RefPtr<Database> database = adoptRef(new Database(backendContext, name, expectedVersion, displayName, estimatedSize));
     136    RefPtr<Database> database = adoptRef(new Database(backendContext.copyRef(), name, expectedVersion, displayName, estimatedSize));
    137137
    138138    if (!database->openAndVerifyVersion(setVersionInNewDatabase, error, errorMessage))

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseTask.cpp

    r202698 r203146  
    145145// Starts a transaction that will report its results via a callback.
    146146
    147 DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend> transaction)
     147DatabaseTransactionTask::DatabaseTransactionTask(RefPtr<SQLTransactionBackend>&& transaction)
    148148    : DatabaseTask(*transaction->database(), 0)
    149     , m_transaction(transaction)
     149    , m_transaction(WTFMove(transaction))
    150150    , m_didPerformTask(false)
    151151{

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseTask.h

    r202698 r203146  
    3434#include <wtf/Condition.h>
    3535#include <wtf/Lock.h>
    36 #include <wtf/PassRefPtr.h>
    3736#include <wtf/Vector.h>
    3837#include <wtf/text/WTFString.h>
    … …  
    124123class DatabaseTransactionTask : public DatabaseTask {
    125124public:
    126     explicit DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend>);
     125    explicit DatabaseTransactionTask(RefPtr<SQLTransactionBackend>&&);
    127126    virtual ~DatabaseTransactionTask();
    128127

  • trunk/Source/WebCore/Modules/webdatabase/SQLCallbackWrapper.h

    r202698 r203146  
    4242template<typename T> class SQLCallbackWrapper {
    4343public:
    44     SQLCallbackWrapper(PassRefPtr<T> callback, ScriptExecutionContext* scriptExecutionContext)
    45         : m_callback(callback)
     44    SQLCallbackWrapper(RefPtr<T>&& callback, ScriptExecutionContext* scriptExecutionContext)
     45        : m_callback(WTFMove(callback))
    4646        , m_scriptExecutionContext(m_callback ? scriptExecutionContext : 0)
    4747    {

  • trunk/Source/WebCore/Modules/webdatabase/SQLResultSetRowList.h

    r202698 r203146  
    3030#define SQLResultSetRowList_h
    3131
    32 #include <wtf/PassRefPtr.h>
    3332#include <wtf/RefCounted.h>
    3433#include "SQLValue.h"

  • trunk/Source/WebCore/Modules/webdatabase/SQLStatement.cpp

    r202698 r203146  
    4141
    4242
    43 // The Life-Cycle of a SQLStatement i.e. Who's keeping the SQLStatement alive? 
     43// The Life-Cycle of a SQLStatement i.e. Who's keeping the SQLStatement alive?
    4444// ==========================================================================
    4545// The RefPtr chain goes something like this:
    … …  
    7575namespace WebCore {
    7676
    77 SQLStatement::SQLStatement(Database& database, const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback, int permissions)
     77SQLStatement::SQLStatement(Database& database, const String& statement, const Vector<SQLValue>& arguments, RefPtr<SQLStatementCallback>&& callback, RefPtr<SQLStatementErrorCallback>&& errorCallback, int permissions)
    7878    : m_statement(statement.isolatedCopy())
    7979    , m_arguments(arguments)
    80     , m_statementCallbackWrapper(callback, database.scriptExecutionContext())
    81     , m_statementErrorCallbackWrapper(errorCallback, database.scriptExecutionContext())
     80    , m_statementCallbackWrapper(WTFMove(callback), database.scriptExecutionContext())
     81    , m_statementErrorCallbackWrapper(WTFMove(errorCallback), database.scriptExecutionContext())
    8282    , m_permissions(permissions)
    8383{
    … …  
    8888}
    8989
    90 PassRefPtr<SQLError> SQLStatement::sqlError() const
    91 {
    92     return m_error;
    93 }
    94 
    95 PassRefPtr<SQLResultSet> SQLStatement::sqlResultSet() const
    96 {
    97     return m_resultSet;
     90SQLError* SQLStatement::sqlError() const
     91{
     92    return m_error.get();
     93}
     94
     95SQLResultSet* SQLStatement::sqlResultSet() const
     96{
     97    return m_resultSet.get();
    9898}
    9999

  • trunk/Source/WebCore/Modules/webdatabase/SQLStatement.h

    r202698 r203146  
    4646class SQLStatement {
    4747public:
    48     SQLStatement(Database&, const String&, const Vector<SQLValue>&, PassRefPtr<SQLStatementCallback>, PassRefPtr<SQLStatementErrorCallback>, int permissions);
     48    SQLStatement(Database&, const String&, const Vector<SQLValue>&, RefPtr<SQLStatementCallback>&&, RefPtr<SQLStatementErrorCallback>&&, int permissions);
    4949    ~SQLStatement();
    5050
    … …  
    5959    void setVersionMismatchedError();
    6060
    61     PassRefPtr<SQLError> sqlError() const;
    62     PassRefPtr<SQLResultSet> sqlResultSet() const;
     61    SQLError* sqlError() const;
     62    SQLResultSet* sqlResultSet() const;
    6363
    6464private:

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransaction.h

    r202698 r203146  
    3333#include "SQLCallbackWrapper.h"
    3434#include "SQLTransactionStateMachine.h"
    35 #include <wtf/PassRefPtr.h>
    3635#include <wtf/Ref.h>
    3736#include <wtf/RefPtr.h>

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp

    r202698 r203146  
    344344namespace WebCore {
    345345
    346 Ref<SQLTransactionBackend> SQLTransactionBackend::create(Database* db, PassRefPtr<SQLTransaction> frontend, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
    347 {
    348     return adoptRef(*new SQLTransactionBackend(db, frontend, wrapper, readOnly));
    349 }
    350 
    351 SQLTransactionBackend::SQLTransactionBackend(Database* db, PassRefPtr<SQLTransaction> frontend, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
    352     : m_frontend(frontend)
     346Ref<SQLTransactionBackend> SQLTransactionBackend::create(Database* db, RefPtr<SQLTransaction>&& frontend, RefPtr<SQLTransactionWrapper>&& wrapper, bool readOnly)
     347{
     348    return adoptRef(*new SQLTransactionBackend(db, WTFMove(frontend), WTFMove(wrapper), readOnly));
     349}
     350
     351SQLTransactionBackend::SQLTransactionBackend(Database* db, RefPtr<SQLTransaction>&& frontend, RefPtr<SQLTransactionWrapper>&& wrapper, bool readOnly)
     352    : m_frontend(WTFMove(frontend))
    353353    , m_database(db)
    354     , m_wrapper(wrapper)
     354    , m_wrapper(WTFMove(wrapper))
    355355    , m_hasCallback(m_frontend->hasCallback())
    356356    , m_hasSuccessCallback(m_frontend->hasSuccessCallback())
    … …  
    429429}
    430430
    431 PassRefPtr<SQLError> SQLTransactionBackend::transactionError()
    432 {
    433     return m_transactionError;
     431SQLError* SQLTransactionBackend::transactionError()
     432{
     433    return m_transactionError.get();
    434434}
    435435

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.h

    r202698 r203146  
    5959class SQLTransactionBackend : public ThreadSafeRefCounted<SQLTransactionBackend>, public SQLTransactionStateMachine<SQLTransactionBackend> {
    6060public:
    61     static Ref<SQLTransactionBackend> create(Database*, PassRefPtr<SQLTransaction>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
     61    static Ref<SQLTransactionBackend> create(Database*, RefPtr<SQLTransaction>&&, RefPtr<SQLTransactionWrapper>&&, bool readOnly);
    6262
    6363    virtual ~SQLTransactionBackend();
    … …  
    7272    // APIs called from the frontend published via SQLTransactionBackend:
    7373    void requestTransitToState(SQLTransactionState);
    74     PassRefPtr<SQLError> transactionError();
     74    SQLError* transactionError();
    7575    SQLStatement* currentStatement();
    7676    void setShouldRetryCurrentStatement(bool);
    … …  
    7878   
    7979private:
    80     SQLTransactionBackend(Database*, PassRefPtr<SQLTransaction>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
     80    SQLTransactionBackend(Database*, RefPtr<SQLTransaction>&&, RefPtr<SQLTransactionWrapper>&&, bool readOnly);
    8181
    8282    void doCleanup();
Note: See TracChangeset for help on using the changeset viewer.