Revert "devtools: Prepare for service worker UI thread core."

This reverts commit b9e16d2b.

Reason for revert: Speculative revert for

Unexpected Failures:
* http/tests/devtools/a11y-axe-core/elements/event-listeners-a11y-test.js
* http/tests/devtools/a11y-axe-core/security/security-origin-a11y-test.js
* http/tests/devtools/a11y-axe-core/sources/sources-editor-pane-a11y-test.js

See builds
https://ci.chromium.org/p/chromium/builders/ci/WebKit%20Linux%20Leak/3809
to
https://ci.chromium.org/p/chromium/builders/ci/WebKit%20Linux%20Leak/3842

Original change's description:
> devtools: Prepare for service worker UI thread core.
> 
> The thread ServiceWorkerContextCore lives on (the "core thread") will move from
> the IO thread to the UI thread when the ServiceWorkerOnUI feature is enabled.
> 
> This CL makes DevTools aware of the core thread instead of assuming the IO
> thread. This makes https/tests/devtools web_tests pass when the feature is
> enabled.
> 
> Bug: 824858
> Change-Id: I20e38f50998f4b0cd9d8b8cc43526665d92dbf94
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1775655
> Commit-Queue: Matt Falkenhagen <falken@chromium.org>
> Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#691689}

TBR=falken@chromium.org,caseq@chromium.org

Change-Id: I2d49a0fe27f033a7b8bd74e3a50fd9d78a4f1f58
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 824858
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1778403Reviewed-by: sebsg <sebsg@chromium.org>
Commit-Queue: sebsg <sebsg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#692059}

content/browser/devtools/devtools_background_services_context_impl.cc

