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

Source/platform/graphics/test/MockImageDecoder.h

 /*
  * Copyright (C) 2012 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 43 matching lines @@
     MockImageDecoder(MockImageDecoderClient* client)
         : ImageDecoder(ImageSource::AlphaPremultiplied, ImageSource::GammaAndColorProfileApplied, noDecodedImageByteLimit)
         , m_client(client)
     { }
 
     ~MockImageDecoder()
     {
         m_client->decoderBeingDestroyed();
     }
 
-    virtual IntSize decodedSize() const override
+    IntSize decodedSize() const override
     {
         return m_client->decodedSize().isEmpty() ? size() : m_client->decodedSize();
     }
 
-    virtual String filenameExtension() const override
+    String filenameExtension() const override
     {
         return "mock";
     }
 
-    virtual int repetitionCount() const override
+    int repetitionCount() const override
     {
         return m_client->repetitionCount();
     }
 
-    virtual bool frameIsCompleteAtIndex(size_t) const override
+    bool frameIsCompleteAtIndex(size_t) const override
     {
         return m_client->status() == ImageFrame::FrameComplete;
     }
 
-    virtual float frameDurationAtIndex(size_t) const override
+    float frameDurationAtIndex(size_t) const override
     {
         return m_client->frameDuration();
     }
 
-    virtual size_t clearCacheExceptFrame(size_t) override { return 0; }
+    size_t clearCacheExceptFrame(size_t) override { return 0; }
 
 private:
-    virtual void decodeSize() override { }
+    void decodeSize() override { }
 
-    virtual size_t decodeFrameCount() override { return m_client->frameCount(); }
+    size_t decodeFrameCount() override { return m_client->frameCount(); }
 
-    virtual void decode(size_t index) override
+    void decode(size_t index) override
     {
         m_client->decodeRequested();
         m_frameBufferCache[index].setStatus(m_client->status());
     }
 
-    virtual void initializeNewFrame(size_t index) override
+    void initializeNewFrame(size_t index) override
     {
         m_frameBufferCache[index].setSize(size().width(), size().height());
         m_frameBufferCache[index].setHasAlpha(false);
     }
 
     MockImageDecoderClient* m_client;
 };
 
 class MockImageDecoderFactory : public ImageDecoderFactory {
 public:
     static PassOwnPtr<MockImageDecoderFactory> create(MockImageDecoderClient* client, const SkISize& decodedSize)
     {
         return adoptPtr(new MockImageDecoderFactory(client, IntSize(decodedSize.width(), decodedSize.height())));
     }
 
     static PassOwnPtr<MockImageDecoderFactory> create(MockImageDecoderClient* client, const IntSize& decodedSize)
     {
         return adoptPtr(new MockImageDecoderFactory(client, decodedSize));
     }
 
-    virtual PassOwnPtr<ImageDecoder> create() override
+    PassOwnPtr<ImageDecoder> create() override
     {
         OwnPtr<MockImageDecoder> decoder = MockImageDecoder::create(m_client);
         decoder->setSize(m_decodedSize.width(), m_decodedSize.height());
         return decoder.release();
     }
 
 private:
     MockImageDecoderFactory(MockImageDecoderClient* client, const IntSize& decodedSize)
         : m_client(client)
         , m_decodedSize(decodedSize)
     {
     }
 
     MockImageDecoderClient* m_client;
     IntSize m_decodedSize;
 };
 
 } // namespace blink
 
 #endif // MockImageDecoder_h