Pass WorkerClients into WorkerThreadForTest::StartWithSourceCode.

Also rearranges code so that WorkerThreadForTest can be defined in one
place instead of having to declare FakeWorkerGlobalScope in between. No
functional change is done here. Purley moving the code around.

Split from
https://chromium-review.googlesource.com/c/chromium/src/+/636684

Bug: 750311
Change-Id: Ic79600567401604651ad579542ee5aabbeb5fa5f
Reviewed-on: https://chromium-review.googlesource.com/691301
Commit-Queue: Alok Priyadarshi <alokp@chromium.org>
Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
Cr-Commit-Position: refs/heads/master@{#505299}

third_party/WebKit/Source/core/workers/WorkerThreadTestHelper.h

@@ -52,6 +52,31 @@ class MockWorkerThreadLifecycleObserver final
   MOCK_METHOD1(ContextDestroyed, void(WorkerThreadLifecycleContext*));
 };
 
+class FakeWorkerGlobalScope : public WorkerGlobalScope {
+ public:
+  FakeWorkerGlobalScope(const KURL& url,
+                        const String& user_agent,
+                        WorkerThread* thread,
+                        std::unique_ptr<SecurityOrigin::PrivilegeData>
+                            starter_origin_privilege_data,
+                        WorkerClients* worker_clients)
+      : WorkerGlobalScope(url,
+                          user_agent,
+                          thread,
+                          MonotonicallyIncreasingTime(),
+                          std::move(starter_origin_privilege_data),
+                          worker_clients) {}
+
+  ~FakeWorkerGlobalScope() override {}
+
+  // EventTarget
+  const AtomicString& InterfaceName() const override {
+    return EventTargetNames::DedicatedWorkerGlobalScope;
+  }
+
+  void ExceptionThrown(ErrorEvent*) override {}
+};
+
 class WorkerThreadForTest : public WorkerThread {
  public:
   WorkerThreadForTest(ThreadableLoadingContext* loading_context,
@@ -65,78 +90,50 @@ class WorkerThreadForTest : public WorkerThread {
   WorkerBackingThread& GetWorkerBackingThread() override {
     return *worker_backing_thread_;
   }
-  void ClearWorkerBackingThread() override { worker_backing_thread_ = nullptr; }
-
-  WorkerOrWorkletGlobalScope* CreateWorkerGlobalScope(
-      std::unique_ptr<GlobalScopeCreationParams>) override;
+  void ClearWorkerBackingThread() override { worker_backing_thread_.reset(); }
 
   void StartWithSourceCode(SecurityOrigin* security_origin,
                            const String& source,
-                           ParentFrameTaskRunners* parent_frame_task_runners) {
-    std::unique_ptr<Vector<CSPHeaderAndType>> headers =
-        WTF::MakeUnique<Vector<CSPHeaderAndType>>();
+                           ParentFrameTaskRunners* parent_frame_task_runners,
+                           WorkerClients* worker_clients = nullptr) {
+    auto headers = WTF::MakeUnique<Vector<CSPHeaderAndType>>();
     CSPHeaderAndType header_and_type("contentSecurityPolicy",
                                      kContentSecurityPolicyHeaderTypeReport);
     headers->push_back(header_and_type);
 
-    WorkerClients* clients = nullptr;
+    auto creation_params = WTF::MakeUnique<GlobalScopeCreationParams>(
+        KURL(kParsedURLString, "http://fake.url/"), "fake user agent", source,
+        nullptr, kDontPauseWorkerGlobalScopeOnStart, headers.get(), "",
+        security_origin, worker_clients, kWebAddressSpaceLocal, nullptr,
+        nullptr, kV8CacheOptionsDefault);
 
-    Start(WTF::MakeUnique<GlobalScopeCreationParams>(
-              KURL(kParsedURLString, "http://fake.url/"), "fake user agent",
-              source, nullptr, kDontPauseWorkerGlobalScopeOnStart,
-              headers.get(), "", security_origin, clients,
-              kWebAddressSpaceLocal, nullptr, nullptr, kV8CacheOptionsDefault),
+    Start(std::move(creation_params),
           WorkerBackingThreadStartupData::CreateDefault(),
           parent_frame_task_runners);
   }
 
   void WaitForInit() {
-    std::unique_ptr<WaitableEvent> completion_event =
-        WTF::MakeUnique<WaitableEvent>();
+    WaitableEvent completion_event;
     GetWorkerBackingThread().BackingThread().PostTask(
         BLINK_FROM_HERE,
         CrossThreadBind(&WaitableEvent::Signal,
-                        CrossThreadUnretained(completion_event.get())));
-    completion_event->Wait();
+                        CrossThreadUnretained(&completion_event)));
+    completion_event.Wait();
   }
 
- private:
-  std::unique_ptr<WorkerBackingThread> worker_backing_thread_;
-};
-
-class FakeWorkerGlobalScope : public WorkerGlobalScope {
- public:
-  FakeWorkerGlobalScope(const KURL& url,
-                        const String& user_agent,
-                        WorkerThreadForTest* thread,
-                        std::unique_ptr<SecurityOrigin::PrivilegeData>
-                            starter_origin_privilege_data,
-                        WorkerClients* worker_clients)
-      : WorkerGlobalScope(url,
-                          user_agent,
-                          thread,
-                          MonotonicallyIncreasingTime(),
-                          std::move(starter_origin_privilege_data),
-                          worker_clients) {}
-
-  ~FakeWorkerGlobalScope() override {}
-
-  // EventTarget
-  const AtomicString& InterfaceName() const override {
-    return EventTargetNames::DedicatedWorkerGlobalScope;
+ protected:
+  WorkerOrWorkletGlobalScope* CreateWorkerGlobalScope(
+      std::unique_ptr<GlobalScopeCreationParams> creation_params) override {
+    return new FakeWorkerGlobalScope(
+        creation_params->script_url, creation_params->user_agent, this,
+        std::move(creation_params->starter_origin_privilege_data),
+        std::move(creation_params->worker_clients));
   }
 
-  void ExceptionThrown(ErrorEvent*) override {}
+ private:
+  std::unique_ptr<WorkerBackingThread> worker_backing_thread_;
 };
 
-inline WorkerOrWorkletGlobalScope* WorkerThreadForTest::CreateWorkerGlobalScope(
-    std::unique_ptr<GlobalScopeCreationParams> creation_params) {
-  return new FakeWorkerGlobalScope(
-      creation_params->script_url, creation_params->user_agent, this,
-      std::move(creation_params->starter_origin_privilege_data),
-      std::move(creation_params->worker_clients));
-}
-
 }  // namespace blink
 
 #endif  // WorkerThreadTestHelper_h