Update inspector classes to use OVERRIDE / FINAL when needed

Source/core/inspector/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 50 matching lines @@
 namespace {
 
 void reportTransactionFailed(ExecuteSQLCallback* requestCallback, SQLError* error)
 {
     RefPtr<TypeBuilder::Database::Error> errorObject = TypeBuilder::Database::Error::create()
         .setMessage(error->message())
         .setCode(error->code());
     requestCallback->sendSuccess(0, 0, errorObject.release());
 }
 
-class StatementCallback : public SQLStatementCallback {
+class StatementCallback FINAL : public SQLStatementCallback {
 public:
     static PassOwnPtr<StatementCallback> create(PassRefPtr<ExecuteSQLCallback> requestCallback)
     {
         return adoptPtr(new StatementCallback(requestCallback));
     }
 
     virtual ~StatementCallback() { }
 
-    virtual bool handleEvent(SQLTransaction*, SQLResultSet* resultSet)
+    virtual 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();
         for (size_t i = 0; i < data.size(); ++i) {
             const SQLValue& value = rowList->values()[i];
             switch (value.type()) {
             case SQLValue::StringValue: values->addItem(JSONString::create(value.string())); break;
             case SQLValue::NumberValue: values->addItem(JSONBasicValue::create(value.number())); break;
             case SQLValue::NullValue: values->addItem(JSONValue::null()); break;
             }
         }
         m_requestCallback->sendSuccess(columnNames.release(), values.release(), 0);
         return true;
     }
 
 private:
     StatementCallback(PassRefPtr<ExecuteSQLCallback> requestCallback)
         : m_requestCallback(requestCallback) { }
     RefPtr<ExecuteSQLCallback> m_requestCallback;
 };
 
-class StatementErrorCallback : public SQLStatementErrorCallback {
+class StatementErrorCallback FINAL : public SQLStatementErrorCallback {
 public:
     static PassOwnPtr<StatementErrorCallback> create(PassRefPtr<ExecuteSQLCallback> requestCallback)
     {
         return adoptPtr(new StatementErrorCallback(requestCallback));
     }
 
     virtual ~StatementErrorCallback() { }
 
-    virtual bool handleEvent(SQLTransaction*, SQLError* error)
+    virtual bool handleEvent(SQLTransaction*, SQLError* error) OVERRIDE
     {
         reportTransactionFailed(m_requestCallback.get(), error);
         return true;
     }
 
 private:
     StatementErrorCallback(PassRefPtr<ExecuteSQLCallback> requestCallback)
         : m_requestCallback(requestCallback) { }
     RefPtr<ExecuteSQLCallback> m_requestCallback;
 };
 
-class TransactionCallback : public SQLTransactionCallback {
+class TransactionCallback FINAL : public SQLTransactionCallback {
 public:
     static PassOwnPtr<TransactionCallback> create(const String& sqlStatement, PassRefPtr<ExecuteSQLCallback> requestCallback)
     {
         return adoptPtr(new TransactionCallback(sqlStatement, requestCallback));
     }
 
     virtual ~TransactionCallback() { }
 
-    virtual bool handleEvent(SQLTransaction* transaction)
+    virtual bool handleEvent(SQLTransaction* transaction) OVERRIDE
     {
         if (!m_requestCallback->isActive())
             return true;
 
         Vector<SQLValue> sqlValues;
         OwnPtr<SQLStatementCallback> callback(StatementCallback::create(m_requestCallback.get()));
         OwnPtr<SQLStatementErrorCallback> errorCallback(StatementErrorCallback::create(m_requestCallback.get()));
         transaction->executeSQL(m_sqlStatement, sqlValues, callback.release(), errorCallback.release(), IGNORE_EXCEPTION);
         return true;
     }
 private:
     TransactionCallback(const String& sqlStatement, PassRefPtr<ExecuteSQLCallback> requestCallback)
         : m_sqlStatement(sqlStatement)
         , m_requestCallback(requestCallback) { }
     String m_sqlStatement;
     RefPtr<ExecuteSQLCallback> m_requestCallback;
 };
 
-class TransactionErrorCallback : public SQLTransactionErrorCallback {
+class TransactionErrorCallback FINAL : public SQLTransactionErrorCallback {
 public:
     static PassOwnPtr<TransactionErrorCallback> create(PassRefPtr<ExecuteSQLCallback> requestCallback)
     {
         return adoptPtr(new TransactionErrorCallback(requestCallback));
     }
 
     virtual ~TransactionErrorCallback() { }
 
-    virtual bool handleEvent(SQLError* error)
+    virtual bool handleEvent(SQLError* error) OVERRIDE
     {
         reportTransactionFailed(m_requestCallback.get(), error);
         return true;
     }
 private:
     TransactionErrorCallback(PassRefPtr<ExecuteSQLCallback> requestCallback)
         : m_requestCallback(requestCallback) { }
     RefPtr<ExecuteSQLCallback> m_requestCallback;
 };
 
-class TransactionSuccessCallback : public VoidCallback {
+class TransactionSuccessCallback FINAL : public VoidCallback {
 public:
     static PassOwnPtr<TransactionSuccessCallback> create()
     {
         return adoptPtr(new TransactionSuccessCallback());
     }
 
     virtual ~TransactionSuccessCallback() { }
 
-    virtual void handleEvent() { }
+    virtual void handleEvent() OVERRIDE { }
 
 private:
     TransactionSuccessCallback() { }
 };
 
 } // namespace
 
 void InspectorDatabaseAgent::didOpenDatabase(PassRefPtr<Database> database, const String& domain, const String& name, const String& version)
 {
     if (InspectorDatabaseResource* resource = findByFileName(database->fileName())) {
@@ skipping 127 matching lines @@
 
 Database* InspectorDatabaseAgent::databaseForId(const String& databaseId)
 {
     DatabaseResourcesMap::iterator it = m_resources.find(databaseId);
     if (it == m_resources.end())
         return 0;
     return it->value->database();
 }
 
 } // namespace WebCore