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

Source/web/tests/WebFrameTest.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:
  *
  *     * 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 158 matching lines @@
 
 class WebFrameTest : public ::testing::Test {
 protected:
     WebFrameTest()
         : m_baseURL("http://internal.test/")
         , m_notBaseURL("http://external.test/")
         , m_chromeURL("chrome://")
     {
     }
 
-    virtual ~WebFrameTest()
+    ~WebFrameTest() override
     {
         Platform::current()->unitTestSupport()->unregisterAllMockedURLs();
     }
 
     void registerMockedHttpURLLoad(const std::string& fileName)
     {
         URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8(fileName.c_str()));
     }
 
     void registerMockedChromeURLLoad(const std::string& fileName)
@@ skipping 71 matching lines @@
     Default,
     RootLayerScrolls
 };
 
 class ParameterizedWebFrameTest
     : public WebFrameTest
     , public ::testing::WithParamInterface<ParameterizedWebFrameTestConfig>
     , public FrameTestHelpers::SettingOverrider {
 public:
 
-    virtual void overrideSettings(WebSettings* settings)
+    void overrideSettings(WebSettings* settings)
     {
         switch (GetParam()) {
         case Default:
             break;
         case RootLayerScrolls:
             settings->setRootLayerScrolls(true);
             break;
         }
     }
 };
@@ skipping 244 matching lines @@
 {
     EvaluateOnLoadWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad("about:blank", true, &webFrameClient);
     EXPECT_TRUE(webFrameClient.m_wasExecuted);
 }
 
 class CSSCallbackWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     CSSCallbackWebFrameClient() : m_updateCount(0) { }
-    virtual void didMatchCSS(WebLocalFrame*, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors) override;
+    void didMatchCSS(WebLocalFrame*, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors) override;
 
     std::map<WebLocalFrame*, std::set<std::string>> m_matchedSelectors;
     int m_updateCount;
 };
 
 void CSSCallbackWebFrameClient::didMatchCSS(WebLocalFrame* frame, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors)
 {
     ++m_updateCount;
     std::set<std::string>& frameSelectors = m_matchedSelectors[frame];
     for (size_t i = 0; i < newlyMatchingSelectors.size(); ++i) {
@@ skipping 291 matching lines @@
     EXPECT_FALSE(exceptionState.hadException());
 
     // Success is not crashing.
     runPendingTasks();
 }
 
 namespace {
 
 class FixedLayoutTestWebViewClient : public FrameTestHelpers::TestWebViewClient {
  public:
-    virtual WebScreenInfo screenInfo() override { return m_screenInfo; }
+    WebScreenInfo screenInfo() override { return m_screenInfo; }
 
     WebScreenInfo m_screenInfo;
 };
 
 class FakeCompositingWebViewClient : public FixedLayoutTestWebViewClient {
 };
 
 // Viewport settings need to be set before the page gets loaded
 void enableViewportSettings(WebSettings* settings)
 {
@@ skipping 2307 matching lines @@
     WebRect rect;
     mainFrame->firstRectForCharacterRange(0, 5, rect);
 
     EXPECT_EQ((oldRect.x - pinchOffset.x) * scale, rect.x);
     EXPECT_EQ((oldRect.y - pinchOffset.y) * scale, rect.y);
     EXPECT_EQ(oldRect.width*scale, rect.width);
     EXPECT_EQ(oldRect.height*scale, rect.height);
 }
 class TestReloadDoesntRedirectWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
-    virtual WebNavigationPolicy decidePolicyForNavigation(const NavigationPolicyInfo& info) override
+    WebNavigationPolicy decidePolicyForNavigation(const NavigationPolicyInfo& info) override
     {
         EXPECT_FALSE(info.isRedirect);
         return WebNavigationPolicyCurrentTab;
     }
 };
 
 TEST_P(ParameterizedWebFrameTest, ReloadDoesntSetRedirect)
 {
     // Test for case in http://crbug.com/73104. Reloading a frame very quickly
     // would sometimes call decidePolicyForNavigation with isRedirect=true
     registerMockedHttpURLLoad("form.html");
 
     TestReloadDoesntRedirectWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "form.html", false, &webFrameClient);
 
     webViewHelper.webView()->mainFrame()->reload(true);
     // start another reload before request is delivered.
     FrameTestHelpers::reloadFrameIgnoringCache(webViewHelper.webView()->mainFrame());
 }
 
 class ReloadWithOverrideURLTask : public WebThread::Task {
 public:
     ReloadWithOverrideURLTask(WebFrame* frame, const KURL& url, bool ignoreCache)
         : m_frame(frame), m_url(url), m_ignoreCache(ignoreCache)
     {
     }
 
-    virtual void run() override
+    void run() override
     {
         m_frame->reloadWithOverrideURL(m_url, m_ignoreCache);
     }
 
 private:
     WebFrame* const m_frame;
     const KURL m_url;
     const bool m_ignoreCache;
 };
 
