Fix unit test style in Source/web/.

Source/web/tests/TextFinderTest.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
-
 #include "web/TextFinder.h"
 
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/dom/Document.h"
 #include "core/dom/NodeList.h"
 #include "core/dom/Range.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/html/HTMLElement.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/web/WebDocument.h"
 #include "web/FindInPageCoordinates.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 #include "wtf/OwnPtr.h"
 #include <gtest/gtest.h>
 
-using namespace blink;
 using blink::testing::runPendingTasks;
 
-namespace {
+namespace blink {
 
 class TextFinderTest : public ::testing::Test {
 protected:
-    virtual void SetUp() override;
+    void SetUp() override;
 
     Document& document() const;
     TextFinder& textFinder() const;
 
     static WebFloatRect findInPageRect(Node* startContainer, int startOffset, Node* endContainer, int endOffset);
 
 private:
     FrameTestHelpers::WebViewHelper m_webViewHelper;
     RefPtrWillBePersistent<Document> m_document;
     TextFinder* m_textFinder;
@@ skipping 27 matching lines @@
 
 TEST_F(TextFinderTest, FindTextSimple)
 {
     document().body()->setInnerHTML("XXXXFindMeYYYYfindmeZZZZ", ASSERT_NO_EXCEPTION);
     Node* textNode = document().body()->firstChild();
 
     int identifier = 0;
     WebString searchText(String("FindMe"));
     WebFindOptions findOptions; // Default.
     bool wrapWithinFrame = true;
-    WebRect* selectionRect = 0;
+    WebRect* selectionRect = nullptr;
 
     ASSERT_TRUE(textFinder().find(identifier, searchText, findOptions, wrapWithinFrame, selectionRect));
     Range* activeMatch = textFinder().activeMatch();
     ASSERT_TRUE(activeMatch);
     EXPECT_EQ(textNode, activeMatch->startContainer());
     EXPECT_EQ(4, activeMatch->startOffset());
     EXPECT_EQ(textNode, activeMatch->endContainer());
     EXPECT_EQ(10, activeMatch->endOffset());
 
     findOptions.findNext = true;
@@ skipping 47 matching lines @@
 }
 
 TEST_F(TextFinderTest, FindTextNotFound)
 {
     document().body()->setInnerHTML("XXXXFindMeYYYYfindmeZZZZ", ASSERT_NO_EXCEPTION);
 
     int identifier = 0;
     WebString searchText(String("Boo"));
     WebFindOptions findOptions; // Default.
     bool wrapWithinFrame = true;
-    WebRect* selectionRect = 0;
+    WebRect* selectionRect = nullptr;
 
     EXPECT_FALSE(textFinder().find(identifier, searchText, findOptions, wrapWithinFrame, selectionRect));
     EXPECT_FALSE(textFinder().activeMatch());
 }
 
 TEST_F(TextFinderTest, FindTextInShadowDOM)
 {
     document().body()->setInnerHTML("<b>FOO</b><i>foo</i>", ASSERT_NO_EXCEPTION);
     RefPtrWillBeRawPtr<ShadowRoot> shadowRoot = document().body()->createShadowRoot(ASSERT_NO_EXCEPTION);
     shadowRoot->setInnerHTML("<content select=\"i\"></content><u>Foo</u><content></content>", ASSERT_NO_EXCEPTION);
     Node* textInBElement = document().body()->firstChild()->firstChild();
     Node* textInIElement = document().body()->lastChild()->firstChild();
     Node* textInUElement = shadowRoot->childNodes()->item(1)->firstChild();
 
     int identifier = 0;
     WebString searchText(String("foo"));
     WebFindOptions findOptions; // Default.
     bool wrapWithinFrame = true;
-    WebRect* selectionRect = 0;
+    WebRect* selectionRect = nullptr;
 
     // TextIterator currently returns the matches in the document order, instead of the visual order. It visits
     // the shadow roots first, so in this case the matches will be returned in the order of <u> -> <b> -> <i>.
     ASSERT_TRUE(textFinder().find(identifier, searchText, findOptions, wrapWithinFrame, selectionRect));
     Range* activeMatch = textFinder().activeMatch();
     ASSERT_TRUE(activeMatch);
     EXPECT_EQ(textInUElement, activeMatch->startContainer());
     EXPECT_EQ(0, activeMatch->startOffset());
     EXPECT_EQ(textInUElement, activeMatch->endContainer());
     EXPECT_EQ(3, activeMatch->endOffset());
@@ skipping 177 matching lines @@
     WebVector<WebFloatRect> matchRects;
     textFinder().findMatchRects(matchRects);
     ASSERT_EQ(3u, matchRects.size());
     EXPECT_EQ(findInPageRect(textNode, 0, textNode, 2), matchRects[0]);
     EXPECT_EQ(findInPageRect(textNode, 2, textNode, 4), matchRects[1]);
     EXPECT_EQ(findInPageRect(textNode, 4, textNode, 6), matchRects[2]);
 }
 
 class TextFinderFakeTimerTest : public TextFinderTest {
 protected:
-    virtual void SetUp() override;
-    virtual void TearDown() override;
+    void SetUp() override;
+    void TearDown() override;
 
     // A simple platform that mocks out the clock.
     class TimeProxyPlatform : public Platform {
     public:
         TimeProxyPlatform()
             : m_timeCounter(0.)
             , m_fallbackPlatform(0)
         { }
 
         void install()
@@ skipping 16 matching lines @@
         }
 
     private:
         Platform& ensureFallback()
         {
             ASSERT(m_fallbackPlatform);
             return *m_fallbackPlatform;
         }
 
         // From blink::Platform:
-        virtual double currentTime() override
+        double currentTime() override
         {
             return ++m_timeCounter;
         }
 
         // These blink::Platform methods must be overriden to make a usable object.
-        virtual void cryptographicallyRandomValues(unsigned char* buffer, size_t length) override
+        void cryptographicallyRandomValues(unsigned char* buffer, size_t length) override
         {
             ensureFallback().cryptographicallyRandomValues(buffer, length);
         }
 
-        virtual const unsigned char* getTraceCategoryEnabledFlag(const char* categoryName) override
+        const unsigned char* getTraceCategoryEnabledFlag(const char* categoryName) override
         {
             return ensureFallback().getTraceCategoryEnabledFlag(categoryName);
         }
 
         // These two methods allow timers to work correctly.
-        virtual double monotonicallyIncreasingTime() override
+        double monotonicallyIncreasingTime() override
         {
             return ensureFallback().monotonicallyIncreasingTime();
         }
 
-        virtual WebThread* currentThread() override { return ensureFallback().currentThread(); }
-        virtual WebUnitTestSupport* unitTestSupport() override { return ensureFallback().unitTestSupport(); }
-        virtual WebString defaultLocale() override { return ensureFallback().defaultLocale(); }
-        virtual WebCompositorSupport* compositorSupport() override { return ensureFallback().compositorSupport(); }
+        WebThread* currentThread() override { return ensureFallback().currentThread(); }
+        WebUnitTestSupport* unitTestSupport() override { return ensureFallback().unitTestSupport(); }
+        WebString defaultLocale() override { return ensureFallback().defaultLocale(); }
+        WebCompositorSupport* compositorSupport() override { return ensureFallback().compositorSupport(); }
 
         double m_timeCounter;
         Platform* m_fallbackPlatform;
     };
 
     TimeProxyPlatform m_proxyTimePlatform;
 };
 
 void TextFinderFakeTimerTest::SetUp()
 {
@@ skipping 28 matching lines @@
 
     // There will be only one iteration before timeout, because increment
     // of the TimeProxyPlatform timer is greater than timeout threshold.
     textFinder().scopeStringMatches(identifier, searchPattern, findOptions, true);
     while (textFinder().scopingInProgress())
         runPendingTasks();
 
     EXPECT_EQ(4, textFinder().totalMatchCount());
 }
 
-} // namespace
+} // namespace blink