service worker: Remove ServiceWorkerAggressiveCodeCache feature

We've concluded that we won't actively pursue this feature as we
weren't able to see performance improvements.

Bug: 915081
Change-Id: I0a6a804b4fbc613dc8b8c7abff64e4d4d21419df
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1828726
Commit-Queue: Kenichi Ishibashi <bashi@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#701024}

content/browser/service_worker/service_worker_browsertest.cc

@@ -91,7 +91,6 @@
 #include "storage/browser/blob/blob_handle.h"
 #include "storage/browser/blob/blob_reader.h"
 #include "storage/browser/blob/blob_storage_context.h"
-#include "third_party/blink/public/common/features.h"
 #include "third_party/blink/public/common/loader/url_loader_throttle.h"
 #include "third_party/blink/public/common/service_worker/service_worker_status_code.h"
 #include "third_party/blink/public/common/service_worker/service_worker_type_converters.h"
@@ -3506,180 +3505,6 @@ IN_PROC_BROWSER_TEST_F(ServiceWorkerV8CodeCacheForCacheStorageNoneTest,
   WaitUntilSideDataSizeIs(0);
 }
 
-class ServiceWorkerCodeCacheStrategyTestBase : public ServiceWorkerBrowserTest {
- public:
-  ServiceWorkerCodeCacheStrategyTestBase() = default;
-  ~ServiceWorkerCodeCacheStrategyTestBase() override = default;
-
- protected:
-  static const char kWorkerUrl[];
-  static const char kPageUrl[];
-  static const char kCachedInInstallEventUrl[];
-  static const char kCachedInInstallEventWithMimeTypeParamUrl[];
-  static const char kCachedInFetchEventUrl[];
-  static const char kCachedInMessageEventUrl[];
-
-  void RegisterAndActivateServiceWorker() {
-    auto observer = base::MakeRefCounted<WorkerActivatedObserver>(wrapper());
-    observer->Init();
-    blink::mojom::ServiceWorkerRegistrationOptions options(
-        embedded_test_server()->GetURL(kPageUrl),
-        blink::mojom::ScriptType::kClassic,
-        blink::mojom::ServiceWorkerUpdateViaCache::kImports);
-    public_context()->RegisterServiceWorker(
-        embedded_test_server()->GetURL(kWorkerUrl), options,
-        base::BindOnce(&ExpectResultAndRun, true, base::DoNothing()));
-    observer->Wait();
-  }
-
-  void NavigateToTestPage() {
-    StartServerAndNavigateToSetup();
-    RegisterAndActivateServiceWorker();
-    EXPECT_TRUE(
-        NavigateToURL(shell(), embedded_test_server()->GetURL(kPageUrl)));
-  }
-
-  void InitiateEventsToCacheScript() {
-    // Fetch a test script in the page. The service worker will put the
-    // response into CacheStorage in the fetch event handler.
-    EXPECT_EQ("DONE", EvalJs(shell(),
-                             "fetch_script('code_cache_strategy_test_script.js?"
-                             "cached_in_fetch_event');"));
-    // Post a message to the service worker to put the response of the test
-    // script into CacheStorage in the message event handler.
-    EXPECT_EQ("DONE", EvalJs(shell(),
-                             "post_message('cache_script_in_message_event');"));
-  }
-
-  CacheStorageContextImpl* GetCacheStorageContextImpl() {
-    StoragePartition* partition = BrowserContext::GetDefaultStoragePartition(
-        shell()->web_contents()->GetBrowserContext());
-    return static_cast<CacheStorageContextImpl*>(
-        partition->GetCacheStorageContext());
-  }
-
-  bool HasSideData(const std::string& path) {
-    int size = CacheStorageSideDataSizeChecker::GetSize(
-        GetCacheStorageContextImpl(), embedded_test_server()->base_url(),
-        std::string("cache_name"), embedded_test_server()->GetURL(path));
-    return size > 0;
-  }
-
-  void WaitForSideData(const std::string& path) {
-    while (true) {
-      if (HasSideData(path))
-        return;
-    }
-  }
-
-  base::test::ScopedFeatureList feature_list_;
-
-  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerCodeCacheStrategyTestBase);
-};
-
-const char ServiceWorkerCodeCacheStrategyTestBase::kPageUrl[] =
-    "/service_worker/code_cache_strategy.html";
-const char ServiceWorkerCodeCacheStrategyTestBase::kWorkerUrl[] =
-    "/service_worker/code_cache_strategy_worker.js";
-const char ServiceWorkerCodeCacheStrategyTestBase::kCachedInInstallEventUrl[] =
-    "/service_worker/"
-    "code_cache_strategy_test_script.js?cached_in_install_event";
-const char ServiceWorkerCodeCacheStrategyTestBase::
-    kCachedInInstallEventWithMimeTypeParamUrl[] =
-        "/service_worker/"
-        "code_cache_strategy_test_script.js?cached_in_install_event_with_mime_"
-        "type_param";
-const char ServiceWorkerCodeCacheStrategyTestBase::kCachedInFetchEventUrl[] =
-    "/service_worker/code_cache_strategy_test_script.js?cached_in_fetch_event";
-const char ServiceWorkerCodeCacheStrategyTestBase::kCachedInMessageEventUrl[] =
-    "/service_worker/"
-    "code_cache_strategy_test_script.js?cached_in_message_event";
-
-class ServiceWorkerCodeCacheStrategyDontGenerateTest
-    : public ServiceWorkerCodeCacheStrategyTestBase {
- public:
-  void SetUp() override {
-    feature_list_.InitAndEnableFeatureWithParameters(
-        blink::features::kServiceWorkerAggressiveCodeCache,
-        {{blink::kServiceWorkerEagerCodeCacheStrategy, "dontgenerate"}});
-    ServiceWorkerCodeCacheStrategyTestBase::SetUp();
-  }
-};
-
-IN_PROC_BROWSER_TEST_F(ServiceWorkerCodeCacheStrategyDontGenerateTest,
-                       DontGenerate) {
-  NavigateToTestPage();
-  InitiateEventsToCacheScript();
-  EXPECT_FALSE(HasSideData(kCachedInInstallEventUrl));
-  EXPECT_FALSE(HasSideData(kCachedInInstallEventWithMimeTypeParamUrl));
-  EXPECT_FALSE(HasSideData(kCachedInFetchEventUrl));
-  EXPECT_FALSE(HasSideData(kCachedInMessageEventUrl));
-}
-
-class ServiceWorkerCodeCacheStrategyInstallEventTest
-    : public ServiceWorkerCodeCacheStrategyTestBase {
- public:
-  void SetUp() override {
-    feature_list_.InitAndEnableFeatureWithParameters(
-        blink::features::kServiceWorkerAggressiveCodeCache,
-        {{blink::kServiceWorkerEagerCodeCacheStrategy, "installevent"}});
-    ServiceWorkerCodeCacheStrategyTestBase::SetUp();
-  }
-};
-
-IN_PROC_BROWSER_TEST_F(ServiceWorkerCodeCacheStrategyInstallEventTest,
-                       GenerateInInstallEvent) {
-  NavigateToTestPage();
-  InitiateEventsToCacheScript();
-  EXPECT_TRUE(HasSideData(kCachedInInstallEventUrl));
-  EXPECT_TRUE(HasSideData(kCachedInInstallEventWithMimeTypeParamUrl));
-  EXPECT_FALSE(HasSideData(kCachedInFetchEventUrl));
-  EXPECT_FALSE(HasSideData(kCachedInMessageEventUrl));
-}
-
-class ServiceWorkerCodeCacheStrategyIdleTaskTest
-    : public ServiceWorkerCodeCacheStrategyTestBase {
- public:
-  void SetUp() override {
-    feature_list_.InitAndEnableFeatureWithParameters(
-        blink::features::kServiceWorkerAggressiveCodeCache,
-        {{blink::kServiceWorkerEagerCodeCacheStrategy, "idletask"}});
-    ServiceWorkerCodeCacheStrategyTestBase::SetUp();
-  }
-};
-
-IN_PROC_BROWSER_TEST_F(ServiceWorkerCodeCacheStrategyIdleTaskTest,
-                       GenerateInIdleTask) {
-  NavigateToTestPage();
-  InitiateEventsToCacheScript();
-  EXPECT_TRUE(HasSideData(kCachedInInstallEventUrl));
-  EXPECT_TRUE(HasSideData(kCachedInInstallEventWithMimeTypeParamUrl));
-  // These should not time out.
-  WaitForSideData(kCachedInFetchEventUrl);
-  WaitForSideData(kCachedInMessageEventUrl);
-}
-
-// Test that generating and storing code cache in idle tasks doesn't corrupt
-// cache entry when Cache#put() is called twice asynchronously.
-IN_PROC_BROWSER_TEST_F(ServiceWorkerCodeCacheStrategyIdleTaskTest,
-                       CacheScriptTwice) {
-  const char kCachedTwiceUrl[] =
-      "/service_worker/code_cache_strategy_test_script.js?cached_twice";
-
-  NavigateToTestPage();
-
-  // Ask the service worker to call Cache#put() twice asynchronously.
-  // The first response is a dummy script that contains no function.
-  // The second response is an actual script that contains |test_function()|.
-  EXPECT_EQ("DONE", EvalJs(shell(), "post_message('cache_script_twice');"));
-
-  WaitForSideData(kCachedTwiceUrl);
-
-  // Ask the page to load the test script and execute |test_function()|, which
-  // will return "SUCCESS".
-  EXPECT_EQ("SUCCESS", EvalJs(shell(), "execute_cached_twice_script();"));
-}
-
 // ServiceWorkerDisableWebSecurityTests check the behavior when the web security
 // is disabled. If '--disable-web-security' flag is set, we don't check the
 // origin equality in Blink. So the Service Worker related APIs should succeed