@@ skipping 149 matching lines @@
         bool Equals(Notification* other)
         {
             return other && frame == other->frame && context == other->context && worldId == other->worldId;
         }
 
         WebLocalFrame* frame;
         v8::Persistent<v8::Context> context;
         int worldId;
     };
 
-    virtual ~ContextLifetimeTestWebFrameClient()
+    ~ContextLifetimeTestWebFrameClient() override
     {
         reset();
     }
 
     void reset()
     {
         for (size_t i = 0; i < createNotifications.size(); ++i)
             delete createNotifications[i];
 
         for (size_t i = 0; i < releaseNotifications.size(); ++i)
             delete releaseNotifications[i];
 
         createNotifications.clear();
         releaseNotifications.clear();
     }
 
     std::vector<Notification*> createNotifications;
     std::vector<Notification*> releaseNotifications;
 
  private:
-    virtual void didCreateScriptContext(WebLocalFrame* frame, v8::Local<v8::Context> context, int extensionGroup, int worldId) override
+    void didCreateScriptContext(WebLocalFrame* frame, v8::Local<v8::Context> context, int extensionGroup, int worldId) override
     {
         createNotifications.push_back(new Notification(frame, context, worldId));
     }
 
-    virtual void willReleaseScriptContext(WebLocalFrame* frame, v8::Local<v8::Context> context, int worldId) override
+    void willReleaseScriptContext(WebLocalFrame* frame, v8::Local<v8::Context> context, int worldId) override
     {
         releaseNotifications.push_back(new Notification(frame, context, worldId));
     }
 };
 
 // TODO(aa): Deflake this test.
 TEST_P(ParameterizedWebFrameTest, FLAKY_ContextNotificationsLoadUnload)
 {
     v8::HandleScope handleScope(v8::Isolate::GetCurrent());
 
@@ skipping 242 matching lines @@
     frame->executeCommand(WebString::fromUTF8("SelectAll"));
     EXPECT_TRUE(frame->hasSelection());
     frame->executeCommand(WebString::fromUTF8("Unselect"));
     EXPECT_FALSE(frame->hasSelection());
     WebString selectionHtml = frame->selectionAsMarkup();
     EXPECT_TRUE(selectionHtml.isEmpty());
 }
 
 class TestExecuteScriptDuringDidCreateScriptContext : public FrameTestHelpers::TestWebFrameClient {
 public:
-    virtual void didCreateScriptContext(WebLocalFrame* frame, v8::Local<v8::Context> context, int extensionGroup, int worldId) override
+    void didCreateScriptContext(WebLocalFrame* frame, v8::Local<v8::Context> context, int extensionGroup, int worldId) override
     {
         frame->executeScript(WebScriptSource("window.history = 'replaced';"));
     }
 };
 
 TEST_P(ParameterizedWebFrameTest, ExecuteScriptDuringDidCreateScriptContext)
 {
     registerMockedHttpURLLoad("hello_world.html");
 
     TestExecuteScriptDuringDidCreateScriptContext webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "hello_world.html", true, &webFrameClient);
 
     FrameTestHelpers::reloadFrame(webViewHelper.webView()->mainFrame());
 }
 
 class FindUpdateWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     FindUpdateWebFrameClient()
         : m_findResultsAreReady(false)
         , m_count(-1)
     {
     }
 
