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

Source/web/tests/WebViewTest.cpp

 /*
  * Copyright (C) 2011, 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 1257 matching lines @@
 }
 
 class PrintWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
     PrintWebViewClient()
         : m_printCalled(false)
     {
     }
 
     // WebViewClient methods
-    virtual void printPage(WebLocalFrame*) override
+    void printPage(WebLocalFrame*) override
     {
         m_printCalled = true;
     }
 
     bool printCalled() const { return m_printCalled; }
 
 private:
     bool m_printCalled;
 };
 
 
 TEST_F(WebViewTest, PrintWithXHRInFlight)
 {
     PrintWebViewClient client;
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("print_with_xhr_inflight.html"));
     WebViewImpl* webViewImpl = m_webViewHelper.initializeAndLoad(m_baseURL + "print_with_xhr_inflight.html", true, 0, &client);
 
     ASSERT_TRUE(toLocalFrame(webViewImpl->page()->mainFrame())->document()->loadEventFinished());
     EXPECT_TRUE(client.printCalled());
     m_webViewHelper.reset();
 }
 
 class DropTask : public WebThread::Task {
 public:
     explicit DropTask(WebView* webView) : m_webView(webView)
     {
     }
 
-    virtual void run() override
+    void run() override
     {
         const WebPoint clientPoint(0, 0);
         const WebPoint screenPoint(0, 0);
         m_webView->dragTargetDrop(clientPoint, screenPoint, 0);
     }
 
 private:
     WebView* const m_webView;
 };
 static void DragAndDropURL(WebViewImpl* webView, const std::string& url)
@@ skipping 39 matching lines @@
 
     // Attempt to drag and drop to barUrl and verify that no navigation has occurred.
     DragAndDropURL(webView, barUrl);
     EXPECT_EQ(fooUrl, webView->mainFrame()->document().url().string().utf8());
 }
 
 class ContentDetectorClient : public FrameTestHelpers::TestWebViewClient {
 public:
     ContentDetectorClient() { reset(); }
 
-    virtual WebContentDetectionResult detectContentAround(const WebHitTestResult& hitTest) override
+    WebContentDetectionResult detectContentAround(const WebHitTestResult& hitTest) override
     {
         m_contentDetectionRequested = true;
         return m_contentDetectionResult;
     }
 
-    virtual void scheduleContentIntent(const WebURL& url) override
+    void scheduleContentIntent(const WebURL& url) override
     {
         m_scheduledIntentURL = url;
     }
 
-    virtual void cancelScheduledContentIntents() override
+    void cancelScheduledContentIntents() override
     {
         m_pendingIntentsCancelled = true;
     }
 
     void reset()
     {
         m_contentDetectionRequested = false;
         m_pendingIntentsCancelled = false;
         m_scheduledIntentURL = WebURL();
         m_contentDetectionResult = WebContentDetectionResult();
@@ skipping 213 matching lines @@
     webViewImpl->handleInputEvent(event);
 }
 
 class MockAutofillClient : public WebAutofillClient {
 public:
     MockAutofillClient()
         : m_ignoreTextChanges(false)
         , m_textChangesFromUserGesture(0)
         , m_textChangesWhileIgnored(0)
         , m_textChangesWhileNotIgnored(0)
-        , m_userGestureNotificationsCount(0) { }
+        , m_userGestureNotificationsCount(0) {}
 
-    virtual ~MockAutofillClient() { }
+    ~MockAutofillClient() override {}
 
-    virtual void setIgnoreTextChanges(bool ignore) override { m_ignoreTextChanges = ignore; }
-    virtual void textFieldDidChange(const WebFormControlElement&) override
+    void setIgnoreTextChanges(bool ignore) override { m_ignoreTextChanges = ignore; }
+    void textFieldDidChange(const WebFormControlElement&) override
     {
         if (m_ignoreTextChanges)
             ++m_textChangesWhileIgnored;
         else
             ++m_textChangesWhileNotIgnored;
 
         if (UserGestureIndicator::processingUserGesture())
             ++m_textChangesFromUserGesture;
     }
-    virtual void firstUserGestureObserved() override { ++m_userGestureNotificationsCount; }
+    void firstUserGestureObserved() override { ++m_userGestureNotificationsCount; }
 
     void clearChangeCounts()
     {
         m_textChangesWhileIgnored = 0;
         m_textChangesWhileNotIgnored = 0;
     }
 
     int textChangesFromUserGesture() { return m_textChangesFromUserGesture; }
     int textChangesWhileIgnored() { return m_textChangesWhileIgnored; }
     int textChangesWhileNotIgnored() { return m_textChangesWhileNotIgnored; }
@@ skipping 164 matching lines @@
 }
 
 class ViewCreatingWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
     ViewCreatingWebViewClient()
         : m_didFocusCalled(false)
     {
     }
 
     // WebViewClient methods
-    virtual WebView* createView(WebLocalFrame*, const WebURLRequest&, const WebWindowFeatures&, const WebString& name, WebNavigationPolicy, bool) override
+    WebView* createView(WebLocalFrame*, const WebURLRequest&, const WebWindowFeatures&, const WebString& name, WebNavigationPolicy, bool) override
     {
         return m_webViewHelper.initialize(true, 0, 0);
     }
 
     // WebWidgetClient methods
-    virtual void didFocus() override
+    void didFocus() override
     {
         m_didFocusCalled = true;
     }
 
     bool didFocusCalled() const { return m_didFocusCalled; }
     WebView* createdWebView() const { return m_webViewHelper.webView(); }
 
 private:
     FrameTestHelpers::WebViewHelper m_webViewHelper;
     bool m_didFocusCalled;
@@ skipping 254 matching lines @@
     webView->layout();
     WebRect cropRect(0, 0, 100, 100);
     webView->extractSmartClipData(cropRect, clipText, clipHtml, clipRect);
     EXPECT_STREQ("", clipText.utf8().c_str());
     EXPECT_STREQ("", clipHtml.utf8().c_str());
 }
 
 class CreateChildCounterFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     CreateChildCounterFrameClient() : m_count(0) { }
-    virtual WebFrame* createChildFrame(WebLocalFrame* parent, WebTreeScopeType, const WebString& frameName, WebSandboxFlags) override;
+    WebFrame* createChildFrame(WebLocalFrame* parent, WebTreeScopeType, const WebString& frameName, WebSandboxFlags) override;
 
     int count() const { return m_count; }
 
 private:
     int m_count;
 };
 
 WebFrame* CreateChildCounterFrameClient::createChildFrame(WebLocalFrame* parent, WebTreeScopeType scope, const WebString& frameName, WebSandboxFlags sandboxFlags)
 {
     ++m_count;
@@ skipping 52 matching lines @@
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("add_frame_in_unload.html"));
     m_webViewHelper.initializeAndLoad(m_baseURL + "add_frame_in_unload_wrapper.html", true, &frameClient);
     FrameTestHelpers::loadFrame(m_webViewHelper.webView()->mainFrame(), "about:blank");
     EXPECT_EQ(1, frameClient.count());
     m_webViewHelper.reset();
 }
 
 class TouchEventHandlerWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
     // WebWidgetClient methods
-    virtual void hasTouchEventHandlers(bool state) override
+    void hasTouchEventHandlers(bool state) override
     {
         m_hasTouchEventHandlerCount[state]++;
     }
 
     // Local methods
     TouchEventHandlerWebViewClient() : m_hasTouchEventHandlerCount()
     {
     }
 
     int getAndResetHasTouchEventHandlerCallCount(bool state)
@@ skipping 157 matching lines @@
     Heap::collectAllGarbage();
 #endif
     EXPECT_FALSE(registry.hasEventHandlers(EventHandlerRegistry::ScrollEvent));
 }
 
 class NonUserInputTextUpdateWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
     NonUserInputTextUpdateWebViewClient() : m_textIsUpdated(false) { }
 
     // WebWidgetClient methods
-    virtual void didUpdateTextOfFocusedElementByNonUserInput() override
+    void didUpdateTextOfFocusedElementByNonUserInput() override
     {
         m_textIsUpdated = true;
     }
 
     void reset()
     {
         m_textIsUpdated = false;
     }
 
     bool textIsUpdated() const
@@ skipping 279 matching lines @@
     webView = m_webViewHelper.initializeAndLoad(url, true);
 
     webView->setZoomLevel(WebView::zoomFactorToZoomLevel(1));
     size = webView->contentsPreferredMinimumSize();
     EXPECT_EQ(2, size.width);
     EXPECT_EQ(2, size.height);
 }
 
 class UnhandledTapWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
-    virtual void showUnhandledTapUIIfNeeded(const WebPoint& tappedPosition, const WebNode& tappedNode, bool pageChanged) override
+    void showUnhandledTapUIIfNeeded(const WebPoint& tappedPosition, const WebNode& tappedNode, bool pageChanged) override
     {
         m_wasCalled = true;
         m_tappedPosition = tappedPosition;
         m_tappedNode = tappedNode;
         m_pageChanged = pageChanged;
     }
     bool getWasCalled() const { return m_wasCalled; }
     int getTappedXPos() const { return m_tappedPosition.x(); }
     int getTappedYPos() const { return m_tappedPosition.y(); }
     bool isTappedNodeNull() const { return m_tappedNode.isNull(); }
@@ skipping 388 matching lines @@
     for (size_t i = 0; i < renders.size(); ++i) {
         double docStartTime = frame->domWindow()->document()->loader()->timing().monotonicTimeToZeroBasedDocumentTime(renderPairs[i].startTime) * 1000.0;
         ASSERT_DOUBLE_EQ(docStartTime, renders[i]->startTime());
         double docFinishTime = frame->domWindow()->document()->loader()->timing().monotonicTimeToZeroBasedDocumentTime(renderPairs[i].finishTime) * 1000.0;
         double docDuration = docFinishTime - docStartTime;
         ASSERT_DOUBLE_EQ(docDuration, renders[i]->duration());
     }
 }
 
 } // namespace blink