content/test/data/service_worker/code_cache_strategy.html

-<html>
-<title>Code cache strategy test</title>
-<script>
-async function fetch_script(url) {
-  try {
-    await fetch(url).then(res => res.text());
-    return 'DONE';
-  } catch (error) {
-    return `${error}`;
-  }
-}
-
-async function post_message(command) {
-  return new Promise(resolve => {
-    let listener = (e) => {
-      navigator.serviceWorker.removeEventListener('message', listener);
-      resolve(e.data);
-    };
-    navigator.serviceWorker.addEventListener('message', listener);
-    navigator.serviceWorker.controller.postMessage({ command: command });
-  });
-}
-
-async function execute_cached_twice_script() {
-  return new Promise(resolve => {
-    const tag = document.createElement('script');
-    tag.src = 'code_cache_strategy_test_script.js?cached_twice';
-    tag.onload = () => {
-      const result = test_function();
-      resolve(result);
-    };
-    document.body.appendChild(tag);
-  });
-}
-</script>
-</html>

content/test/data/service_worker/code_cache_strategy_test_script.js

-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-function test_function() {
-  return 'SUCCESS';
-}

content/test/data/service_worker/code_cache_strategy_worker.js

-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-const CACHE_NAME = 'cache_name';
-const SCRIPT_PATH = 'code_cache_strategy_test_script.js';
-
-async function get_from_cache_or_fetch(request) {
-  const cache = await caches.open(CACHE_NAME);
-  const cached = await cache.match(request);
-  if (cached) {
-    return cached;
-  }
-  const response = await fetch(request);
-  await cache.put(request, response.clone());
-  return response;
-}
-
-async function cache_script_in_message_event(source) {
-  const cache = await caches.open(CACHE_NAME);
-  await cache.add(`${SCRIPT_PATH}?cached_in_message_event`);
-  source.postMessage('DONE');
-}
-
-async function cache_script_twice(source) {
-  const cache = await caches.open(CACHE_NAME);
-  const url = `${SCRIPT_PATH}?cached_twice`;
-  const response = await fetch(url);
-  const dummy_response = new Response('/* dummy script */', {
-    headers: {
-      'Content-Type': 'application/javascript'
-    }
-  });
-
-  // 1st step: put synthesized response without await.
-  cache.put(url, dummy_response);
-  // 2nd step: put the actual response.
-  await cache.put(url, response);
-  source.postMessage('DONE');
-}
-
-self.addEventListener('install', e => {
-  e.waitUntil(async function() {
-    const cache = await caches.open(CACHE_NAME);
-    await cache.addAll([
-      `${SCRIPT_PATH}?cached_in_install_event`,
-    ]);
-
-    // Create a synthetic response with a mime-type that has a charset
-    const script_body = "function test_function() { return 'SUCCESS'; }";
-    const response = new Response(script_body, {
-      headers: { 'content-type': 'application/javascript; charset=utf-8' }
-    });
-    await cache.put(
-        `${SCRIPT_PATH}?cached_in_install_event_with_mime_type_param`,
-        response);
-  }());
-});
-
-self.addEventListener('fetch', e => {
-  const url = e.request.url;
-  if (url.indexOf('cached_in_fetch_event') >= 0) {
-    e.respondWith(get_from_cache_or_fetch(e.request));
-  }
-});
-
-self.addEventListener('message', e => {
-  const command = e.data.command;
-  if (command === 'cache_script_in_message_event') {
-    cache_script_in_message_event(e.source);
-  } else if (command === 'cache_script_twice') {
-    cache_script_twice(e.source);
-  }
-});

