Fix virtual/override/final usage in Source/modules/.

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 57 matching lines @@
     requestCallback->sendSuccess(nullptr, nullptr, errorObject.release());
 }
 
 class StatementCallback final : public SQLStatementCallback {
 public:
     static StatementCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
         return new StatementCallback(requestCallback);
     }
 
-    virtual ~StatementCallback() { }
+    ~StatementCallback() override { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_requestCallback);
         SQLStatementCallback::trace(visitor);
     }
 
-    virtual bool handleEvent(SQLTransaction*, SQLResultSet* resultSet) override
+    bool handleEvent(SQLTransaction*, SQLResultSet* resultSet) override
     {
         SQLResultSetRowList* rowList = resultSet->rows();
 
         RefPtr<TypeBuilder::Array<String>> columnNames = TypeBuilder::Array<String>::create();
         const Vector<String>& columns = rowList->columnNames();
         for (size_t i = 0; i < columns.size(); ++i)
             columnNames->addItem(columns[i]);
 
         RefPtr<TypeBuilder::Array<JSONValue>> values = TypeBuilder::Array<JSONValue>::create();
         const Vector<SQLValue>& data = rowList->values();
@@ skipping 15 matching lines @@
     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 };
 
 class StatementErrorCallback final : public SQLStatementErrorCallback {
 public:
     static StatementErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
         return new StatementErrorCallback(requestCallback);
     }
 
-    virtual ~StatementErrorCallback() { }
+    ~StatementErrorCallback() override { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_requestCallback);
         SQLStatementErrorCallback::trace(visitor);
     }
 
-    virtual bool handleEvent(SQLTransaction*, SQLError* error) override
+    bool handleEvent(SQLTransaction*, SQLError* error) override
     {
         reportTransactionFailed(m_requestCallback.get(), error);
         return true;
     }
 
 private:
     StatementErrorCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
         : m_requestCallback(requestCallback) { }
     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 };
 
 class TransactionCallback final : public SQLTransactionCallback {
 public:
     static TransactionCallback* create(const String& sqlStatement, PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
         return new TransactionCallback(sqlStatement, requestCallback);
     }
 
-    virtual ~TransactionCallback() { }
+    ~TransactionCallback() override { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_requestCallback);
         SQLTransactionCallback::trace(visitor);
     }
 
-    virtual bool handleEvent(SQLTransaction* transaction) override
+    bool handleEvent(SQLTransaction* transaction) override
     {
         if (!m_requestCallback->isActive())
             return true;
 
         Vector<SQLValue> sqlValues;
         SQLStatementCallback* callback = StatementCallback::create(m_requestCallback.get());
         SQLStatementErrorCallback* errorCallback = StatementErrorCallback::create(m_requestCallback.get());
         transaction->executeSQL(m_sqlStatement, sqlValues, callback, errorCallback, IGNORE_EXCEPTION);
         return true;
     }
 private:
     TransactionCallback(const String& sqlStatement, PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
         : m_sqlStatement(sqlStatement)
         , m_requestCallback(requestCallback) { }
     String m_sqlStatement;
     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 };
 
 class TransactionErrorCallback final : public SQLTransactionErrorCallback {
 public:
     static TransactionErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
         return new TransactionErrorCallback(requestCallback);
     }
 
-    virtual ~TransactionErrorCallback() { }
+    ~TransactionErrorCallback() override { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_requestCallback);
         SQLTransactionErrorCallback::trace(visitor);
     }
 
-    virtual bool handleEvent(SQLError* error) override
+    bool handleEvent(SQLError* error) override
     {
         reportTransactionFailed(m_requestCallback.get(), error);
         return true;
     }
 private:
     TransactionErrorCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
         : m_requestCallback(requestCallback) { }
     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 };
 
 class TransactionSuccessCallback final : public VoidCallback {
 public:
     static TransactionSuccessCallback* create()
     {
         return new TransactionSuccessCallback();
     }
 
-    virtual ~TransactionSuccessCallback() { }
+    ~TransactionSuccessCallback() override { }
 
-    virtual void handleEvent() override { }
+    void handleEvent() override { }
 
 private:
     TransactionSuccessCallback() { }
 };
 
 } // namespace
 
 void InspectorDatabaseAgent::didOpenDatabase(Database* database, const String& domain, const String& name, const String& version)
 {
     if (InspectorDatabaseResource* resource = findByFileName(database->fileName())) {
@@ skipping 112 matching lines @@
 
 DEFINE_TRACE(InspectorDatabaseAgent)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_resources);
 #endif
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink