Replaced PassRefPtr copites with moves in Source/modules.

third_party/WebKit/Source/modules/webdatabase/InspectorDatabaseAgent.cpp

 /*
  * Copyright (C) 2010 Google 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 64 matching lines @@
 
 private:
     explicit ExecuteSQLCallbackWrapper(std::unique_ptr<ExecuteSQLCallback> callback) : m_callback(std::move(callback)) { }
     std::unique_ptr<ExecuteSQLCallback> m_callback;
 };
 
 class StatementCallback final : public SQLStatementCallback {
 public:
     static StatementCallback* create(PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback)
     {
-        return new StatementCallback(requestCallback);
+        return new StatementCallback(std::move(requestCallback));
     }
 
     ~StatementCallback() override { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         SQLStatementCallback::trace(visitor);
     }
 
     bool handleEvent(SQLTransaction*, SQLResultSet* resultSet) override
@@ skipping 21 matching lines @@
 
 private:
     StatementCallback(PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback) : m_requestCallback(requestCallback) { }
     RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback;
 };
 
 class StatementErrorCallback final : public SQLStatementErrorCallback {
 public:
     static StatementErrorCallback* create(PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback)
     {
-        return new StatementErrorCallback(requestCallback);
+        return new StatementErrorCallback(std::move(requestCallback));
     }
 
     ~StatementErrorCallback() override { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         SQLStatementErrorCallback::trace(visitor);
     }
 
     bool handleEvent(SQLTransaction*, SQLError* error) override
     {
         m_requestCallback->reportTransactionFailed(error);
         return true;
     }
 
 private:
     StatementErrorCallback(PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback) : m_requestCallback(requestCallback) { }
     RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback;
 };
 
 class TransactionCallback final : public SQLTransactionCallback {
 public:
     static TransactionCallback* create(const String& sqlStatement, PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback)
     {
-        return new TransactionCallback(sqlStatement, requestCallback);
+        return new TransactionCallback(sqlStatement, std::move(requestCallback));
     }
 
     ~TransactionCallback() override { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         SQLTransactionCallback::trace(visitor);
     }
 
     bool handleEvent(SQLTransaction* transaction) override
     {
         Vector<SQLValue> sqlValues;
         SQLStatementCallback* callback = StatementCallback::create(m_requestCallback);
         SQLStatementErrorCallback* errorCallback = StatementErrorCallback::create(m_requestCallback);
         transaction->executeSQL(m_sqlStatement, sqlValues, callback, errorCallback, IGNORE_EXCEPTION);
         return true;
     }
 private:
     TransactionCallback(const String& sqlStatement, PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback)
         : m_sqlStatement(sqlStatement)
         , m_requestCallback(requestCallback) { }
     String m_sqlStatement;
     RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback;
 };
 
 class TransactionErrorCallback final : public SQLTransactionErrorCallback {
 public:
     static TransactionErrorCallback* create(PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback)
     {
-        return new TransactionErrorCallback(requestCallback);
+        return new TransactionErrorCallback(std::move(requestCallback));
     }
 
     ~TransactionErrorCallback() override { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         SQLTransactionErrorCallback::trace(visitor);
     }
 
     bool handleEvent(SQLError* error) override
@@ skipping 150 matching lines @@
 }
 
 DEFINE_TRACE(InspectorDatabaseAgent)
 {
     visitor->trace(m_page);
     visitor->trace(m_resources);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink