Update XML classes to use OVERRIDE / FINAL when needed

Source/core/xml/XPathPredicate.h

 /*
  * Copyright 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006 Apple Computer, Inc.
  *
  * 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.
@@ skipping 16 matching lines @@
 #ifndef XPathPredicate_h
 #define XPathPredicate_h
 
 #include "core/xml/XPathExpressionNode.h"
 #include "core/xml/XPathValue.h"
 
 namespace WebCore {
 
     namespace XPath {
 
-        class Number : public Expression {
+        class Number FINAL : public Expression {
         public:
             explicit Number(double);
         private:
-            virtual Value evaluate() const;
-            virtual Value::Type resultType() const { return Value::NumberValue; }
+            virtual Value evaluate() const OVERRIDE;
+            virtual Value::Type resultType() const OVERRIDE { return Value::NumberValue; }
 
             Value m_value;
         };
 
-        class StringExpression : public Expression {
+        class StringExpression FINAL : public Expression {
         public:
             explicit StringExpression(const String&);
         private:
-            virtual Value evaluate() const;
-            virtual Value::Type resultType() const { return Value::StringValue; }
+            virtual Value evaluate() const OVERRIDE;
+            virtual Value::Type resultType() const OVERRIDE { return Value::StringValue; }
 
             Value m_value;
         };
 
-        class Negative : public Expression {
+        class Negative FINAL : public Expression {
         private:
-            virtual Value evaluate() const;
-            virtual Value::Type resultType() const { return Value::NumberValue; }
+            virtual Value evaluate() const OVERRIDE;
+            virtual Value::Type resultType() const OVERRIDE { return Value::NumberValue; }
         };
 
-        class NumericOp : public Expression {
+        class NumericOp FINAL : public Expression {
         public:
             enum Opcode {
                 OP_Add, OP_Sub, OP_Mul, OP_Div, OP_Mod
             };
             NumericOp(Opcode, PassOwnPtr<Expression> lhs, PassOwnPtr<Expression> rhs);
         private:
-            virtual Value evaluate() const;
-            virtual Value::Type resultType() const { return Value::NumberValue; }
+            virtual Value evaluate() const OVERRIDE;
+            virtual Value::Type resultType() const OVERRIDE { return Value::NumberValue; }
 
             Opcode m_opcode;
         };
 
-        class EqTestOp : public Expression {
+        class EqTestOp FINAL : public Expression {
         public:
             enum Opcode { OP_EQ, OP_NE, OP_GT, OP_LT, OP_GE, OP_LE };
             EqTestOp(Opcode, PassOwnPtr<Expression> lhs, PassOwnPtr<Expression> rhs);
-            virtual Value evaluate() const;
+            virtual Value evaluate() const OVERRIDE;
         private:
-            virtual Value::Type resultType() const { return Value::BooleanValue; }
+            virtual Value::Type resultType() const OVERRIDE { return Value::BooleanValue; }
             bool compare(const Value&, const Value&) const;
 
             Opcode m_opcode;
         };
 
-        class LogicalOp : public Expression {
+        class LogicalOp FINAL : public Expression {
         public:
             enum Opcode { OP_And, OP_Or };
             LogicalOp(Opcode, PassOwnPtr<Expression> lhs, PassOwnPtr<Expression> rhs);
         private:
-            virtual Value::Type resultType() const { return Value::BooleanValue; }
+            virtual Value::Type resultType() const OVERRIDE { return Value::BooleanValue; }
             bool shortCircuitOn() const;
-            virtual Value evaluate() const;
+            virtual Value evaluate() const OVERRIDE;
 
             Opcode m_opcode;
         };
 
-        class Union : public Expression {
+        class Union FINAL : public Expression {
         private:
-            virtual Value evaluate() const;
-            virtual Value::Type resultType() const { return Value::NodeSetValue; }
+            virtual Value evaluate() const OVERRIDE;
+            virtual Value::Type resultType() const OVERRIDE { return Value::NodeSetValue; }
         };
 
         class Predicate {
             WTF_MAKE_NONCOPYABLE(Predicate); WTF_MAKE_FAST_ALLOCATED;
         public:
             explicit Predicate(PassOwnPtr<Expression>);
             ~Predicate();
             bool evaluate() const;
 
             bool isContextPositionSensitive() const { return m_expr->isContextPositionSensitive() || m_expr->resultType() == Value::NumberValue; }
             bool isContextSizeSensitive() const { return m_expr->isContextSizeSensitive(); }
 
         private:
             OwnPtr<Expression> m_expr;
         };
 
     }
 
 }
 
 #endif // XPathPredicate_h