Wrapped PassRefPtrs in move where passed to RefPtr constructor.

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 117 matching lines @@
       }
     }
     m_requestCallback->get()->sendSuccess(std::move(columnNames),
                                           std::move(values),
                                           Maybe<protocol::Database::Error>());
     return true;
   }
 
  private:
   StatementCallback(PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback)
-      : m_requestCallback(requestCallback) {}
+      : m_requestCallback(std::move(requestCallback)) {}
   RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback;
 };
 
 class StatementErrorCallback final : public SQLStatementErrorCallback {
  public:
   static StatementErrorCallback* create(
       PassRefPtr<ExecuteSQLCallbackWrapper> 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) {}
+      : m_requestCallback(std::move(requestCallback)) {}
   RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback;
 };
 
 class TransactionCallback final : public SQLTransactionCallback {
  public:
   static TransactionCallback* create(
       const String& sqlStatement,
       PassRefPtr<ExecuteSQLCallbackWrapper> 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_FOR_TESTING);
     return true;
   }
 
  private:
   TransactionCallback(const String& sqlStatement,
                       PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback)
-      : m_sqlStatement(sqlStatement), m_requestCallback(requestCallback) {}
+      : m_sqlStatement(sqlStatement),
+        m_requestCallback(std::move(requestCallback)) {}
   String m_sqlStatement;
   RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback;
 };
 
 class TransactionErrorCallback final : public SQLTransactionErrorCallback {
  public:
   static TransactionErrorCallback* create(
       PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback) {
     return new TransactionErrorCallback(std::move(requestCallback));
   }
 
   ~TransactionErrorCallback() override {}
 
   DEFINE_INLINE_VIRTUAL_TRACE() { SQLTransactionErrorCallback::trace(visitor); }
 
   bool handleEvent(SQLError* error) override {
     m_requestCallback->reportTransactionFailed(error);
     return true;
   }
 
  private:
   TransactionErrorCallback(
       PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback)
-      : m_requestCallback(requestCallback) {}
+      : m_requestCallback(std::move(requestCallback)) {}
   RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback;
 };
 
 class TransactionSuccessCallback final : public VoidCallback {
  public:
   static TransactionSuccessCallback* create() {
     return new TransactionSuccessCallback();
   }
 
   ~TransactionSuccessCallback() override {}
@@ skipping 139 matching lines @@
   return it->value->database();
 }
 
 DEFINE_TRACE(InspectorDatabaseAgent) {
   visitor->trace(m_page);
   visitor->trace(m_resources);
   InspectorBaseAgent::trace(visitor);
 }
 
 }  // namespace blink