-    virtual void reportFindInPageMatchCount(int, int count, bool finalUpdate) override
+    void reportFindInPageMatchCount(int, int count, bool finalUpdate) override
     {
         m_count = count;
         if (finalUpdate)
             m_findResultsAreReady = true;
     }
 
     bool findResultsAreReady() const { return m_findResultsAreReady; }
     int count() const { return m_count; }
 
 private:
@@ skipping 770 matching lines @@
     frame->moveCaretSelection(moveTo);
     webViewHelper.webView()->selectionBounds(startRect, endRect);
     EXPECT_EQ(startRect, initialStartRect);
     EXPECT_EQ(endRect, initialEndRect);
 }
 #endif
 
 class CompositedSelectionBoundsTestLayerTreeView : public WebLayerTreeView {
 public:
     CompositedSelectionBoundsTestLayerTreeView() : m_selectionCleared(false) { }
-    virtual ~CompositedSelectionBoundsTestLayerTreeView() { }
+    ~CompositedSelectionBoundsTestLayerTreeView() override { }
 
-    virtual void setRootLayer(const WebLayer&)  override { }
-    virtual void clearRootLayer()  override { }
-    virtual void setViewportSize(const WebSize& deviceViewportSize)  override { }
-    virtual WebSize deviceViewportSize() const  override { return WebSize(); }
-    virtual void setDeviceScaleFactor(float) override { }
-    virtual float deviceScaleFactor() const  override { return 1.f; }
-    virtual void setBackgroundColor(WebColor)  override { }
-    virtual void setHasTransparentBackground(bool)  override { }
-    virtual void setVisible(bool)  override { }
-    virtual void setPageScaleFactorAndLimits(float pageScaleFactor, float minimum, float maximum)  override { }
-    virtual void startPageScaleAnimation(const WebPoint& destination, bool useAnchor, float newPageScale, double durationSec)  override { }
-    virtual void setNeedsAnimate()  override { }
-    virtual void finishAllRendering()  override { }
-    virtual void registerSelection(const WebSelection& selection) override
+    void setRootLayer(const WebLayer&)  override { }
+    void clearRootLayer()  override { }
+    void setViewportSize(const WebSize& deviceViewportSize)  override { }
+    WebSize deviceViewportSize() const  override { return WebSize(); }
+    void setDeviceScaleFactor(float) override { }
+    float deviceScaleFactor() const  override { return 1.f; }
+    void setBackgroundColor(WebColor)  override { }
+    void setHasTransparentBackground(bool)  override { }
+    void setVisible(bool)  override { }
+    void setPageScaleFactorAndLimits(float pageScaleFactor, float minimum, float maximum)  override { }
+    void startPageScaleAnimation(const WebPoint& destination, bool useAnchor, float newPageScale, double durationSec)  override { }
+    void setNeedsAnimate()  override { }
+    void finishAllRendering()  override { }
+    void registerSelection(const WebSelection& selection) override
     {
         m_selection = adoptPtr(new WebSelection(selection));
     }
-    virtual void clearSelection() override
+    void clearSelection() override
     {
         m_selectionCleared = true;
         m_selection.clear();
     }
 
     bool getAndResetSelectionCleared()
     {
         bool selectionCleared  = m_selectionCleared;
         m_selectionCleared = false;
         return selectionCleared;
     }
 
     const WebSelection* selection() const { return m_selection.get(); }
     const WebSelectionBound* start() const { return m_selection ? &m_selection->start() : nullptr; }
     const WebSelectionBound* end() const { return m_selection ? &m_selection->end() : nullptr; }
 
 private:
     bool m_selectionCleared;
     OwnPtr<WebSelection> m_selection;
 };
 
 class CompositedSelectionBoundsTestWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