third_party/blink/common/features.cc

@@ -198,9 +198,6 @@ const base::Feature kServiceWorkerIsolateInForeground{
 const base::Feature kServiceWorkerImportedScriptUpdateCheck{
     "ServiceWorkerImportedScriptUpdateCheck", base::FEATURE_ENABLED_BY_DEFAULT};
 
-const base::Feature kServiceWorkerAggressiveCodeCache{
-    "ServiceWorkerAggressiveCodeCache", base::FEATURE_DISABLED_BY_DEFAULT};
-
 // Experiment of the delay from navigation to starting an update of a service
 // worker's script.
 const base::Feature kServiceWorkerUpdateDelay{

third_party/blink/common/service_worker/service_worker_utils.cc

@@ -5,37 +5,13 @@
 #include "third_party/blink/public/common/service_worker/service_worker_utils.h"
 
 #include "base/feature_list.h"
-#include "base/metrics/field_trial_params.h"
 #include "third_party/blink/public/common/features.h"
 
 namespace blink {
 
-const char kServiceWorkerEagerCodeCacheStrategy[] = "sw_cache_strategy";
-
-namespace {
-
-constexpr base::FeatureParam<EagerCodeCacheStrategy>::Option
-    kEagerCodeCacheStrategyOptions[] = {
-        {EagerCodeCacheStrategy::kDontGenerate, "dontgenerate"},
-        {EagerCodeCacheStrategy::kDuringInstallEvent, "installevent"},
-        {EagerCodeCacheStrategy::kOnIdleTask, "idletask"},
-};
-
-constexpr base::FeatureParam<EagerCodeCacheStrategy>
-    kEagerCodeCacheStrategyParam{&features::kServiceWorkerAggressiveCodeCache,
-                                 "sw_cache_strategy",
-                                 EagerCodeCacheStrategy::kDuringInstallEvent,
-                                 &kEagerCodeCacheStrategyOptions};
-
-}  // namespace
-
 bool ServiceWorkerUtils::IsImportedScriptUpdateCheckEnabled() {
   return base::FeatureList::IsEnabled(
       blink::features::kServiceWorkerImportedScriptUpdateCheck);
 }
 
-EagerCodeCacheStrategy ServiceWorkerUtils::GetEagerCodeCacheStrategy() {
-  return kEagerCodeCacheStrategyParam.Get();
-}
-
 }  // namespace blink

third_party/blink/public/common/features.h

@@ -59,8 +59,6 @@ BLINK_COMMON_EXPORT extern const base::Feature
     kServiceWorkerIsolateInForeground;
 BLINK_COMMON_EXPORT extern const base::Feature
     kServiceWorkerImportedScriptUpdateCheck;
-BLINK_COMMON_EXPORT extern const base::Feature
-    kServiceWorkerAggressiveCodeCache;
 BLINK_COMMON_EXPORT extern const base::Feature kServiceWorkerUpdateDelay;
 BLINK_COMMON_EXPORT extern const base::Feature kStopInBackground;
 BLINK_COMMON_EXPORT extern const base::Feature

third_party/blink/renderer/modules/cache_storage/cache.cc

@@ -7,12 +7,9 @@
 #include <memory>
 #include <utility>
 
-#include "base/feature_list.h"
 #include "base/optional.h"
 #include "services/network/public/mojom/fetch_api.mojom-blink.h"
 #include "third_party/blink/public/common/cache_storage/cache_storage_utils.h"
-#include "third_party/blink/public/common/features.h"
-#include "third_party/blink/public/common/service_worker/service_worker_utils.h"
 #include "third_party/blink/public/mojom/cache_storage/cache_storage.mojom-blink.h"
 #include "third_party/blink/renderer/bindings/core/v8/callback_promise_adapter.h"
 #include "third_party/blink/renderer/bindings/core/v8/idl_types.h"
@@ -48,7 +45,6 @@
 #include "third_party/blink/renderer/platform/network/http_parsers.h"
 #include "third_party/blink/renderer/platform/network/mime/mime_type_registry.h"
 #include "third_party/blink/renderer/platform/runtime_enabled_features.h"
-#include "third_party/blink/renderer/platform/scheduler/worker/worker_thread_scheduler.h"
 #include "third_party/blink/renderer/platform/wtf/text/string_builder.h"
 
 namespace blink {
@@ -76,38 +72,22 @@ bool HasJavascriptMimeType(const Response* response) {
   return MIMETypeRegistry::IsSupportedJavaScriptMIMEType(mime_type);
 }
 
-enum class CodeCacheGenerateTiming {
-  kDontGenerate,
-  kGenerateNow,
-  kGenerateWhenIdle,
-};
-
-CodeCacheGenerateTiming ShouldGenerateV8CodeCache(ScriptState* script_state,
+bool ShouldGenerateV8CodeCache(ScriptState* script_state,
                                const Response* response) {
-  EagerCodeCacheStrategy strategy =
-      ServiceWorkerUtils::GetEagerCodeCacheStrategy();
-  if (strategy == EagerCodeCacheStrategy::kDontGenerate)
-    return CodeCacheGenerateTiming::kDontGenerate;
-
   ExecutionContext* context = ExecutionContext::From(script_state);
   auto* global_scope = DynamicTo<ServiceWorkerGlobalScope>(context);
   if (!global_scope)
-    return CodeCacheGenerateTiming::kDontGenerate;
+    return false;
+
+  if (!global_scope->IsInstalling())
+    return false;
 
   if (!HasJavascriptMimeType(response))
-    return CodeCacheGenerateTiming::kDontGenerate;
+    return false;
 
   if (!response->InternalBodyBuffer())
-    return CodeCacheGenerateTiming::kDontGenerate;
-
-  if (global_scope->IsInstalling())
-    return CodeCacheGenerateTiming::kGenerateNow;
-
-  if (strategy == EagerCodeCacheStrategy::kOnIdleTask) {
-    return CodeCacheGenerateTiming::kGenerateWhenIdle;
-  }
-
-  return CodeCacheGenerateTiming::kDontGenerate;
+    return false;
+  return true;
 }
 
 }  // namespace
@@ -406,27 +386,19 @@ class Cache::CodeCacheHandleCallbackForPut final
 
  public:
   CodeCacheHandleCallbackForPut(ScriptState* script_state,
-                                Cache* cache,
                                 wtf_size_t index,
                                 BarrierCallbackForPut* barrier_callback,
                                 Request* request,
                                 Response* response,
-                                CodeCacheGenerateTiming timing,
                                 int64_t trace_id)
       : script_state_(script_state),
-        cache_(cache),
         index_(index),
         barrier_callback_(barrier_callback),
         mime_type_(response->InternalMIMEType()),
-        timing_(timing),
         trace_id_(trace_id) {
     fetch_api_request_ = request->CreateFetchAPIRequest();
     fetch_api_response_ = response->PopulateFetchAPIResponse();
     url_ = fetch_api_request_->url;
-    opaque_mode_ = fetch_api_response_->response_type ==
-                           network::mojom::FetchResponseType::kOpaque
-                       ? V8CodeCache::OpaqueMode::kOpaque
-                       : V8CodeCache::OpaqueMode::kNotOpaque;
   }
   ~CodeCacheHandleCallbackForPut() override = default;
 
@@ -437,7 +409,6 @@ class Cache::CodeCacheHandleCallbackForPut final
         TRACE_ID_GLOBAL(trace_id_),
         TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT, "url",
         CacheStorageTracedValue(url_.GetString()));
-    base::Time response_time = fetch_api_response_->response_time;
     mojom::blink::BatchOperationPtr batch_operation =
         mojom::blink::BatchOperation::New();
     batch_operation->operation_type = mojom::blink::OperationType::kPut;
@@ -450,7 +421,6 @@ class Cache::CodeCacheHandleCallbackForPut final
     batch_operation->response->blob = BlobDataHandle::Create(
         std::move(blob_data), array_buffer->ByteLength());
 
-    if (timing_ == CodeCacheGenerateTiming::kGenerateNow) {
     scoped_refptr<CachedMetadata> cached_metadata =
         GenerateFullCodeCache(array_buffer);
     if (cached_metadata) {
@@ -463,21 +433,6 @@ class Cache::CodeCacheHandleCallbackForPut final
       batch_operation->response->side_data_blob = BlobDataHandle::Create(
           std::move(side_data_blob_data), serialized_data.size());
     }
-    } else {
-      // Schedule an idle task to generate code cache later.
-      ServiceWorkerGlobalScope* global_scope = GetServiceWorkerGlobalScope();
-      if (global_scope) {
-        auto* thread_scheduler =
-            global_scope->GetScheduler()->GetWorkerThreadScheduler();
-        DCHECK(thread_scheduler);
-        int task_id = global_scope->WillStartTask();
-        thread_scheduler->IdleTaskRunner()->PostIdleTask(
-            FROM_HERE, WTF::Bind(&Cache::CodeCacheHandleCallbackForPut::
-                                     GenerateCodeCacheOnIdleTask,
-                                 WrapPersistent(this), task_id,
-                                 WrapPersistent(array_buffer), response_time));
-      }
-    }
 
     barrier_callback_->OnSuccess(index_, std::move(batch_operation));
   }
@@ -490,7 +445,6 @@ class Cache::CodeCacheHandleCallbackForPut final
 
   void Trace(blink::Visitor* visitor) override {
     visitor->Trace(script_state_);
-    visitor->Trace(cache_);
     visitor->Trace(barrier_callback_);
     FetchDataLoader::Client::Trace(visitor);
   }
@@ -528,45 +482,12 @@ class Cache::CodeCacheHandleCallbackForPut final
         url_, text_decoder->Encoding(), opaque_mode_);
   }
 
