Invoke ResourceLoadObserver when using WorkerMainScriptLoader to load

main script for workers

Currently, we are using WorkerMainScriptLoader to load the main script
for PlzWorkers when kLoadMainScriptForPlzDedicatedWorkerByParams is
enabled. So the whole loading process will not go through
a normal flow of network request, which means
that ResourceLoadObserverForWorker doesn't get invoked and the network
inspector isn't notified.

This patch will pass ResourceLoadObserver to the WorkerMainScriptLoader
when starting to load the main script, thus we
could call the ResourceLoadObserver at the proper timing and send
the notifications to the inspector finally.

Bug: 860403
Change-Id: I51e2bbdf3f9185cf2640d21183bf641e0cf8b6af
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2309093Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Commit-Queue: Minggang Wang <minggang.wang@intel.com>
Cr-Commit-Position: refs/heads/master@{#793202}

content/public/common/referrer.cc

@@ -17,6 +17,7 @@
 #include "services/network/public/cpp/features.h"
 #include "services/network/public/cpp/resource_request.h"
 #include "services/network/public/mojom/referrer_policy.mojom-shared.h"
+#include "third_party/blink/public/common/loader/network_utils.h"
 #include "third_party/blink/public/mojom/loader/referrer.mojom.h"
 
 namespace content {
@@ -61,7 +62,7 @@ blink::mojom::ReferrerPtr Referrer::SanitizeForRequest(
   network::mojom::ReferrerPolicy effective_policy = referrer.policy;
   if (effective_policy == network::mojom::ReferrerPolicy::kDefault) {
     effective_policy =
-        NetReferrerPolicyToBlinkReferrerPolicy(GetDefaultReferrerPolicy());
+        blink::NetToMojoReferrerPolicy(GetDefaultReferrerPolicy());
   }
   DCHECK_NE(effective_policy, network::mojom::ReferrerPolicy::kDefault);
 
@@ -92,29 +93,11 @@ net::ReferrerPolicy Referrer::ReferrerPolicyForUrlRequest(
 }
 
 // static
+// TODO(minggang): Let the callers of this static method call
+// blink::NetToMojoReferrerPolicy() directly.
 network::mojom::ReferrerPolicy Referrer::NetReferrerPolicyToBlinkReferrerPolicy(
     net::ReferrerPolicy net_policy) {
-  switch (net_policy) {
-    case net::ReferrerPolicy::CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE:
-      return network::mojom::ReferrerPolicy::kNoReferrerWhenDowngrade;
-    case net::ReferrerPolicy::REDUCE_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN:
-      return network::mojom::ReferrerPolicy::kStrictOriginWhenCrossOrigin;
-    case net::ReferrerPolicy::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN:
-      return network::mojom::ReferrerPolicy::kOriginWhenCrossOrigin;
-    case net::ReferrerPolicy::NEVER_CLEAR:
-      return network::mojom::ReferrerPolicy::kAlways;
-    case net::ReferrerPolicy::ORIGIN:
-      return network::mojom::ReferrerPolicy::kOrigin;
-    case net::ReferrerPolicy::CLEAR_ON_TRANSITION_CROSS_ORIGIN:
-      return network::mojom::ReferrerPolicy::kSameOrigin;
-    case net::ReferrerPolicy::
-        ORIGIN_CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE:
-      return network::mojom::ReferrerPolicy::kStrictOrigin;
-    case net::ReferrerPolicy::NO_REFERRER:
-      return network::mojom::ReferrerPolicy::kNever;
-  }
-  NOTREACHED();
-  return network::mojom::ReferrerPolicy::kDefault;
+  return blink::NetToMojoReferrerPolicy(net_policy);
 }
 
 // static

third_party/blink/common/loader/network_utils.cc

@@ -18,4 +18,29 @@ bool AlwaysAccessNetwork(
          headers->HasHeaderValue("vary", "*");
 }
 
+network::mojom::ReferrerPolicy NetToMojoReferrerPolicy(
+    net::ReferrerPolicy net_policy) {
+  switch (net_policy) {
+    case net::ReferrerPolicy::CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE:
+      return network::mojom::ReferrerPolicy::kNoReferrerWhenDowngrade;
+    case net::ReferrerPolicy::REDUCE_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN:
+      return network::mojom::ReferrerPolicy::kStrictOriginWhenCrossOrigin;
+    case net::ReferrerPolicy::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN:
+      return network::mojom::ReferrerPolicy::kOriginWhenCrossOrigin;
+    case net::ReferrerPolicy::NEVER_CLEAR:
+      return network::mojom::ReferrerPolicy::kAlways;
+    case net::ReferrerPolicy::ORIGIN:
+      return network::mojom::ReferrerPolicy::kOrigin;
+    case net::ReferrerPolicy::CLEAR_ON_TRANSITION_CROSS_ORIGIN:
+      return network::mojom::ReferrerPolicy::kSameOrigin;
+    case net::ReferrerPolicy::
+        ORIGIN_CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE:
+      return network::mojom::ReferrerPolicy::kStrictOrigin;
+    case net::ReferrerPolicy::NO_REFERRER:
+      return network::mojom::ReferrerPolicy::kNever;
+  }
+  NOTREACHED();
+  return network::mojom::ReferrerPolicy::kDefault;
+}
+
 }  // namespace blink

third_party/blink/public/common/loader/network_utils.h

@@ -7,6 +7,8 @@
 
 #include "base/memory/scoped_refptr.h"
 #include "net/http/http_response_headers.h"
+#include "net/url_request/referrer_policy.h"
+#include "services/network/public/mojom/referrer_policy.mojom-shared.h"
 #include "third_party/blink/public/common/common_export.h"
 
 namespace blink {
@@ -16,6 +18,9 @@ namespace blink {
 BLINK_COMMON_EXPORT bool AlwaysAccessNetwork(
     const scoped_refptr<net::HttpResponseHeaders>& headers);
 
+BLINK_COMMON_EXPORT network::mojom::ReferrerPolicy NetToMojoReferrerPolicy(
+    net::ReferrerPolicy net_policy);
+
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_PUBLIC_COMMON_LOADER_NETWORK_UTILS_H_

third_party/blink/renderer/core/loader/modulescript/worker_module_script_fetcher.cc

@@ -9,6 +9,7 @@
 #include "services/network/public/mojom/ip_address_space.mojom-blink.h"
 #include "services/network/public/mojom/referrer_policy.mojom-blink.h"
 #include "third_party/blink/public/common/features.h"
+#include "third_party/blink/public/common/loader/network_utils.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
 #include "third_party/blink/renderer/core/origin_trials/origin_trial_context.h"
 #include "third_party/blink/renderer/core/workers/worker_global_scope.h"
@@ -16,6 +17,7 @@
 #include "third_party/blink/renderer/platform/loader/fetch/fetch_client_settings_object.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_fetcher.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.h"
+#include "third_party/blink/renderer/platform/loader/fetch/unique_identifier.h"
 #include "third_party/blink/renderer/platform/network/content_security_policy_response_headers.h"
 #include "third_party/blink/renderer/platform/network/http_names.h"
 #include "third_party/blink/renderer/platform/network/mime/mime_type_registry.h"
@@ -46,18 +48,18 @@ void WorkerModuleScriptFetcher::Fetch(
   std::unique_ptr<WorkerMainScriptLoadParameters>
       worker_main_script_load_params =
           global_scope_->TakeWorkerMainScriptLoadingParametersForModules();
-  ResourceLoaderOptions resource_loader_options;
   if (worker_main_script_load_params) {
     DCHECK(base::FeatureList::IsEnabled(
         features::kLoadMainScriptForPlzDedicatedWorkerByParams));
     DCHECK_EQ(level_, ModuleGraphLevel::kTopLevelModuleFetch);
+
+    fetch_params.MutableResourceRequest().SetInspectorId(
+        CreateUniqueIdentifier());
     worker_main_script_loader_ = MakeGarbageCollected<WorkerMainScriptLoader>();
     worker_main_script_loader_->Start(
-        fetch_params.Url(), std::move(worker_main_script_load_params),
-        resource_loader_options,
-        fetch_params.GetResourceRequest().GetRequestContext(),
-        fetch_params.GetResourceRequest().GetRequestDestination(),
+        fetch_params, std::move(worker_main_script_load_params),
         &fetch_client_settings_object_fetcher->Context(),
+        fetch_client_settings_object_fetcher->GetResourceLoadObserver(),
         global_scope_->CloneResourceLoadInfoNotifier(), this);
     return;
   }

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

@@ -45,6 +45,7 @@
 #include "third_party/blink/renderer/platform/loader/fetch/resource_loader_options.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_response.h"
 #include "third_party/blink/renderer/platform/loader/fetch/text_resource_decoder_options.h"
+#include "third_party/blink/renderer/platform/loader/fetch/unique_identifier.h"
 #include "third_party/blink/renderer/platform/network/content_security_policy_response_headers.h"
 #include "third_party/blink/renderer/platform/network/http_names.h"
 #include "third_party/blink/renderer/platform/network/network_utils.h"
@@ -156,33 +157,37 @@ void WorkerClassicScriptLoader::LoadTopLevelScriptAsynchronously(
   url_ = url;
   fetch_client_settings_object_fetcher_ = fetch_client_settings_object_fetcher;
   is_top_level_script_ = true;
-  ResourceLoaderOptions resource_loader_options;
+  ResourceRequest request(url);
+  request.SetHttpMethod(http_names::kGET);
+  request.SetExternalRequestStateFromRequestorAddressSpace(
+      fetch_client_settings_object_fetcher_->GetProperties()
+          .GetFetchClientSettingsObject()
+          .GetAddressSpace());
+  request.SetRequestContext(request_context);
+  request.SetRequestDestination(destination);
+  request.SetMode(request_mode);
+  request.SetCredentialsMode(credentials_mode);
 
   // Use WorkerMainScriptLoader to load the main script for dedicated workers
   // (PlzDedicatedWorker) and shared workers.
   if (worker_main_script_load_params) {
     DCHECK(base::FeatureList::IsEnabled(
         features::kLoadMainScriptForPlzDedicatedWorkerByParams));
+
+    request.SetInspectorId(CreateUniqueIdentifier());
+    request.SetReferrerString(Referrer::NoReferrer());
+    request.SetPriority(ResourceLoadPriority::kHigh);
+    FetchParameters fetch_params(std::move(request), ResourceLoaderOptions());
     worker_main_script_loader_ = MakeGarbageCollected<WorkerMainScriptLoader>();
     worker_main_script_loader_->Start(
-        url, std::move(worker_main_script_load_params), resource_loader_options,
-        request_context, destination,
+        fetch_params, std::move(worker_main_script_load_params),
         &fetch_client_settings_object_fetcher_->Context(),
+        fetch_client_settings_object_fetcher->GetResourceLoadObserver(),
         std::move(resource_load_info_notifier), this);
     return;
   }
 
-  ResourceRequest request(url);
-  request.SetHttpMethod(http_names::kGET);
-  request.SetExternalRequestStateFromRequestorAddressSpace(
-      fetch_client_settings_object_fetcher_->GetProperties()
-          .GetFetchClientSettingsObject()
-          .GetAddressSpace());
-  request.SetRequestContext(request_context);
-  request.SetRequestDestination(destination);
-  request.SetMode(request_mode);
-  request.SetCredentialsMode(credentials_mode);
-
+  ResourceLoaderOptions resource_loader_options;
   need_to_cancel_ = true;
   resource_loader_options.reject_coep_unsafe_none = reject_coep_unsafe_none;
   if (blob_url_loader_factory) {

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

@@ -166,6 +166,9 @@ class CORE_EXPORT WorkerClassicScriptLoader final
   base::OnceClosure finished_callback_;
 
   Member<ThreadableLoader> threadable_loader_;
+
+  // These are used only when
+  // features::kLoadMainScriptForPlzDedicatedWorkerByParams is enabled.
   Member<WorkerMainScriptLoader> worker_main_script_loader_;
   String response_encoding_;
   std::unique_ptr<TextResourceDecoder> decoder_;

third_party/blink/renderer/platform/loader/fetch/url_loader/worker_main_script_loader.h

@@ -20,6 +20,7 @@
 #include "third_party/blink/public/mojom/loader/resource_load_info_notifier.mojom.h"
 #include "third_party/blink/public/platform/cross_variant_mojo_util.h"
 #include "third_party/blink/renderer/platform/heap/member.h"
+#include "third_party/blink/renderer/platform/loader/fetch/resource_load_observer.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_response.h"
 #include "third_party/blink/renderer/platform/loader/fetch/response_body_loader_client.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
@@ -30,6 +31,7 @@
 namespace blink {
 
 class FetchContext;
+class FetchParameters;
 class SingleCachedMetadataHandler;
 class WorkerMainScriptLoaderClient;
 struct ResourceLoaderOptions;
@@ -46,13 +48,11 @@ class PLATFORM_EXPORT WorkerMainScriptLoader final
 
   // Starts to load the main script.
   void Start(
-      const KURL& request_script_url,
+      FetchParameters& fetch_params,
       std::unique_ptr<WorkerMainScriptLoadParameters>
           worker_main_script_load_params,
-      const ResourceLoaderOptions& options,
-      mojom::RequestContextType request_context,
-      network::mojom::RequestDestination request_destination,
       FetchContext* fetch_context,
+      ResourceLoadObserver* resource_loade_observer,
       CrossVariantMojoRemote<mojom::ResourceLoadInfoNotifierInterfaceBase>
           resource_load_info_notifier,
       WorkerMainScriptLoaderClient* client);
@@ -90,6 +90,9 @@ class PLATFORM_EXPORT WorkerMainScriptLoader final
   void OnReadable(MojoResult);
   void NotifyCompletionIfAppropriate();
   void OnConnectionClosed();
+  void HandleRedirections(
+      std::vector<net::RedirectInfo>& redirect_infos,
+      std::vector<network::mojom::URLResponseHeadPtr>& redirect_responses);
 
   // Methods used to notify the loading stats.
   void NotifyResponseReceived(network::mojom::URLResponseHeadPtr response_head);
@@ -103,9 +106,10 @@ class PLATFORM_EXPORT WorkerMainScriptLoader final
 
   Member<FetchContext> fetch_context_;
   Member<WorkerMainScriptLoaderClient> client_;
+  Member<ResourceLoadObserver> resource_load_observer_;
 
-  mojom::RequestContextType request_context_;
-  network::mojom::RequestDestination request_destination_;
+  ResourceRequest initial_request_;
+  ResourceLoaderOptions resource_loader_options_;
   KURL initial_request_url_;
   KURL last_request_url_;
   ResourceResponse resource_response_;

third_party/blink/renderer/platform/loader/fetch/url_loader/worker_main_script_loader_unittest.cc

@@ -9,9 +9,11 @@
 #include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/system/data_pipe_utils.h"
 #include "net/http/http_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/common/features.h"
 #include "third_party/blink/public/mojom/fetch/fetch_api_request.mojom-shared.h"
+#include "third_party/blink/renderer/platform/loader/fetch/resource_load_observer.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_loader_options.h"
 #include "third_party/blink/renderer/platform/loader/fetch/url_loader/worker_main_script_loader_client.h"
 #include "third_party/blink/renderer/platform/loader/testing/mock_fetch_context.h"
@@ -21,6 +23,8 @@ namespace blink {
 
 namespace {
 
+using ::testing::_;
+
 const char kTopLevelScriptURL[] = "https://example.com/worker.js";
 const char kHeader[] =
     "HTTP/1.1 200 OK\n"
@@ -146,6 +150,44 @@ class WorkerMainScriptLoaderTest : public testing::Test {
     mojo::Receiver<blink::mojom::ResourceLoadInfoNotifier> receiver_;
   };
 
+  class MockResourceLoadObserver : public ResourceLoadObserver {
+   public:
+    MOCK_METHOD2(DidStartRequest, void(const FetchParameters&, ResourceType));
+    MOCK_METHOD5(WillSendRequest,
+                 void(uint64_t identifier,
+                      const ResourceRequest&,
+                      const ResourceResponse& redirect_response,
+                      ResourceType,
+                      const FetchInitiatorInfo&));
+    MOCK_METHOD3(DidChangePriority,
+                 void(uint64_t identifier,
+                      ResourceLoadPriority,
+                      int intra_priority_value));
+    MOCK_METHOD5(DidReceiveResponse,
+                 void(uint64_t identifier,
+                      const ResourceRequest& request,
+                      const ResourceResponse& response,
+                      const Resource* resource,
+                      ResponseSource));
+    MOCK_METHOD2(DidReceiveData,
+                 void(uint64_t identifier, base::span<const char> chunk));
+    MOCK_METHOD2(DidReceiveTransferSizeUpdate,
+                 void(uint64_t identifier, int transfer_size_diff));
+    MOCK_METHOD2(DidDownloadToBlob, void(uint64_t identifier, BlobDataHandle*));
+    MOCK_METHOD5(DidFinishLoading,
+                 void(uint64_t identifier,
+                      base::TimeTicks finish_time,
+                      int64_t encoded_data_length,
+                      int64_t decoded_body_length,
+                      bool should_report_corb_blocking));
+    MOCK_METHOD5(DidFailLoading,
+                 void(const KURL&,
+                      uint64_t identifier,
+                      const ResourceError&,
+                      int64_t encoded_data_length,
+                      IsInternalRequest));
+  };
+
   MojoCreateDataPipeOptions CreateDataPipeOptions() {
     MojoCreateDataPipeOptions options;
     options.struct_size = sizeof(MojoCreateDataPipeOptions);
@@ -185,15 +227,19 @@ class WorkerMainScriptLoaderTest : public testing::Test {
   WorkerMainScriptLoader* CreateWorkerMainScriptLoaderAndStartLoading(
       std::unique_ptr<WorkerMainScriptLoadParameters>
           worker_main_script_load_params,
+      ResourceLoadObserver* observer,
       mojo::PendingRemote<blink::mojom::ResourceLoadInfoNotifier>
           pending_remote) {
+    ResourceRequest request(kTopLevelScriptURL);
+    request.SetRequestContext(mojom::RequestContextType::SHARED_WORKER);
+    request.SetRequestDestination(
+        network::mojom::RequestDestination::kSharedWorker);
+    FetchParameters fetch_params(std::move(request), ResourceLoaderOptions());
     WorkerMainScriptLoader* worker_main_script_loader =
         MakeGarbageCollected<WorkerMainScriptLoader>();
     worker_main_script_loader->Start(
-        KURL(kTopLevelScriptURL), std::move(worker_main_script_load_params),
-        options_, mojom::RequestContextType::SHARED_WORKER,
-        network::mojom::RequestDestination::kSharedWorker,
-        MakeGarbageCollected<MockFetchContext>(),
+        fetch_params, std::move(worker_main_script_load_params),
+        MakeGarbageCollected<MockFetchContext>(), observer,
         blink::CrossVariantMojoRemote<
             blink::mojom::ResourceLoadInfoNotifierInterfaceBase>(
             std::move(pending_remote)),
@@ -214,7 +260,6 @@ class WorkerMainScriptLoaderTest : public testing::Test {
   mojo::Remote<network::mojom::URLLoaderClient> loader_client_;
   FakeURLLoader fake_loader_;
 
-  ResourceLoaderOptions options_;
   Persistent<TestClient> client_;
   base::test::ScopedFeatureList scoped_feature_list_;
 };
@@ -228,10 +273,16 @@ TEST_F(WorkerMainScriptLoaderTest, ResponseWithSucessThenOnComplete) {
   std::unique_ptr<WorkerMainScriptLoadParameters>
       worker_main_script_load_params =
           CreateMainScriptLoaderParams(kHeader, &body_producer);
-
+  MockResourceLoadObserver* mock_observer =
+      MakeGarbageCollected<MockResourceLoadObserver>();
+  EXPECT_CALL(*mock_observer, WillSendRequest(_, _, _, _, _));
+  EXPECT_CALL(*mock_observer, DidReceiveResponse(_, _, _, _, _));
+  EXPECT_CALL(*mock_observer, DidReceiveData(_, _));
+  EXPECT_CALL(*mock_observer, DidFinishLoading(_, _, _, _, _));
+  EXPECT_CALL(*mock_observer, DidFailLoading(_, _, _, _, _)).Times(0);
   Persistent<WorkerMainScriptLoader> worker_main_script_loader =
       CreateWorkerMainScriptLoaderAndStartLoading(
-          std::move(worker_main_script_load_params),
+          std::move(worker_main_script_load_params), mock_observer,
           std::move(pending_resource_load_info_notifier));
   mojo::BlockingCopyFromString(kTopLevelScript, body_producer);
   body_producer.reset();
@@ -256,10 +307,15 @@ TEST_F(WorkerMainScriptLoaderTest, ResponseWithFailureThenOnComplete) {
   std::unique_ptr<WorkerMainScriptLoadParameters>
       worker_main_script_load_params =
           CreateMainScriptLoaderParams(kFailHeader, &body_producer);
-
+  MockResourceLoadObserver* mock_observer =
+      MakeGarbageCollected<MockResourceLoadObserver>();
+  EXPECT_CALL(*mock_observer, WillSendRequest(_, _, _, _, _));
+  EXPECT_CALL(*mock_observer, DidReceiveResponse(_, _, _, _, _));
+  EXPECT_CALL(*mock_observer, DidFinishLoading(_, _, _, _, _)).Times(0);
+  EXPECT_CALL(*mock_observer, DidFailLoading(_, _, _, _, _));
   Persistent<WorkerMainScriptLoader> worker_main_script_loader =
       CreateWorkerMainScriptLoaderAndStartLoading(
-          std::move(worker_main_script_load_params),
+          std::move(worker_main_script_load_params), mock_observer,
           std::move(pending_resource_load_info_notifier));
   mojo::BlockingCopyFromString("PAGE NOT FOUND\n", body_producer);
   Complete(net::OK);
@@ -278,10 +334,15 @@ TEST_F(WorkerMainScriptLoaderTest, DisconnectBeforeOnComplete) {
   std::unique_ptr<WorkerMainScriptLoadParameters>
       worker_main_script_load_params =
           CreateMainScriptLoaderParams(kHeader, &body_producer);
-
+  MockResourceLoadObserver* mock_observer =
+      MakeGarbageCollected<MockResourceLoadObserver>();
+  EXPECT_CALL(*mock_observer, WillSendRequest(_, _, _, _, _));
+  EXPECT_CALL(*mock_observer, DidReceiveResponse(_, _, _, _, _));
+  EXPECT_CALL(*mock_observer, DidFinishLoading(_, _, _, _, _)).Times(0);
+  EXPECT_CALL(*mock_observer, DidFailLoading(_, _, _, _, _));
   Persistent<WorkerMainScriptLoader> worker_main_script_loader =
       CreateWorkerMainScriptLoaderAndStartLoading(
-          std::move(worker_main_script_load_params),
+          std::move(worker_main_script_load_params), mock_observer,
           std::move(pending_resource_load_info_notifier));
   loader_client_.reset();
   body_producer.reset();
@@ -300,10 +361,16 @@ TEST_F(WorkerMainScriptLoaderTest, OnCompleteWithError) {
   std::unique_ptr<WorkerMainScriptLoadParameters>
       worker_main_script_load_params =
           CreateMainScriptLoaderParams(kHeader, &body_producer);
-
+  MockResourceLoadObserver* mock_observer =
+      MakeGarbageCollected<MockResourceLoadObserver>();
+  EXPECT_CALL(*mock_observer, WillSendRequest(_, _, _, _, _));
+  EXPECT_CALL(*mock_observer, DidReceiveResponse(_, _, _, _, _));
+  EXPECT_CALL(*mock_observer, DidReceiveData(_, _));
+  EXPECT_CALL(*mock_observer, DidFinishLoading(_, _, _, _, _)).Times(0);
+  EXPECT_CALL(*mock_observer, DidFailLoading(_, _, _, _, _));
   Persistent<WorkerMainScriptLoader> worker_main_script_loader =
       CreateWorkerMainScriptLoaderAndStartLoading(
-          std::move(worker_main_script_load_params),
+          std::move(worker_main_script_load_params), mock_observer,
           std::move(pending_resource_load_info_notifier));
   mojo::BlockingCopyFromString(kTopLevelScript, body_producer);
   Complete(net::ERR_FAILED);