-    virtual ~CompositedSelectionBoundsTestWebViewClient() { }
-    virtual WebLayerTreeView* layerTreeView() override { return &m_testLayerTreeView; }
+    ~CompositedSelectionBoundsTestWebViewClient() override {}
+    WebLayerTreeView* layerTreeView() override { return &m_testLayerTreeView; }
 
     CompositedSelectionBoundsTestLayerTreeView& selectionLayerTreeView() { return m_testLayerTreeView; }
 
 private:
     CompositedSelectionBoundsTestLayerTreeView m_testLayerTreeView;
 };
 
 class CompositedSelectionBoundsTest : public WebFrameTest {
 protected:
     CompositedSelectionBoundsTest()
@@ skipping 153 matching lines @@
 
     frame = webViewHelper.webView()->mainFrame();
     frame->executeCommand(WebString::fromUTF8("Unselect"));
     webViewHelper.webView()->layout();
     ASSERT_FALSE(frame->hasSelection());
     EXPECT_TRUE(fakeSelectionLayerTreeView.getAndResetSelectionCleared());
 }
 
 class DisambiguationPopupTestWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
-    virtual bool didTapMultipleTargets(const WebSize&, const WebRect&, const WebVector<WebRect>& targetRects) override
+    bool didTapMultipleTargets(const WebSize&, const WebRect&, const WebVector<WebRect>& targetRects) override
     {
         EXPECT_GE(targetRects.size(), 2u);
         m_triggered = true;
         return true;
     }
 
     bool triggered() const { return m_triggered; }
     void resetTriggered() { m_triggered = false; }
     bool m_triggered;
 };
@@ skipping 326 matching lines @@
     EXPECT_EQ("This should appear", text.utf8());
     EXPECT_TRUE(webFrameClient.commitCalled());
 }
 
 class TestWillInsertBodyWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestWillInsertBodyWebFrameClient() : m_numBodies(0), m_didLoad(false)
     {
     }
 
-    virtual void didCommitProvisionalLoad(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType) override
+    void didCommitProvisionalLoad(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType) override
     {
         m_numBodies = 0;
         m_didLoad = true;
     }
 
-    virtual void didCreateDocumentElement(WebLocalFrame*) override
+    void didCreateDocumentElement(WebLocalFrame*) override
     {
         EXPECT_EQ(0, m_numBodies);
     }
 
-    virtual void willInsertBody(WebLocalFrame*) override
+    void willInsertBody(WebLocalFrame*) override
     {
         m_numBodies++;
     }
 
     int m_numBodies;
     bool m_didLoad;
 };
 
 TEST_P(ParameterizedWebFrameTest, HTMLDocument)
 {
@@ skipping 26 matching lines @@
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // This test passes if this doesn't crash.
     frame->moveCaretSelection(WebPoint(0, 0));
 }
 
 class SpellCheckClient : public WebSpellCheckClient {
 public:
     explicit SpellCheckClient(uint32_t hash = 0) : m_numberOfTimesChecked(0), m_hash(hash) { }
     virtual ~SpellCheckClient() { }
-    virtual void requestCheckingOfText(const WebString&, const WebVector<uint32_t>&, const WebVector<unsigned>&, WebTextCheckingCompletion* completion) override
+    void requestCheckingOfText(const WebString&, const WebVector<uint32_t>&, const WebVector<unsigned>&, WebTextCheckingCompletion* completion) override
     {
         ++m_numberOfTimesChecked;
         Vector<WebTextCheckingResult> results;
         const int misspellingStartOffset = 1;
         const int misspellingLength = 8;
         results.append(WebTextCheckingResult(WebTextDecorationTypeSpelling, misspellingStartOffset, misspellingLength, WebString(), m_hash));
         completion->didFinishCheckingText(results);
     }
     int numberOfTimesChecked() const { return m_numberOfTimesChecked; }
 private:
@@ skipping 479 matching lines @@
 class TestScrolledFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestScrolledFrameClient() { reset(); }
     void reset()
     {
         m_didScrollFrame = false;
     }
     bool wasFrameScrolled() const { return m_didScrollFrame; }
 
     // WebFrameClient:
-    virtual void didChangeScrollOffset(WebLocalFrame* frame) override
+    void didChangeScrollOffset(WebLocalFrame* frame) override
     {
         if (frame->parent())
             return;
         EXPECT_FALSE(m_didScrollFrame);
         FrameView* view = toWebLocalFrameImpl(frame)->frameView();
         // FrameView can be scrolled in FrameView::setFixedVisibleContentRect
         // which is called from LocalFrame::createView (before the frame is associated
         // with the the view).
         if (view)
             m_didScrollFrame = true;
@@ skipping 82 matching lines @@
     Platform::current()->unitTestSupport()->registerMockedURL(redirectURL, finalResponse, filePath);
 
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     webViewHelper.initializeAndLoad(m_baseURL + "first_party_redirect.html", true);
     EXPECT_TRUE(webViewHelper.webView()->mainFrame()->document().firstPartyForCookies() == redirectURL);
 }
 
 class TestNavigationPolicyWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
 
-    virtual void didNavigateWithinPage(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType) override
+    void didNavigateWithinPage(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType) override
     {
         EXPECT_TRUE(false);
     }
 };
 
 TEST_P(ParameterizedWebFrameTest, SimulateFragmentAnchorMiddleClick)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     TestNavigationPolicyWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper(this);
