Worker: Reflow comments in worker components

third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThreadTest.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 "modules/compositorworker/CompositorWorkerThread.h"
 
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
@@ skipping 13 matching lines @@
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAddressSpace.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 namespace {
 
-// A null InProcessWorkerObjectProxy, supplied when creating CompositorWorkerThreads.
+// A null InProcessWorkerObjectProxy, supplied when creating
+// CompositorWorkerThreads.
 class TestCompositorWorkerObjectProxy : public InProcessWorkerObjectProxy {
  public:
   static std::unique_ptr<TestCompositorWorkerObjectProxy> create(
       ExecutionContext* context) {
     return wrapUnique(new TestCompositorWorkerObjectProxy(context));
   }
 
   // (Empty) WorkerReportingProxy implementation:
   virtual void dispatchErrorEvent(const String& errorMessage,
                                   std::unique_ptr<SourceLocation>,
@@ skipping 111 matching lines @@
   CompositorWorkerTestPlatform m_testPlatform;
 };
 
 TEST_F(CompositorWorkerThreadTest, Basic) {
   std::unique_ptr<CompositorWorkerThread> compositorWorker =
       createCompositorWorker();
   checkWorkerCanExecuteScript(compositorWorker.get());
   compositorWorker->terminateAndWait();
 }
 
-// Tests that the same WebThread is used for new workers if the WebThread is still alive.
+// Tests that the same WebThread is used for new workers if the WebThread is
+// still alive.
 TEST_F(CompositorWorkerThreadTest, CreateSecondAndTerminateFirst) {
   // Create the first worker and wait until it is initialized.
   std::unique_ptr<CompositorWorkerThread> firstWorker =
       createCompositorWorker();
   WebThreadSupportingGC* firstThread =
       &firstWorker->workerBackingThread().backingThread();
   checkWorkerCanExecuteScript(firstWorker.get());
   v8::Isolate* firstIsolate = firstWorker->isolate();
   ASSERT_TRUE(firstIsolate);
 
   // Create the second worker and immediately destroy the first worker.
   std::unique_ptr<CompositorWorkerThread> secondWorker =
       createCompositorWorker();
   // We don't use terminateAndWait here to avoid forcible termination.
   firstWorker->terminate();
   firstWorker->waitForShutdownForTesting();
 
-  // Wait until the second worker is initialized. Verify that the second worker is using the same
-  // thread and Isolate as the first worker.
+  // Wait until the second worker is initialized. Verify that the second worker
+  // is using the same thread and Isolate as the first worker.
   WebThreadSupportingGC* secondThread =
       &secondWorker->workerBackingThread().backingThread();
   ASSERT_EQ(firstThread, secondThread);
 
   v8::Isolate* secondIsolate = secondWorker->isolate();
   ASSERT_TRUE(secondIsolate);
   EXPECT_EQ(firstIsolate, secondIsolate);
 
   // Verify that the worker can still successfully execute script.
   checkWorkerCanExecuteScript(secondWorker.get());
 
   secondWorker->terminateAndWait();
 }
 
-// Tests that a new WebThread is created if all existing workers are terminated before a new worker is created.
+// Tests that a new WebThread is created if all existing workers are terminated
+// before a new worker is created.
 TEST_F(CompositorWorkerThreadTest, TerminateFirstAndCreateSecond) {
   // Create the first worker, wait until it is initialized, and terminate it.
   std::unique_ptr<CompositorWorkerThread> compositorWorker =
       createCompositorWorker();
   WebThreadSupportingGC* firstThread =
       &compositorWorker->workerBackingThread().backingThread();
   checkWorkerCanExecuteScript(compositorWorker.get());
 
   // We don't use terminateAndWait here to avoid forcible termination.
   compositorWorker->terminate();
   compositorWorker->waitForShutdownForTesting();
 
   // Create the second worker. The backing thread is same.
   compositorWorker = createCompositorWorker();
   WebThreadSupportingGC* secondThread =
       &compositorWorker->workerBackingThread().backingThread();
   EXPECT_EQ(firstThread, secondThread);
   checkWorkerCanExecuteScript(compositorWorker.get());
 
   compositorWorker->terminateAndWait();
 }
 
-// Tests that v8::Isolate and WebThread are correctly set-up if a worker is created while another is terminating.
+// Tests that v8::Isolate and WebThread are correctly set-up if a worker is
+// created while another is terminating.
 TEST_F(CompositorWorkerThreadTest, CreatingSecondDuringTerminationOfFirst) {
   std::unique_ptr<CompositorWorkerThread> firstWorker =
       createCompositorWorker();
   checkWorkerCanExecuteScript(firstWorker.get());
   v8::Isolate* firstIsolate = firstWorker->isolate();
   ASSERT_TRUE(firstIsolate);
 
   // Request termination of the first worker and create the second worker
   // as soon as possible.
   firstWorker->terminate();
   // We don't wait for its termination.
   // Note: We rely on the assumption that the termination steps don't run
   // on the worker thread so quickly. This could be a source of flakiness.
 
   std::unique_ptr<CompositorWorkerThread> secondWorker =
       createCompositorWorker();
 
   v8::Isolate* secondIsolate = secondWorker->isolate();
   ASSERT_TRUE(secondIsolate);
   EXPECT_EQ(firstIsolate, secondIsolate);
 
-  // Verify that the isolate can run some scripts correctly in the second worker.
+  // Verify that the isolate can run some scripts correctly in the second
+  // worker.
   checkWorkerCanExecuteScript(secondWorker.get());
   secondWorker->terminateAndWait();
 }
 
 }  // namespace blink