Replace OVERRIDE and FINAL with override and final in WebKit/public

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 129 matching lines @@
         EXPECT_FLOAT_EQ((expected).x(), (actual).x()); \
         EXPECT_FLOAT_EQ((expected).y(), (actual).y()); \
     } while (false)
 
 #define EXPECT_EQ_POINT(a, b) \
     EXPECT_EQ(a.x(), b.x()); \
     EXPECT_EQ(a.y(), b.y());
 
 class FakeCompositingWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
-    virtual bool enterFullScreen() OVERRIDE { return true; }
+    virtual bool enterFullScreen() override { return true; }
 };
 
 class WebFrameTest : public testing::Test {
 protected:
     WebFrameTest()
         : m_baseURL("http://www.test.com/")
         , m_notBaseURL("http://www.nottest.com/")
         , m_chromeURL("chrome://")
     {
     }
@@ skipping 221 matching lines @@
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.body.textContent = location.href; void 0;");
 
     std::string content = webViewHelper.webView()->mainFrame()->contentAsText(1024).utf8();
     EXPECT_EQ("http://www.test.com:0/" + fileName, content);
 }
 
 class CSSCallbackWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     CSSCallbackWebFrameClient() : m_updateCount(0) { }
-    virtual void didMatchCSS(WebLocalFrame*, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors) OVERRIDE;
+    virtual 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 290 matching lines @@
     frame->domWindow()->postMessage(SerializedScriptValue::create("message"), 0, "*", frame->domWindow(), exceptionState);
     webViewHelper.reset();
     EXPECT_FALSE(exceptionState.hadException());
 
     // Success is not crashing.
     runPendingTasks();
 }
 
 class FixedLayoutTestWebViewClient : public FrameTestHelpers::TestWebViewClient {
  public:
-    virtual WebScreenInfo screenInfo() OVERRIDE { return m_screenInfo; }
+    virtual WebScreenInfo screenInfo() override { return m_screenInfo; }
 
     WebScreenInfo m_screenInfo;
 };
 
 // Viewport settings need to be set before the page gets loaded
 static void enableViewportSettings(WebSettings* settings)
 {
     settings->setViewportMetaEnabled(true);
     settings->setViewportEnabled(true);
     settings->setMainFrameResizesAreOrientationChanges(true);
@@ skipping 2268 matching lines @@
     // Horizontal scroll have to be the same
     EXPECT_NEAR(hScroll, scroll.x(), 1);
     vScroll = editBoxWithText.y - (viewportHeight / scale - editBoxWithText.height) / 2;
     EXPECT_NEAR(vScroll, scroll.y(), 1);
     // Page scale have to be unchanged
     EXPECT_EQ(newScale, scale);
 }
 
 class TestReloadDoesntRedirectWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
-    virtual WebNavigationPolicy decidePolicyForNavigation(const NavigationPolicyInfo& info) OVERRIDE
+    virtual WebNavigationPolicy decidePolicyForNavigation(const NavigationPolicyInfo& info) override
     {
         EXPECT_FALSE(info.isRedirect);
         return WebNavigationPolicyCurrentTab;
     }
 };
 
 TEST_F(WebFrameTest, 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;
     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
+    virtual void run() override
     {
         m_frame->reloadWithOverrideURL(m_url, m_ignoreCache);
     }
 
 private:
     WebFrame* const m_frame;
     const KURL m_url;
     const bool m_ignoreCache;
 };
 
@@ skipping 151 matching lines @@
             delete releaseNotifications[i];
 
         createNotifications.clear();
         releaseNotifications.clear();
     }
 
     std::vector<Notification*> createNotifications;
     std::vector<Notification*> releaseNotifications;
 
  private:
-    virtual void didCreateScriptContext(WebLocalFrame* frame, v8::Handle<v8::Context> context, int extensionGroup, int worldId) OVERRIDE
+    virtual void didCreateScriptContext(WebLocalFrame* frame, v8::Handle<v8::Context> context, int extensionGroup, int worldId) override
     {
         createNotifications.push_back(new Notification(frame, context, worldId));
     }
 
-    virtual void willReleaseScriptContext(WebLocalFrame* frame, v8::Handle<v8::Context> context, int worldId) OVERRIDE
+    virtual void willReleaseScriptContext(WebLocalFrame* frame, v8::Handle<v8::Context> context, int worldId) override
     {
         releaseNotifications.push_back(new Notification(frame, context, worldId));
     }
 };
 
 // TODO(aa): Deflake this test.
 TEST_F(WebFrameTest, 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::Handle<v8::Context> context, int extensionGroup, int worldId) OVERRIDE