@@ skipping 20 matching lines @@
     }
 };
 
 class TestNewWindowWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestNewWindowWebFrameClient()
         : m_decidePolicyCallCount(0)
     {
     }
 
-    virtual WebNavigationPolicy decidePolicyForNavigation(const NavigationPolicyInfo& info) override
+    WebNavigationPolicy decidePolicyForNavigation(const NavigationPolicyInfo& info) override
     {
         m_decidePolicyCallCount++;
         return info.defaultPolicy;
     }
 
     int decidePolicyCallCount() const { return m_decidePolicyCallCount; }
 
 private:
     int m_decidePolicyCallCount;
 };
@@ skipping 145 matching lines @@
 
     virtual void didStopLoading()
     {
         if (m_parentClient) {
             m_parentClient->didStopLoading();
             return;
         }
         TestWebFrameClient::didStopLoading();
     }
 
-    virtual void willSendRequest(WebLocalFrame* frame, unsigned, WebURLRequest& request, const WebURLResponse&) override
+    void willSendRequest(WebLocalFrame* frame, unsigned, WebURLRequest& request, const WebURLResponse&) override
     {
         m_policy = request.cachePolicy();
         m_willSendRequestCallCount++;
     }
 
 private:
     TestCachePolicyWebFrameClient* m_parentClient;
 
     WebURLRequest::CachePolicy m_policy;
     TestCachePolicyWebFrameClient* m_childClient;
@@ skipping 127 matching lines @@
 
 class TestStartStopCallbackWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestStartStopCallbackWebFrameClient()
         : m_startLoadingCount(0)
         , m_stopLoadingCount(0)
         , m_differentDocumentStartCount(0)
     {
     }
 
-    virtual void didStartLoading(bool toDifferentDocument) override
+    void didStartLoading(bool toDifferentDocument) override
     {
         TestWebFrameClient::didStartLoading(toDifferentDocument);
         m_startLoadingCount++;
         if (toDifferentDocument)
             m_differentDocumentStartCount++;
     }
 
-    virtual void didStopLoading() override
+    void didStopLoading() override
     {
         TestWebFrameClient::didStopLoading();
         m_stopLoadingCount++;
     }
 
     int startLoadingCount() const { return m_startLoadingCount; }
     int stopLoadingCount() const { return m_stopLoadingCount; }
     int differentDocumentStartCount() const { return m_differentDocumentStartCount; }
 
 private:
@@ skipping 14 matching lines @@
     EXPECT_EQ(client.differentDocumentStartCount(), 1);
 }
 
 class TestDidNavigateCommitTypeWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestDidNavigateCommitTypeWebFrameClient()
         : m_lastCommitType(WebHistoryInertCommit)
     {
     }
 
-    virtual void didNavigateWithinPage(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType type) override
+    void didNavigateWithinPage(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType type) override
     {
         m_lastCommitType = type;
     }
 
     WebHistoryCommitType lastCommitType() const { return m_lastCommitType; }
 
 private:
     WebHistoryCommitType m_lastCommitType;
 };
 