-  void GenerateCodeCacheOnIdleTask(int task_id,
-                                   DOMArrayBuffer* array_buffer,
-                                   base::Time response_time,
-                                   base::TimeTicks) {
-    TRACE_EVENT_WITH_FLOW1(
-        "CacheStorage",
-        "Cache::CodeCacheHandleCallbackForPut::GenerateCodeCacheOnIdleTask",
-        TRACE_ID_GLOBAL(trace_id_),
-        TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT, "url",
-        CacheStorageTracedValue(url_.GetString()));
-
-    ServiceWorkerGlobalScope* global_scope = GetServiceWorkerGlobalScope();
-    if (!global_scope)
-      return;
-
-    scoped_refptr<CachedMetadata> cached_metadata =
-        GenerateFullCodeCache(array_buffer);
-    if (!cached_metadata) {
-      global_scope->DidEndTask(task_id);
-      return;
-    }
-    cache_->cache_remote_->SetSideData(
-        url_, response_time, cached_metadata->SerializedData(), trace_id_,
-        WTF::Bind(
-            [](ServiceWorkerGlobalScope* global_scope, int task_id,
-               mojom::blink::CacheStorageError error) {
-              global_scope->DidEndTask(task_id);
-            },
-            WrapPersistent(global_scope), task_id));
-  }
-
   const Member<ScriptState> script_state_;
