Replace FINAL and OVERRIDE with their C++11 counterparts in Source/core/xml

Source/core/xml/parser/XMLDocumentParser.cpp

 /*
  * Copyright (C) 2000 Peter Kelly (pmk@post.com)
  * Copyright (C) 2005, 2006, 2008, 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008 Holger Hans Peter Freyther
  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 99 matching lines @@
 
     if (document->frame()->tree().parent())
         return false; // This document is not in a top frame
 
     if (SVGImage::isInSVGImage(document))
         return false;
 
     return true;
 }
 
-class PendingStartElementNSCallback FINAL : public XMLDocumentParser::PendingCallback {
+class PendingStartElementNSCallback final : public XMLDocumentParser::PendingCallback {
 public:
     PendingStartElementNSCallback(const AtomicString& localName, const AtomicString& prefix, const AtomicString& uri,
         int namespaceCount, const xmlChar** namespaces, int attributeCount, int defaultedCount, const xmlChar** attributes)
         : m_localName(localName)
         , m_prefix(prefix)
         , m_uri(uri)
         , m_namespaceCount(namespaceCount)
         , m_attributeCount(attributeCount)
         , m_defaultedCount(defaultedCount)
     {
@@ skipping 16 matching lines @@
     {
         for (int i = 0; i < m_namespaceCount * 2; ++i)
             xmlFree(m_namespaces[i]);
         xmlFree(m_namespaces);
         for (int i = 0; i < m_attributeCount; ++i)
             for (int j = 0; j < 4; ++j)
                 xmlFree(m_attributes[i * 5 + j]);
         xmlFree(m_attributes);
     }
 
-    virtual void call(XMLDocumentParser* parser) OVERRIDE
+    virtual void call(XMLDocumentParser* parser) override
     {
         parser->startElementNs(m_localName, m_prefix, m_uri,
             m_namespaceCount, const_cast<const xmlChar**>(m_namespaces),
             m_attributeCount, m_defaultedCount, const_cast<const xmlChar**>(m_attributes));
     }
 
 private:
     AtomicString m_localName;
     AtomicString m_prefix;
     AtomicString m_uri;
     int m_namespaceCount;
     xmlChar** m_namespaces;
     int m_attributeCount;
     int m_defaultedCount;
     xmlChar** m_attributes;
 };
 
-class PendingEndElementNSCallback FINAL : public XMLDocumentParser::PendingCallback {
+class PendingEndElementNSCallback final : public XMLDocumentParser::PendingCallback {
 public:
-    virtual void call(XMLDocumentParser* parser) OVERRIDE
+    virtual void call(XMLDocumentParser* parser) override
     {
         parser->endElementNs();
     }
 };
 
-class PendingCharactersCallback FINAL : public XMLDocumentParser::PendingCallback {
+class PendingCharactersCallback final : public XMLDocumentParser::PendingCallback {
 public:
     PendingCharactersCallback(const xmlChar* chars, int length)
         : m_chars(xmlStrndup(chars, length))
         , m_length(length)
     {
     }
 
     virtual ~PendingCharactersCallback()
     {
         xmlFree(m_chars);
     }
 
-    virtual void call(XMLDocumentParser* parser) OVERRIDE
+    virtual void call(XMLDocumentParser* parser) override
     {
         parser->characters(m_chars, m_length);
     }
 
 private:
     xmlChar* m_chars;
     int m_length;
 };
 
-class PendingProcessingInstructionCallback FINAL : public XMLDocumentParser::PendingCallback {
+class PendingProcessingInstructionCallback final : public XMLDocumentParser::PendingCallback {
 public:
     PendingProcessingInstructionCallback(const String& target, const String& data)
         : m_target(target)
         , m_data(data)
     {
     }
 
-    virtual void call(XMLDocumentParser* parser) OVERRIDE
+    virtual void call(XMLDocumentParser* parser) override
     {
         parser->processingInstruction(m_target, m_data);
     }
 
 private:
     String m_target;
     String m_data;
 };
 
-class PendingCDATABlockCallback FINAL : public XMLDocumentParser::PendingCallback {
+class PendingCDATABlockCallback final : public XMLDocumentParser::PendingCallback {
 public:
     explicit PendingCDATABlockCallback(const String& text) : m_text(text) { }
 
-    virtual void call(XMLDocumentParser* parser) OVERRIDE
+    virtual void call(XMLDocumentParser* parser) override
     {
         parser->cdataBlock(m_text);
     }
 
 private:
     String m_text;
 };
 
-class PendingCommentCallback FINAL : public XMLDocumentParser::PendingCallback {
+class PendingCommentCallback final : public XMLDocumentParser::PendingCallback {
 public:
     explicit PendingCommentCallback(const String& text) : m_text(text) { }
 
-    virtual void call(XMLDocumentParser* parser) OVERRIDE
+    virtual void call(XMLDocumentParser* parser) override
     {
         parser->comment(m_text);
     }
 
 private:
     String m_text;
 };
 
-class PendingInternalSubsetCallback FINAL : public XMLDocumentParser::PendingCallback {
+class PendingInternalSubsetCallback final : public XMLDocumentParser::PendingCallback {
 public:
     PendingInternalSubsetCallback(const String& name, const String& externalID, const String& systemID)
         : m_name(name)
         , m_externalID(externalID)
         , m_systemID(systemID)
     {
     }
 
-    virtual void call(XMLDocumentParser* parser) OVERRIDE
+    virtual void call(XMLDocumentParser* parser) override
     {
         parser->internalSubset(m_name, m_externalID, m_systemID);
     }
 
 private:
     String m_name;
     String m_externalID;
     String m_systemID;
 };
 
-class PendingErrorCallback FINAL : public XMLDocumentParser::PendingCallback {
+class PendingErrorCallback final : public XMLDocumentParser::PendingCallback {
 public:
     PendingErrorCallback(XMLErrors::ErrorType type, const xmlChar* message, OrdinalNumber lineNumber, OrdinalNumber columnNumber)
         : m_type(type)
         , m_message(xmlStrdup(message))
         , m_lineNumber(lineNumber)
         , m_columnNumber(columnNumber)
     {
     }
 
     virtual ~PendingErrorCallback()
     {
         xmlFree(m_message);
     }
 
-    virtual void call(XMLDocumentParser* parser) OVERRIDE
+    virtual void call(XMLDocumentParser* parser) override
     {
         parser->handleError(m_type, reinterpret_cast<char*>(m_message), TextPosition(m_lineNumber, m_columnNumber));
     }
 
 private:
     XMLErrors::ErrorType m_type;
     xmlChar* m_message;
     OrdinalNumber m_lineNumber;
     OrdinalNumber m_columnNumber;
 };
@@ skipping 1348 matching lines @@
     sax.initialized = XML_SAX2_MAGIC;
     RefPtr<XMLParserContext> parser = XMLParserContext::createStringParser(&sax, &state);
     String parseString = "<?xml version=\"1.0\"?><attrs " + string + " />";
     parseChunk(parser->context(), parseString);
     finishParsing(parser->context());
     attrsOK = state.gotAttributes;
     return state.attributes;
 }
 
 } // namespace blink