@@ skipping 150 matching lines @@
     // After commit, there is.
     HistoryItem* item = mainFrameLoader.currentItem();
     ASSERT_TRUE(item);
     EXPECT_EQ(WTF::String(url.data()), item->urlString());
 }
 
 class FailCreateChildFrame : public FrameTestHelpers::TestWebFrameClient {
 public:
     FailCreateChildFrame() : m_callCount(0) { }
 
-    virtual WebFrame* createChildFrame(WebLocalFrame* parent, WebTreeScopeType scope, const WebString& frameName, WebSandboxFlags sandboxFlags) override
+    WebFrame* createChildFrame(WebLocalFrame* parent, WebTreeScopeType scope, const WebString& frameName, WebSandboxFlags sandboxFlags) override
     {
         ++m_callCount;
         return 0;
     }
 
     int callCount() const { return m_callCount; }
 
 private:
     int m_callCount;
 };
@@ skipping 410 matching lines @@
     FrameTestHelpers::WebViewHelper webViewHelper(this);
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "hidden_frames.html");
     for (WebFrame* frame = webViewImpl->mainFrameImpl()->traverseNext(false); frame; frame = frame->traverseNext(false)) {
         EXPECT_FALSE(frame->hasVisibleContent());
     }
 }
 
 class ManifestChangeWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     ManifestChangeWebFrameClient() : m_manifestChangeCount(0) { }
-    virtual void didChangeManifest(WebLocalFrame*) override
+    void didChangeManifest(WebLocalFrame*) override
     {
         ++m_manifestChangeCount;
     }
 
     int manifestChangeCount() { return m_manifestChangeCount; }
 
 private:
     int m_manifestChangeCount;
 };
 
@@ skipping 69 matching lines @@
 
     ResourcePtr<Resource> resource = fetchManifest(document, toKURL(m_notBaseURL + "link-manifest-fetch.json"));
 
     EXPECT_TRUE(resource->isLoaded());
 }
 
 
 class DefaultPresentationChangeWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     DefaultPresentationChangeWebFrameClient() : m_defaultPresentationChangeCount(0) { }
-    virtual void didChangeDefaultPresentation(WebLocalFrame*) override
+    void didChangeDefaultPresentation(WebLocalFrame*) override
     {
         ++m_defaultPresentationChangeCount;
     }
 
     int defaultPresentationChangeCount() { return m_defaultPresentationChangeCount; }
 
 private:
     int m_defaultPresentationChangeCount;
 };
 
@@ skipping 730 matching lines @@
     WebLocalFrame* childFrame = view->mainFrame()->toWebRemoteFrame()->createLocalChild(WebTreeScopeType::Document, "", WebSandboxFlags::None, &childFrameClient, nullptr);
     registerMockedHttpURLLoad("foo.html");
     FrameTestHelpers::loadFrame(childFrame, m_baseURL + "foo.html");
     EXPECT_EQ(WebInitialCommitInChildFrame, childFrameClient.historyCommitType());
     view->close();
 }
 
 class MockDocumentThreadableLoaderClient : public DocumentThreadableLoaderClient {
 public:
     MockDocumentThreadableLoaderClient() : m_failed(false) { }
-    virtual void didFail(const ResourceError&) override { m_failed = true;}
+    void didFail(const ResourceError&) override { m_failed = true;}
 
     void reset() { m_failed = false; }
     bool failed() { return m_failed; }
 
     bool m_failed;
 };
 
 // FIXME: This would be better as a unittest on DocumentThreadableLoader but it
 // requires spin-up of a frame. It may be possible to remove that requirement
 // and convert it to a unittest.
@@ skipping 396 matching lines @@
 
 TEST_F(WebFrameTest, MaxFramesDetach)
 {
     registerMockedHttpURLLoad("max-frames-detach.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "max-frames-detach.html", true);
     webViewImpl->mainFrameImpl()->collectGarbage();
 }
 
 } // namespace blink