-  const Member<Cache> cache_;
   const wtf_size_t index_;
   Member<BarrierCallbackForPut> barrier_callback_;
   const String mime_type_;
   KURL url_;
   V8CodeCache::OpaqueMode opaque_mode_;
-  CodeCacheGenerateTiming timing_;
   const int64_t trace_id_;
 
   mojom::blink::FetchAPIRequestPtr fetch_api_request_;
@@ -1014,15 +935,12 @@ ScriptPromise Cache::PutImpl(ScriptState* script_state,
 
     BodyStreamBuffer* buffer = responses[i]->InternalBodyBuffer();
 
-    CodeCacheGenerateTiming cache_generate_timing =
-        ShouldGenerateV8CodeCache(script_state, responses[i]);
-    if (cache_generate_timing != CodeCacheGenerateTiming::kDontGenerate) {
+    if (ShouldGenerateV8CodeCache(script_state, responses[i])) {
       FetchDataLoader* loader = FetchDataLoader::CreateLoaderAsArrayBuffer();
-      buffer->StartLoading(
-          loader,
+      buffer->StartLoading(loader,
                            MakeGarbageCollected<CodeCacheHandleCallbackForPut>(
-              script_state, this, i, barrier_callback, requests[i],
-              responses[i], cache_generate_timing, trace_id),
+                               script_state, i, barrier_callback, requests[i],
+                               responses[i], trace_id),
                            exception_state);
       if (exception_state.HadException()) {
         barrier_callback->OnError("Could not inspect response body state");