Worker: Remove cross-thread PostTask functions from WorkerLoaderProxy

third_party/WebKit/Source/web/WebSharedWorkerImpl.cpp

 /*
  * Copyright (C) 2009 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 223 matching lines @@
   TerminateWorkerThread();
 }
 
 void WebSharedWorkerImpl::DidTerminateWorkerThread() {
   DCHECK(IsMainThread());
   client_->WorkerContextDestroyed();
   // The lifetime of this proxy is controlled by the worker context.
   delete this;
 }
 
 // WorkerLoaderProxyProvider -------------------------------------------------

[kinuko, 2017/04/21 06:05:10]

Let's remove this comment too

[nhiroki, 2017/04/21 08:46:01]

Done.

 
-void WebSharedWorkerImpl::PostTaskToLoader(
-    const WebTraceLocation& location,
-    std::unique_ptr<WTF::CrossThreadClosure> task) {
-  DCHECK(worker_thread_->IsCurrentThread());
-  parent_frame_task_runners_->Get(TaskType::kNetworking)
-      ->PostTask(FROM_HERE, std::move(task));
-}
-
-void WebSharedWorkerImpl::PostTaskToWorkerGlobalScope(
-    const WebTraceLocation& location,
-    std::unique_ptr<WTF::CrossThreadClosure> task) {
-  DCHECK(IsMainThread());
-  TaskRunnerHelper::Get(TaskType::kNetworking, GetWorkerThread())
-      ->PostTask(location, std::move(task));
-}
-
 ThreadableLoadingContext* WebSharedWorkerImpl::GetThreadableLoadingContext() {
   if (!loading_context_) {
     loading_context_ =
         ThreadableLoadingContext::Create(*ToDocument(loading_document_.Get()));
   }
   return loading_context_;
 }
 
 void WebSharedWorkerImpl::Connect(
     std::unique_ptr<WebMessagePortChannel> web_channel) {
   DCHECK(IsMainThread());
+  // The HTML spec requires to queue a connect event using the DOM manipulation
+  // task source.
+  // https://html.spec.whatwg.org/multipage/workers.html#shared-workers-and-the-sharedworker-interface
   TaskRunnerHelper::Get(TaskType::kDOMManipulation, GetWorkerThread())
       ->PostTask(
           BLINK_FROM_HERE,
           CrossThreadBind(&WebSharedWorkerImpl::ConnectTaskOnWorkerThread,
                           WTF::CrossThreadUnretained(this),
                           WTF::Passed(std::move(web_channel))));
 }
 
 void WebSharedWorkerImpl::ConnectTaskOnWorkerThread(
     std::unique_ptr<WebMessagePortChannel> channel) {
@@ skipping 75 matching lines @@
           worker_clients, main_script_loader_->ResponseAddressSpace(),
           main_script_loader_->OriginTrialTokens(), std::move(worker_settings),
           WorkerV8Settings::Default());
 
   // SharedWorker can sometimes run tasks that are initiated by/associated with
   // a document's frame but these documents can be from a different process. So
   // we intentionally populate the task runners with null document in order to
   // use the thread's default task runner. Note that |m_document| should not be
   // used as it's a dummy document for loading that doesn't represent the frame
   // of any associated document.
-  parent_frame_task_runners_ = ParentFrameTaskRunners::Create(nullptr);
+  ParentFrameTaskRunners* task_runners =
+      ParentFrameTaskRunners::Create(nullptr);
 
   loader_proxy_ = WorkerLoaderProxy::Create(this);
-  reporting_proxy_ = new WebSharedWorkerReportingProxyImpl(
-      this, parent_frame_task_runners_.Get());
+  reporting_proxy_ = new WebSharedWorkerReportingProxyImpl(this, task_runners);
   worker_thread_ =
       SharedWorkerThread::Create(name_, loader_proxy_, *reporting_proxy_);
   probe::scriptImported(loading_document_, main_script_loader_->Identifier(),
                         main_script_loader_->SourceText());
   main_script_loader_.Clear();
 
-  GetWorkerThread()->Start(std::move(startup_data),
-                           parent_frame_task_runners_.Get());
+  GetWorkerThread()->Start(std::move(startup_data), task_runners);
   worker_inspector_proxy_->WorkerThreadCreated(ToDocument(loading_document_),
                                                GetWorkerThread(), url_);
   client_->WorkerScriptLoaded();
 }
 
 void WebSharedWorkerImpl::TerminateWorkerContext() {
   DCHECK(IsMainThread());
   TerminateWorkerThread();
 }
 
@@ skipping 33 matching lines @@
   if (devtools_agent)
     devtools_agent->DispatchOnInspectorBackend(session_id, call_id, method,
                                                message);
 }
 
 WebSharedWorker* WebSharedWorker::Create(WebSharedWorkerClient* client) {
   return new WebSharedWorkerImpl(client);
 }
 
 }  // namespace blink