+    virtual void didCreateScriptContext(WebLocalFrame* frame, v8::Handle<v8::Context> context, int extensionGroup, int worldId) override
     {
         frame->executeScript(WebScriptSource("window.history = 'replaced';"));
     }
 };
 
 TEST_F(WebFrameTest, ExecuteScriptDuringDidCreateScriptContext)
 {
     registerMockedHttpURLLoad("hello_world.html");
 
     TestExecuteScriptDuringDidCreateScriptContext webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper;
     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
+    virtual 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 697 matching lines @@
     EXPECT_EQ(startRect, initialStartRect);
     EXPECT_EQ(endRect, initialEndRect);
 }
 #endif
 
 class CompositedSelectionBoundsTestLayerTreeView : public WebLayerTreeView {
 public:
     CompositedSelectionBoundsTestLayerTreeView() : m_selectionCleared(false) { }
     virtual ~CompositedSelectionBoundsTestLayerTreeView() { }
 
-    virtual void setSurfaceReady()  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 bool commitRequested() const  OVERRIDE { return false; }
-    virtual void finishAllRendering()  OVERRIDE { }
-    virtual void registerSelection(const WebSelectionBound& start, const WebSelectionBound& end) OVERRIDE
+    virtual void setSurfaceReady()  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 bool commitRequested() const  override { return false; }
+    virtual void finishAllRendering()  override { }
+    virtual void registerSelection(const WebSelectionBound& start, const WebSelectionBound& end) override
     {
         m_start = adoptPtr(new WebSelectionBound(start));
         m_end = adoptPtr(new WebSelectionBound(end));
     }
-    virtual void clearSelection() OVERRIDE
+    virtual void clearSelection() override
     {
         m_selectionCleared = true;
         m_start.clear();
         m_end.clear();
     }
 
     bool getAndResetSelectionCleared()
     {
         bool selectionCleared  = m_selectionCleared;
         m_selectionCleared = false;
         return selectionCleared;
     }
 
     const WebSelectionBound* start() const { return m_start.get(); }
     const WebSelectionBound* end() const { return m_end.get(); }
 
 private:
     bool m_selectionCleared;
     OwnPtr<WebSelectionBound> m_start;
     OwnPtr<WebSelectionBound> m_end;
 };
 
 class CompositedSelectionBoundsTestWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
     virtual ~CompositedSelectionBoundsTestWebViewClient() { }
-    virtual WebLayerTreeView* layerTreeView() OVERRIDE { return &m_testLayerTreeView; }
+    virtual WebLayerTreeView* layerTreeView() override { return &m_testLayerTreeView; }
 
     CompositedSelectionBoundsTestLayerTreeView& selectionLayerTreeView() { return m_testLayerTreeView; }
 
 private:
     CompositedSelectionBoundsTestLayerTreeView m_testLayerTreeView;
 };
 
 class CompositedSelectionBoundsTest : public WebFrameTest {
 protected:
     CompositedSelectionBoundsTest()
@@ skipping 125 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
+    virtual 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 317 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
+    virtual void didCommitProvisionalLoad(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType) override
     {
         m_numBodies = 0;
         m_didLoad = true;
     }
 
-    virtual void didCreateDocumentElement(WebLocalFrame*) OVERRIDE
+    virtual void didCreateDocumentElement(WebLocalFrame*) override
     {
         EXPECT_EQ(0, m_numBodies);
     }
 
-    virtual void willInsertBody(WebLocalFrame*) OVERRIDE
+    virtual void willInsertBody(WebLocalFrame*) override
     {
         m_numBodies++;
     }
 
     int m_numBodies;
     bool m_didLoad;
 };
 
 TEST_F(WebFrameTest, HTMLDocument)
 {
@@ skipping 47 matching lines @@
     EXPECT_FALSE(transitionElement.isNull());
 
     // Check that the inline script was not executed.
     EXPECT_FALSE(transitionElement.hasAttribute("dir"));
 }
 
 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
+    virtual 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 121 matching lines @@
 
 class StubbornSpellCheckClient : public WebSpellCheckClient {
 public:
     StubbornSpellCheckClient() : m_completion(0) { }
     virtual ~StubbornSpellCheckClient() { }
 
     virtual void requestCheckingOfText(
         const WebString&,
         const WebVector<uint32_t>&,
         const WebVector<unsigned>&,
-        WebTextCheckingCompletion* completion) OVERRIDE
+        WebTextCheckingCompletion* completion) override
     {
         m_completion = completion;
     }
 
     void kickNoResults()
     {
         kick(-1, -1, WebTextDecorationTypeSpelling);
     }
 
     void kick()
@@ skipping 320 matching lines @@
     TestMainFrameUserOrProgrammaticScrollFrameClient() { reset(); }
     void reset()
     {
         m_didScrollMainFrame = false;
         m_wasProgrammaticScroll = false;
     }
     bool wasUserScroll() const { return m_didScrollMainFrame && !m_wasProgrammaticScroll; }
     bool wasProgrammaticScroll() const { return m_didScrollMainFrame && m_wasProgrammaticScroll; }
 
     // WebFrameClient:
