Introduce ThreadableLoader::ModuleId for crash investigation

This CL adds DocumentThreadableLoader::module_id_ to see which module is
to blame for the CHECK failure.

I'll revert this change once the cause is found.

Bug: 837511
Change-Id: I76a724d1d8277d5e70afed85bb5576df99d997ca
Reviewed-on: https://chromium-review.googlesource.com/1125546Reviewed-by: Adam Rice <ricea@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Yutaka Hirano <yhirano@chromium.org>
Cr-Commit-Position: refs/heads/master@{#572481}

third_party/blink/renderer/core/exported/web_associated_url_loader_impl.cc

@@ -433,6 +433,7 @@ void WebAssociatedURLLoaderImpl::LoadAsynchronously(
     Document* document = ToDocument(observer_->LifecycleContext());
     DCHECK(document);
     loader_ = DocumentThreadableLoader::Create(
+        ThreadableLoader::ModuleId::kWebAssociatedUrlLoader,
         *ThreadableLoadingContext::Create(*document), client_adapter_.get(),
         options, resource_loader_options);
     loader_->Start(webcore_request);

third_party/blink/renderer/core/fetch/fetch_manager.cc

@@ -857,9 +857,9 @@ void FetchManager::Loader::PerformHTTPFetch(ExceptionState& exception_state) {
   ThreadableLoaderOptions threadable_loader_options;
 
   probe::willStartFetch(execution_context_, this);
-  threadable_loader_ = ThreadableLoader::Create(*execution_context_, this,
-                                                threadable_loader_options,
-                                                resource_loader_options);
+  threadable_loader_ = ThreadableLoader::Create(
+      ThreadableLoader::ModuleId::kFetchManager, *execution_context_, this,
+      threadable_loader_options, resource_loader_options);
   threadable_loader_->Start(request);
 }
 
@@ -887,9 +887,9 @@ void FetchManager::Loader::PerformDataFetch() {
   ThreadableLoaderOptions threadable_loader_options;
 
   probe::willStartFetch(execution_context_, this);
-  threadable_loader_ = ThreadableLoader::Create(*execution_context_, this,
-                                                threadable_loader_options,
-                                                resource_loader_options);
+  threadable_loader_ = ThreadableLoader::Create(
+      ThreadableLoader::ModuleId::kFetchManager, *execution_context_, this,
+      threadable_loader_options, resource_loader_options);
   threadable_loader_->Start(request);
 }
 

third_party/blink/renderer/core/loader/document_threadable_loader.cc

@@ -32,6 +32,7 @@
 #include "third_party/blink/renderer/core/loader/document_threadable_loader.h"
 
 #include <memory>
+#include "base/debug/alias.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "services/network/public/mojom/cors.mojom-blink.h"
@@ -187,8 +188,9 @@ void DocumentThreadableLoader::LoadResourceSynchronously(
     ThreadableLoaderClient& client,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resource_loader_options) {
-  (new DocumentThreadableLoader(loading_context, &client, kLoadSynchronously,
-                                options, resource_loader_options))
+  (new DocumentThreadableLoader(ModuleId::kSync, loading_context, &client,
+                                kLoadSynchronously, options,
+                                resource_loader_options))
       ->Start(request);
 }
 
@@ -242,22 +244,25 @@ DocumentThreadableLoader::CreateAccessControlPreflightRequestForTesting(
 
 // static
 DocumentThreadableLoader* DocumentThreadableLoader::Create(
+    ModuleId id,
     ThreadableLoadingContext& loading_context,
     ThreadableLoaderClient* client,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resource_loader_options) {
-  return new DocumentThreadableLoader(loading_context, client,
+  return new DocumentThreadableLoader(id, loading_context, client,
                                       kLoadAsynchronously, options,
                                       resource_loader_options);
 }
 
 DocumentThreadableLoader::DocumentThreadableLoader(
+    ModuleId module_id,
     ThreadableLoadingContext& loading_context,
     ThreadableLoaderClient* client,
     BlockingBehavior blocking_behavior,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resource_loader_options)
-    : client_(client),
+    : module_id_(module_id),
+      client_(client),
       loading_context_(&loading_context),
       options_(options),
       resource_loader_options_(resource_loader_options),
@@ -551,6 +556,8 @@ void DocumentThreadableLoader::MakeCrossOriginAccessRequest(
 }
 
 DocumentThreadableLoader::~DocumentThreadableLoader() {
+  const auto module_id = module_id_;
+  base::debug::Alias(&module_id);
   CHECK(!client_);
   DCHECK(!GetResource());
 }

third_party/blink/renderer/core/loader/document_threadable_loader.h

@@ -72,7 +72,8 @@ class CORE_EXPORT DocumentThreadableLoader final : public ThreadableLoader,
   static std::unique_ptr<ResourceRequest>
   CreateAccessControlPreflightRequestForTesting(const ResourceRequest&);
 
-  static DocumentThreadableLoader* Create(ThreadableLoadingContext&,
+  static DocumentThreadableLoader* Create(ModuleId,
+                                          ThreadableLoadingContext&,
                                           ThreadableLoaderClient*,
                                           const ThreadableLoaderOptions&,
                                           const ResourceLoaderOptions&);
@@ -99,7 +100,8 @@ class CORE_EXPORT DocumentThreadableLoader final : public ThreadableLoader,
       const ResourceRequest&,
       const SecurityOrigin*);
 
-  DocumentThreadableLoader(ThreadableLoadingContext&,
+  DocumentThreadableLoader(ModuleId,
+                           ThreadableLoadingContext&,
                            ThreadableLoaderClient*,
                            BlockingBehavior,
                            const ThreadableLoaderOptions&,
@@ -176,6 +178,7 @@ class CORE_EXPORT DocumentThreadableLoader final : public ThreadableLoader,
   // TODO(kinuko): Remove dependency to document.
   Document* GetDocument() const;
 
+  const ModuleId module_id_;
   ThreadableLoaderClient* client_;
   Member<ThreadableLoadingContext> loading_context_;
 

third_party/blink/renderer/core/loader/threadable_loader.cc

@@ -38,6 +38,7 @@
 namespace blink {
 
 ThreadableLoader* ThreadableLoader::Create(
+    ModuleId id,
     ExecutionContext& context,
     ThreadableLoaderClient* client,
     const ThreadableLoaderOptions& options,
@@ -46,7 +47,7 @@ ThreadableLoader* ThreadableLoader::Create(
   if (context.IsWorkerGlobalScope())
     ToWorkerGlobalScope(&context)->EnsureFetcher();
   return DocumentThreadableLoader::Create(
-      *ThreadableLoadingContext::Create(context), client, options,
+      id, *ThreadableLoadingContext::Create(context), client, options,
       resource_loader_options);
 }
 

third_party/blink/renderer/core/loader/threadable_loader.h

@@ -94,6 +94,18 @@ struct CrossThreadCopier<ThreadableLoaderOptions> {
 class CORE_EXPORT ThreadableLoader
     : public GarbageCollectedFinalized<ThreadableLoader> {
  public:
+  enum class ModuleId {
+    kFetchManager,
+    kWorkerClassicScriptLoader,
+    kXmlHttpRequest,
+    kBackgroundFetchIconLoader,
+    kEventSource,
+    kNotificationImageLoader,
+    kWebAssociatedUrlLoader,
+    kWorkerThreadableLoader,
+    kSync,
+    kTest,
+  };
   static void LoadResourceSynchronously(ExecutionContext&,
                                         const ResourceRequest&,
                                         ThreadableLoaderClient&,
@@ -131,7 +143,8 @@ class CORE_EXPORT ThreadableLoader
   // also for cancellation happened inside the loader.)
   //
   // ThreadableLoaderClient methods may call cancel().
-  static ThreadableLoader* Create(ExecutionContext&,
+  static ThreadableLoader* Create(ModuleId,
+                                  ExecutionContext&,
                                   ThreadableLoaderClient*,
                                   const ThreadableLoaderOptions&,
                                   const ResourceLoaderOptions&);

third_party/blink/renderer/core/loader/threadable_loader_test.cc

@@ -195,6 +195,7 @@ class DocumentThreadableLoaderTestHelper : public ThreadableLoaderTestHelper {
     ThreadableLoaderOptions options;
     ResourceLoaderOptions resource_loader_options;
     loader_ = DocumentThreadableLoader::Create(
+        ThreadableLoader::ModuleId::kTest,
         *ThreadableLoadingContext::Create(GetDocument()), client, options,
         resource_loader_options);
   }
@@ -394,7 +395,8 @@ class WorkerThreadableLoaderTestHelper : public ThreadableLoaderTestHelper {
     // isWorkerGlobalScope().
     DCHECK(worker_thread_->GlobalScope()->IsWorkerGlobalScope());
 
-    loader_ = ThreadableLoader::Create(*worker_thread_->GlobalScope(), client,
+    loader_ = ThreadableLoader::Create(ThreadableLoader::ModuleId::kTest,
+                                       *worker_thread_->GlobalScope(), client,
                                        options, resource_loader_options);
     DCHECK(loader_);
     event->Signal();

third_party/blink/renderer/core/loader/worker_threadable_loader.cc

@@ -673,7 +673,8 @@ void WorkerThreadableLoader::ParentThreadLoaderHolder::Start(
       original_resource_loader_options;
   resource_loader_options.request_initiator_context = kWorkerContext;
   parent_thread_loader_ = DocumentThreadableLoader::Create(
-      loading_context, this, options, resource_loader_options);
+      ModuleId::kWorkerThreadableLoader, loading_context, this, options,
+      resource_loader_options);
   parent_thread_loader_->Start(ResourceRequest(request.get()));
 }
 

third_party/blink/renderer/core/workers/worker_classic_script_loader.cc

@@ -119,7 +119,8 @@ void WorkerClassicScriptLoader::LoadAsynchronously(
   scoped_refptr<WorkerClassicScriptLoader> protect(this);
   need_to_cancel_ = true;
   threadable_loader_ = ThreadableLoader::Create(
-      execution_context, this, options, resource_loader_options);
+      ThreadableLoader::ModuleId::kWorkerClassicScriptLoader, execution_context,
+      this, options, resource_loader_options);
   threadable_loader_->Start(request);
   if (failed_)
     NotifyFinished();

third_party/blink/renderer/core/xmlhttprequest/xml_http_request.cc

@@ -1128,8 +1128,9 @@ void XMLHttpRequest::CreateRequest(scoped_refptr<EncodedFormData> http_body,
     // TODO(yhirano): Turn this CHECK into DCHECK: see https://crbug.com/570946.
     CHECK(!loader_);
     DCHECK(send_flag_);
-    loader_ = ThreadableLoader::Create(execution_context, this, options,
-                                       resource_loader_options);
+    loader_ = ThreadableLoader::Create(
+        ThreadableLoader::ModuleId::kXmlHttpRequest, execution_context, this,
+        options, resource_loader_options);
     loader_->Start(request);
 
     return;

third_party/blink/renderer/modules/background_fetch/background_fetch_icon_loader.cc

@@ -85,9 +85,10 @@ void BackgroundFetchIconLoader::DidGetIconDisplaySizeIfSoLoadIcon(
   resource_request.SetPriority(ResourceLoadPriority::kMedium);
   resource_request.SetRequestorOrigin(execution_context->GetSecurityOrigin());
 
-  threadable_loader_ = ThreadableLoader::Create(*execution_context, this,
-                                                threadable_loader_options,
-                                                resource_loader_options);
+  threadable_loader_ = ThreadableLoader::Create(
+      ThreadableLoader::ModuleId::kBackgroundFetchIconLoader,
+      *execution_context, this, threadable_loader_options,
+      resource_loader_options);
 
   threadable_loader_->Start(resource_request);
 }

third_party/blink/renderer/modules/eventsource/event_source.cc

@@ -160,7 +160,8 @@ void EventSource::Connect() {
   probe::willSendEventSourceRequest(&execution_context, this);
   // probe::documentThreadableLoaderStartedLoadingForClient
   // will be called synchronously.
-  loader_ = ThreadableLoader::Create(execution_context, this, options,
+  loader_ = ThreadableLoader::Create(ThreadableLoader::ModuleId::kEventSource,
+                                     execution_context, this, options,
                                      resource_loader_options);
   loader_->Start(request);
 }

third_party/blink/renderer/modules/notifications/notification_image_loader.cc

@@ -119,7 +119,8 @@ void NotificationImageLoader::Start(ExecutionContext* context,
   resource_request.SetRequestorOrigin(context->GetSecurityOrigin());
 
   threadable_loader_ = ThreadableLoader::Create(
-      *context, this, threadable_loader_options, resource_loader_options);
+      ThreadableLoader::ModuleId::kNotificationImageLoader, *context, this,
+      threadable_loader_options, resource_loader_options);
   threadable_loader_->Start(resource_request);
 }