@@ -218,7 +218,7 @@ void DevToolsBackgroundServicesContextImpl::ClearLoggedBackgroundServiceEvents(
 void DevToolsBackgroundServicesContextImpl::
     ClearLoggedBackgroundServiceEventsOnCoreThread(
         devtools::proto::BackgroundService service) {
-  DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->ClearUserDataForAllRegistrationsByKeyPrefix(
       CreateEntryKeyPrefix(service), base::BindOnce(&DidClearServiceEvents));

content/browser/devtools/protocol/service_worker_handler.cc

@@ -28,7 +28,6 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/render_process_host.h"
-#include "content/public/browser/service_worker_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "third_party/blink/public/mojom/push_messaging/push_messaging_status.mojom.h"
@@ -79,23 +78,22 @@ const std::string GetVersionStatusString(
   return std::string();
 }
 
-void StopServiceWorkerOnCoreThread(
-    scoped_refptr<ServiceWorkerContextWrapper> context,
-    int64_t version_id) {
+void StopServiceWorkerOnIO(scoped_refptr<ServiceWorkerContextWrapper> context,
+                           int64_t version_id) {
   if (content::ServiceWorkerVersion* version =
           context->GetLiveVersion(version_id)) {
     version->StopWorker(base::DoNothing());
   }
 }
 
-void GetDevToolsRouteInfoOnCoreThread(
+void GetDevToolsRouteInfoOnIO(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     int64_t version_id,
     const base::Callback<void(int, int)>& callback) {
   if (content::ServiceWorkerVersion* version =
           context->GetLiveVersion(version_id)) {
-    RunOrPostTaskOnThread(
-        FROM_HERE, BrowserThread::UI,
+    base::PostTask(
+        FROM_HERE, {BrowserThread::UI},
         base::BindOnce(
             callback, version->embedded_worker()->process_id(),
             version->embedded_worker()->worker_devtools_agent_route_id()));
@@ -114,7 +112,7 @@ Response CreateInvalidVersionIdErrorResponse() {
   return Response::InvalidParams("Invalid version ID");
 }
 
-void DidFindRegistrationForDispatchSyncEventOnCoreThread(
+void DidFindRegistrationForDispatchSyncEventOnIO(
     scoped_refptr<BackgroundSyncContextImpl> sync_context,
     const std::string& tag,
     bool last_chance,
@@ -132,7 +130,7 @@ void DidFindRegistrationForDispatchSyncEventOnCoreThread(
       tag, std::move(version), last_chance, base::DoNothing());
 }
 
-void DidFindRegistrationForDispatchPeriodicSyncEventOnCoreThread(
+void DidFindRegistrationForDispatchPeriodicSyncEventOnIO(
     scoped_refptr<BackgroundSyncContextImpl> sync_context,
     const std::string& tag,
     blink::ServiceWorkerStatusCode status,
@@ -151,7 +149,7 @@ void DidFindRegistrationForDispatchPeriodicSyncEventOnCoreThread(
       tag, std::move(version), base::DoNothing());
 }
 
-void DispatchSyncEventOnCoreThread(
+void DispatchSyncEventOnIO(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     scoped_refptr<BackgroundSyncContextImpl> sync_context,
     const GURL& origin,
@@ -160,11 +158,11 @@ void DispatchSyncEventOnCoreThread(
     bool last_chance) {
   context->FindReadyRegistrationForId(
       registration_id, origin,
-      base::BindOnce(&DidFindRegistrationForDispatchSyncEventOnCoreThread,
-                     sync_context, tag, last_chance));
+      base::BindOnce(&DidFindRegistrationForDispatchSyncEventOnIO, sync_context,
+                     tag, last_chance));
 }
 
-void DispatchPeriodicSyncEventOnCoreThread(
+void DispatchPeriodicSyncEventOnIO(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     scoped_refptr<BackgroundSyncContextImpl> sync_context,
     const GURL& origin,
@@ -172,9 +170,8 @@ void DispatchPeriodicSyncEventOnCoreThread(
     const std::string& tag) {
   context->FindReadyRegistrationForId(
       registration_id, origin,
-      base::BindOnce(
-          &DidFindRegistrationForDispatchPeriodicSyncEventOnCoreThread,
-          sync_context, tag));
+      base::BindOnce(&DidFindRegistrationForDispatchPeriodicSyncEventOnIO,
+                     sync_context, tag));
 }
 
 }  // namespace
@@ -277,9 +274,8 @@ Response ServiceWorkerHandler::StopWorker(const std::string& version_id) {
   int64_t id = 0;
   if (!base::StringToInt64(version_id, &id))
     return CreateInvalidVersionIdErrorResponse();
-  RunOrPostTaskOnThread(
-      FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-      base::BindOnce(&StopServiceWorkerOnCoreThread, context_, id));
+  base::PostTask(FROM_HERE, {BrowserThread::IO},
+                 base::BindOnce(&StopServiceWorkerOnIO, context_, id));
   return Response::OK();
 }
 
@@ -316,9 +312,9 @@ Response ServiceWorkerHandler::InspectWorker(const std::string& version_id) {
   int64_t id = blink::mojom::kInvalidServiceWorkerVersionId;
   if (!base::StringToInt64(version_id, &id))
     return CreateInvalidVersionIdErrorResponse();
-  RunOrPostTaskOnThread(
-      FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-      base::BindOnce(&GetDevToolsRouteInfoOnCoreThread, context_, id,
+  base::PostTask(
+      FROM_HERE, {BrowserThread::IO},
+      base::BindOnce(&GetDevToolsRouteInfoOnIO, context_, id,
                      base::Bind(&ServiceWorkerHandler::OpenNewDevToolsWindow,
                                 weak_factory_.GetWeakPtr())));
   return Response::OK();
@@ -370,10 +366,10 @@ Response ServiceWorkerHandler::DispatchSyncEvent(
   BackgroundSyncContextImpl* sync_context =
       storage_partition_->GetBackgroundSyncContext();
 
-  RunOrPostTaskOnThread(FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-                        base::BindOnce(&DispatchSyncEventOnCoreThread, context_,
-                                       base::WrapRefCounted(sync_context),
-                                       GURL(origin), id, tag, last_chance));
+  base::PostTask(FROM_HERE, {BrowserThread::IO},
+                 base::BindOnce(&DispatchSyncEventOnIO, context_,
+                                base::WrapRefCounted(sync_context),
+                                GURL(origin), id, tag, last_chance));
   return Response::OK();
 }
 
@@ -392,9 +388,9 @@ Response ServiceWorkerHandler::DispatchPeriodicSyncEvent(
   BackgroundSyncContextImpl* sync_context =
       storage_partition_->GetBackgroundSyncContext();
 
-  RunOrPostTaskOnThread(
-      FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-      base::BindOnce(&DispatchPeriodicSyncEventOnCoreThread, context_,
+  base::PostTaskWithTraits(
+      FROM_HERE, {BrowserThread::IO},
+      base::BindOnce(&DispatchPeriodicSyncEventOnIO, context_,
                      base::WrapRefCounted(sync_context), GURL(origin), id,
                      tag));
   return Response::OK();

content/browser/devtools/service_worker_devtools_agent_host.cc

@@ -27,7 +27,7 @@ namespace content {
 
 namespace {
 
-void TerminateServiceWorkerOnCoreThread(
+void TerminateServiceWorkerOnIO(
     base::WeakPtr<ServiceWorkerContextCore> context_weak,
     int64_t version_id) {
   if (ServiceWorkerContextCore* context = context_weak.get()) {
@@ -36,7 +36,7 @@ void TerminateServiceWorkerOnCoreThread(
   }
 }
 
-void SetDevToolsAttachedOnCoreThread(
+void SetDevToolsAttachedOnIO(
     base::WeakPtr<ServiceWorkerContextCore> context_weak,
     int64_t version_id,
     bool attached) {
@@ -46,7 +46,7 @@ void SetDevToolsAttachedOnCoreThread(
   }
 }
 
-void UpdateLoaderFactoriesOnCoreThread(
+void UpdateLoaderFactoriesOnIO(
     base::WeakPtr<ServiceWorkerContextCore> context_weak,
     int64_t version_id,
     std::unique_ptr<blink::URLLoaderFactoryBundleInfo> script_bundle,
@@ -111,9 +111,9 @@ void ServiceWorkerDevToolsAgentHost::Reload() {
 }
 
 bool ServiceWorkerDevToolsAgentHost::Close() {
-  RunOrPostTaskOnThread(FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-                        base::BindOnce(&TerminateServiceWorkerOnCoreThread,
-                                       context_weak_, version_id_));
+  base::PostTask(
+      FROM_HERE, {BrowserThread::IO},
+      base::BindOnce(&TerminateServiceWorkerOnIO, context_weak_, version_id_));
   return true;
 }
 
@@ -192,9 +192,9 @@ void ServiceWorkerDevToolsAgentHost::WorkerDestroyed() {
 }
 
 void ServiceWorkerDevToolsAgentHost::UpdateIsAttached(bool attached) {
-  RunOrPostTaskOnThread(FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-                        base::BindOnce(&SetDevToolsAttachedOnCoreThread,
-                                       context_weak_, version_id_, attached));
+  base::PostTask(FROM_HERE, {BrowserThread::IO},
+                 base::BindOnce(&SetDevToolsAttachedOnIO, context_weak_,
+                                version_id_, attached));
 }
 
 void ServiceWorkerDevToolsAgentHost::UpdateLoaderFactories(
@@ -211,20 +211,11 @@ void ServiceWorkerDevToolsAgentHost::UpdateLoaderFactories(
   auto subresource_bundle = EmbeddedWorkerInstance::CreateFactoryBundleOnUI(
       rph, worker_route_id_, origin,
       ContentBrowserClient::URLLoaderFactoryType::kServiceWorkerSubResource);
-
-  if (ServiceWorkerContext::IsServiceWorkerOnUIEnabled()) {
-    UpdateLoaderFactoriesOnCoreThread(context_weak_, version_id_,
-                                      std::move(script_bundle),
-                                      std::move(subresource_bundle));
-    std::move(callback).Run();
-  } else {
-    base::PostTaskAndReply(
-        FROM_HERE, {BrowserThread::IO},
-        base::BindOnce(&UpdateLoaderFactoriesOnCoreThread, context_weak_,
-                       version_id_, std::move(script_bundle),
-                       std::move(subresource_bundle)),
-        std::move(callback));
-  }
+  base::PostTaskAndReply(
+      FROM_HERE, {BrowserThread::IO},
+      base::BindOnce(&UpdateLoaderFactoriesOnIO, context_weak_, version_id_,
+                     std::move(script_bundle), std::move(subresource_bundle)),
+      std::move(callback));
 }
 
 }  // namespace content