Reflow comments in core/dom/.

third_party/WebKit/Source/core/dom/ScriptRunnerTest.cpp

 // Copyright 2015 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 "core/dom/ScriptRunner.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ScriptLoader.h"
 #include "platform/heap/Handle.h"
@@ skipping 27 matching lines @@
       : ScriptLoader(element, false, false, false) {}
 };
 
 class ScriptRunnerTest : public testing::Test {
  public:
   ScriptRunnerTest()
       : m_document(Document::create()),
         m_element(m_document->createElement("foo", ASSERT_NO_EXCEPTION)) {}
 
   void SetUp() override {
-    // We have to create ScriptRunner after initializing platform, because we need
-    // Platform::current()->currentThread()->scheduler()->loadingTaskRunner()
-    // to be initialized before creating ScriptRunner to save it in constructor.
+    // We have to create ScriptRunner after initializing platform, because we
+    // need Platform::current()->currentThread()->scheduler()->
+    // loadingTaskRunner() to be initialized before creating ScriptRunner to
+    // save it in constructor.
     m_scriptRunner = ScriptRunner::create(m_document.get());
   }
 
   void TearDown() override { m_scriptRunner.release(); }
 
   Persistent<Document> m_document;
   Persistent<Element> m_element;
   TestingPlatformSupportWithMockScheduler m_platform;
   Persistent<ScriptRunner> m_scriptRunner;
   WTF::Vector<int> m_order;
@@ skipping 127 matching lines @@
   scriptLoader = scriptLoader3;
   EXPECT_CALL(*scriptLoader2, execute()).WillOnce(Invoke([scriptLoader, this] {
     m_order.append(2);
     m_scriptRunner->notifyScriptReady(scriptLoader, ScriptRunner::Async);
   }));
 
   EXPECT_CALL(*scriptLoader3, execute()).WillOnce(Invoke([this] {
     m_order.append(3);
   }));
 
-  // Make sure that re-entrant calls to notifyScriptReady don't cause ScriptRunner::execute to do
-  // more work than expected.
+  // Make sure that re-entrant calls to notifyScriptReady don't cause
+  // ScriptRunner::execute to do more work than expected.
   m_platform.runSingleTask();
   EXPECT_THAT(m_order, ElementsAre(1));
 
   m_platform.runSingleTask();
   EXPECT_THAT(m_order, ElementsAre(1, 2));
 
   m_platform.runSingleTask();
   EXPECT_THAT(m_order, ElementsAre(1, 2, 3));
 }
 
@@ skipping 24 matching lines @@
         m_order.append(2);
         m_scriptRunner->queueScriptForExecution(scriptLoader,
                                                 ScriptRunner::InOrder);
         m_scriptRunner->notifyScriptReady(scriptLoader3, ScriptRunner::InOrder);
       }));
 
   EXPECT_CALL(*scriptLoader3, execute()).WillOnce(Invoke([this] {
     m_order.append(3);
   }));
 
-  // Make sure that re-entrant calls to queueScriptForExecution don't cause ScriptRunner::execute to do
-  // more work than expected.
+  // Make sure that re-entrant calls to queueScriptForExecution don't cause
+  // ScriptRunner::execute to do more work than expected.
   m_platform.runSingleTask();
   EXPECT_THAT(m_order, ElementsAre(1));
 
   m_platform.runSingleTask();
   EXPECT_THAT(m_order, ElementsAre(1, 2));
 
   m_platform.runSingleTask();
   EXPECT_THAT(m_order, ElementsAre(1, 2, 3));
 }
 
@@ skipping 122 matching lines @@
   EXPECT_CALL(*scriptLoader1, execute()).WillOnce(Invoke([this] {
     m_order.append(1);
   }));
   EXPECT_CALL(*scriptLoader2, execute()).WillOnce(Invoke([this] {
     m_order.append(2);
   }));
 
   m_scriptRunner->notifyScriptReady(scriptLoader1, ScriptRunner::InOrder);
   m_platform.runUntilIdle();
 
-  // At this moment all tasks can be already executed. Make sure that we do not crash here.
+  // At this moment all tasks can be already executed. Make sure that we do not
+  // crash here.
   m_scriptRunner->notifyScriptReady(scriptLoader2, ScriptRunner::InOrder);
   m_platform.runUntilIdle();
 
   EXPECT_THAT(m_order, ElementsAre(1, 2));
 }
 
 TEST_F(ScriptRunnerTest, TasksWithDeadScriptRunner) {
   Persistent<MockScriptLoader> scriptLoader1 =
       MockScriptLoader::create(m_element.get());
   Persistent<MockScriptLoader> scriptLoader2 =
       MockScriptLoader::create(m_element.get());
 
   EXPECT_CALL(*scriptLoader1, isReady()).WillRepeatedly(Return(true));
   EXPECT_CALL(*scriptLoader2, isReady()).WillRepeatedly(Return(true));
 
   m_scriptRunner->queueScriptForExecution(scriptLoader1, ScriptRunner::Async);
   m_scriptRunner->queueScriptForExecution(scriptLoader2, ScriptRunner::Async);
 
   m_scriptRunner->notifyScriptReady(scriptLoader1, ScriptRunner::Async);
   m_scriptRunner->notifyScriptReady(scriptLoader2, ScriptRunner::Async);
 
   m_scriptRunner.release();
 
   ThreadState::current()->collectAllGarbage();
 
-  // m_scriptRunner is gone. We need to make sure that ScriptRunner::Task do not access dead object.
+  // m_scriptRunner is gone. We need to make sure that ScriptRunner::Task do not
+  // access dead object.
   EXPECT_CALL(*scriptLoader1, execute()).Times(0);
   EXPECT_CALL(*scriptLoader2, execute()).Times(0);
 
   m_platform.runUntilIdle();
 }
 
 }  // namespace blink