-    virtual void didChangeScrollOffset(WebLocalFrame* frame) OVERRIDE
+    virtual void didChangeScrollOffset(WebLocalFrame* frame) override
     {
         if (frame->parent())
             return;
         EXPECT_FALSE(m_didScrollMainFrame);
         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_didScrollMainFrame = true;
@@ skipping 102 matching lines @@
     Platform::current()->unitTestSupport()->registerMockedURL(redirectURL, finalResponse, filePath);
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     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
+    virtual void didNavigateWithinPage(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType) override
     {
         EXPECT_TRUE(false);
     }
 };
 
 TEST_F(WebFrameTest, SimulateFragmentAnchorMiddleClick)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     TestNavigationPolicyWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true, &client);
 
     Document* document = toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->document();
     KURL destination = document->url();
     destination.setFragmentIdentifier("test");
 
     RefPtrWillBeRawPtr<Event> event = MouseEvent::create(EventTypeNames::click, false, false,
         document->domWindow(), 0, 0, 0, 0, 0, 0, 0, false, false, false, false, 1, nullptr, nullptr);
     FrameLoadRequest frameRequest(document, ResourceRequest(destination));
     frameRequest.setTriggeringEvent(event);
     toLocalFrame(webViewHelper.webViewImpl()->page()->mainFrame())->loader().load(frameRequest);
 }
 
 class TestNewWindowWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
     virtual WebView* createView(WebLocalFrame*, const WebURLRequest&, const WebWindowFeatures&,
-        const WebString&, WebNavigationPolicy, bool) OVERRIDE
+        const WebString&, WebNavigationPolicy, bool) override
     {
         EXPECT_TRUE(false);
         return 0;
     }
 };
 
 class TestNewWindowWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestNewWindowWebFrameClient()
         : m_decidePolicyCallCount(0)
     {
     }
 
-    virtual WebNavigationPolicy decidePolicyForNavigation(const NavigationPolicyInfo& info) OVERRIDE
+    virtual 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
+    virtual 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
+    virtual void didStartLoading(bool toDifferentDocument) override
     {
         TestWebFrameClient::didStartLoading(toDifferentDocument);
         m_startLoadingCount++;
         if (toDifferentDocument)
             m_differentDocumentStartCount++;
     }
 
-    virtual void didStopLoading() OVERRIDE
+    virtual 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
+    virtual void didNavigateWithinPage(WebLocalFrame*, const WebHistoryItem&, WebHistoryCommitType type) override
     {
         m_lastCommitType = type;
     }
 
     WebHistoryCommitType lastCommitType() const { return m_lastCommitType; }
 
 private:
     WebHistoryCommitType m_lastCommitType;
 };
 
@@ skipping 132 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, const WebString& frameName) OVERRIDE
+    virtual WebFrame* createChildFrame(WebLocalFrame* parent, const WebString& frameName) override
     {
         ++m_callCount;
         return 0;
     }
 
     int callCount() const { return m_callCount; }
 
 private:
     int m_callCount;
 };
@@ skipping 220 matching lines @@
     FrameTestHelpers::WebViewHelper webViewHelper;
     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
+    virtual void didChangeManifest(WebLocalFrame*) override
     {
         ++m_manifestChangeCount;
     }
 
     int manifestChangeCount() { return m_manifestChangeCount; }
 
 private:
     int m_manifestChangeCount;
 };
 
@@ skipping 379 matching lines @@
 
     // Manually reset to break WebViewHelper's dependency on the stack allocated
     // TestWebFrameClient.
     reset();
     remoteFrame->close();
 }
 
 class MockDocumentThreadableLoaderClient : public DocumentThreadableLoaderClient {
 public:
     MockDocumentThreadableLoaderClient() : m_failed(false) { }
-    virtual void didFail(const ResourceError&) OVERRIDE { m_failed = true;}
+    virtual 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 28 matching lines @@
     EXPECT_FALSE(client.failed());
 }
 
 class NavigationTransitionCallbackWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     NavigationTransitionCallbackWebFrameClient()
         : m_navigationalDataReceivedCount(0)
         , m_provisionalLoadCount(0)
         , m_wasLastProvisionalLoadATransition(false) { }
 
-    virtual void addNavigationTransitionData(const WebString& allowedDestinationOrigin, const WebString& selector, const WebString& markup) OVERRIDE
+    virtual void addNavigationTransitionData(const WebString& allowedDestinationOrigin, const WebString& selector, const WebString& markup) override
     {
         m_navigationalDataReceivedCount++;
     }
 
-    virtual void didStartProvisionalLoad(WebLocalFrame* localFrame, bool isTransitionNavigation) OVERRIDE
+    virtual void didStartProvisionalLoad(WebLocalFrame* localFrame, bool isTransitionNavigation) override
     {
         m_provisionalLoadCount++;
         m_wasLastProvisionalLoadATransition = isTransitionNavigation;
     }
 
     unsigned navigationalDataReceivedCount() const { return m_navigationalDataReceivedCount; }
     unsigned provisionalLoadCount() const { return m_provisionalLoadCount; }
     bool wasLastProvisionalLoadATransition() const { return m_wasLastProvisionalLoadATransition; }
 
 private:
@@ skipping 33 matching lines @@
     EXPECT_EQ(1u, frameClient.navigationalDataReceivedCount());
 
     // Neither should a page reload.
     localFrame->reload();
     EXPECT_EQ(4u, frameClient.provisionalLoadCount());
     EXPECT_FALSE(frameClient.wasLastProvisionalLoadATransition());
     EXPECT_EQ(1u, frameClient.navigationalDataReceivedCount());
 }
 
 } // namespace