Compilation cache: do not pass |compile_options| into the ProduceCache.

The only reason it was there was for the trace, where it was misinterpreted.

Change-Id: If1fe338516ecc1a72984ab7ec16cd3fb58cd779b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1495870
Commit-Queue: Pavel Feldman <pfeldman@chromium.org>
Reviewed-by: Hiroshige Hayashizaki <hiroshige@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Cr-Commit-Position: refs/heads/master@{#637564}

third_party/blink/renderer/bindings/core/v8/script_controller.cc

@@ -135,7 +135,7 @@ v8::Local<v8::Value> ScriptController::ExecuteScriptAndReturnValue(
                                                      GetFrame()->GetDocument());
     probe::ProduceCompilationCache(frame_, source, script);
     V8CodeCache::ProduceCache(GetIsolate(), script, source,
-                              produce_cache_options, compile_options);
+                              produce_cache_options);
 
     if (!maybe_result.ToLocal(&result)) {
       return result;

third_party/blink/renderer/bindings/core/v8/script_module.cc

@@ -20,11 +20,9 @@ namespace blink {
 ScriptModuleProduceCacheData::ScriptModuleProduceCacheData(
     v8::Isolate* isolate,
     SingleCachedMetadataHandler* cache_handler,
-    v8::ScriptCompiler::CompileOptions compile_options,
     V8CodeCache::ProduceCacheOptions produce_cache_options,
     v8::Local<v8::Module> module)
     : cache_handler_(cache_handler),
-      compile_options_(compile_options),
       produce_cache_options_(produce_cache_options) {
   v8::HandleScope scope(isolate);
 
@@ -99,8 +97,7 @@ ScriptModule ScriptModule::Compile(
   if (out_produce_cache_data) {
     *out_produce_cache_data =
         MakeGarbageCollected<ScriptModuleProduceCacheData>(
-            isolate, cache_handler, compile_options, produce_cache_options,
-            module);
+            isolate, cache_handler, produce_cache_options, module);
   }
 
   return ScriptModule(isolate, module, source_url);

third_party/blink/renderer/bindings/core/v8/script_module.h

@@ -32,16 +32,12 @@ class CORE_EXPORT ScriptModuleProduceCacheData final
  public:
   ScriptModuleProduceCacheData(v8::Isolate*,
                                SingleCachedMetadataHandler*,
-                               v8::ScriptCompiler::CompileOptions,
                                V8CodeCache::ProduceCacheOptions,
                                v8::Local<v8::Module>);
 
   void Trace(blink::Visitor*);
 
   SingleCachedMetadataHandler* CacheHandler() const { return cache_handler_; }
-  v8::ScriptCompiler::CompileOptions GetCompileOptions() const {
-    return compile_options_;
-  }
   V8CodeCache::ProduceCacheOptions GetProduceCacheOptions() const {
     return produce_cache_options_;
   }
@@ -51,8 +47,6 @@ class CORE_EXPORT ScriptModuleProduceCacheData final
 
  private:
   Member<SingleCachedMetadataHandler> cache_handler_;
-
-  v8::ScriptCompiler::CompileOptions compile_options_;
   V8CodeCache::ProduceCacheOptions produce_cache_options_;
 
   // TODO(keishi): Visitor only defines a trace method for v8::Value so this

third_party/blink/renderer/bindings/core/v8/v8_code_cache.cc

@@ -203,7 +203,6 @@ static void ProduceCacheInternal(
     bool is_streamed,
     const char* trace_name,
     V8CodeCache::ProduceCacheOptions produce_cache_options,
-    v8::ScriptCompiler::CompileOptions compile_options,
     ScriptStreamer::NotStreamingReason not_streaming_reason) {
   TRACE_EVENT0("v8", trace_name);
   RuntimeCallStatsScopedTracer rcs_scoped_tracer(isolate);
@@ -245,7 +244,7 @@ static void ProduceCacheInternal(
               source_url.GetString(), source_start_position,
               inspector_compile_script_event::V8CacheResult(
                   inspector_compile_script_event::V8CacheResult::ProduceResult(
-                      compile_options, cached_data ? cached_data->length : 0),
+                      cached_data ? cached_data->length : 0),
                   base::Optional<inspector_compile_script_event::V8CacheResult::
                                      ConsumeResult>()),
               is_streamed, not_streaming_reason));
@@ -256,16 +255,14 @@ static void ProduceCacheInternal(
   }
 }
 
-void V8CodeCache::ProduceCache(
-    v8::Isolate* isolate,
-    v8::Local<v8::Script> script,
-    const ScriptSourceCode& source,
-    ProduceCacheOptions produce_cache_options,
-    v8::ScriptCompiler::CompileOptions compile_options) {
+void V8CodeCache::ProduceCache(v8::Isolate* isolate,
+                               v8::Local<v8::Script> script,
+                               const ScriptSourceCode& source,
+                               ProduceCacheOptions produce_cache_options) {
   ProduceCacheInternal(isolate, script->GetUnboundScript(),
                        source.CacheHandler(), source.Source().length(),
                        source.Url(), source.StartPosition(), source.Streamer(),
-                       "v8.compile", produce_cache_options, compile_options,
+                       "v8.compile", produce_cache_options,
                        source.NotStreamingReason());
 }
 
@@ -274,12 +271,12 @@ void V8CodeCache::ProduceCache(v8::Isolate* isolate,
                                size_t source_text_length,
                                const KURL& source_url,
                                const TextPosition& source_start_position) {
-  ProduceCacheInternal(
-      isolate, produce_cache_data->UnboundScript(isolate),
-      produce_cache_data->CacheHandler(), source_text_length, source_url,
-      source_start_position, false, "v8.compileModule",
-      produce_cache_data->GetProduceCacheOptions(),
-      produce_cache_data->GetCompileOptions(), ScriptStreamer::kModuleScript);
+  ProduceCacheInternal(isolate, produce_cache_data->UnboundScript(isolate),
+                       produce_cache_data->CacheHandler(), source_text_length,
+                       source_url, source_start_position, false,
+                       "v8.compileModule",
+                       produce_cache_data->GetProduceCacheOptions(),
+                       ScriptStreamer::kModuleScript);
 }
 
 uint32_t V8CodeCache::TagForCodeCache(
@@ -358,7 +355,6 @@ scoped_refptr<CachedMetadata> V8CodeCache::GenerateFullCodeCache(
           file_name, TextPosition(),
           inspector_compile_script_event::V8CacheResult(
               inspector_compile_script_event::V8CacheResult::ProduceResult(
-                  v8::ScriptCompiler::kEagerCompile,
                   cached_data ? cached_data->length : 0),
               base::Optional<inspector_compile_script_event::V8CacheResult::
                                  ConsumeResult>()),

third_party/blink/renderer/bindings/core/v8/v8_code_cache.h

@@ -70,8 +70,7 @@ class CORE_EXPORT V8CodeCache final {
   static void ProduceCache(v8::Isolate*,
                            v8::Local<v8::Script>,
                            const ScriptSourceCode&,
-                           ProduceCacheOptions,
-                           v8::ScriptCompiler::CompileOptions);
+                           ProduceCacheOptions);
   static void ProduceCache(v8::Isolate*,
                            ScriptModuleProduceCacheData*,
                            size_t source_text_length,

third_party/blink/renderer/bindings/core/v8/v8_script_runner_test.cc

@@ -69,8 +69,7 @@ class V8ScriptRunnerTest : public testing::Test {
       return false;
     }
     V8CodeCache::ProduceCache(isolate, compiled_script.ToLocalChecked(),
-                              source_code, produce_cache_options,
-                              compile_options);
+                              source_code, produce_cache_options);
     return true;
   }
 
@@ -87,8 +86,7 @@ class V8ScriptRunnerTest : public testing::Test {
       return false;
     }
     V8CodeCache::ProduceCache(isolate, compiled_script.ToLocalChecked(),
-                              source_code, produce_cache_options,
-                              compile_options);
+                              source_code, produce_cache_options);
     return true;
   }
 

third_party/blink/renderer/bindings/core/v8/worker_or_worklet_script_controller.cc

@@ -283,7 +283,7 @@ ScriptValue WorkerOrWorkletScriptController::EvaluateInternal(
     maybe_result = V8ScriptRunner::RunCompiledScript(isolate_, compiled_script,
                                                      global_scope_);
     V8CodeCache::ProduceCache(isolate_, compiled_script, source_code,
-                              produce_cache_options, compile_options);
+                              produce_cache_options);
   }
 
   if (!block.CanContinue()) {

third_party/blink/renderer/core/inspector/inspector_trace_events.cc

@@ -1145,12 +1145,8 @@ std::unique_ptr<TracedValue> inspector_parse_script_event::Data(
 }
 
 inspector_compile_script_event::V8CacheResult::ProduceResult::ProduceResult(
-    v8::ScriptCompiler::CompileOptions produce_options,
     int cache_size)
-    : produce_options(produce_options), cache_size(cache_size) {
-  DCHECK(produce_options == v8::ScriptCompiler::kNoCompileOptions ||
-         produce_options == v8::ScriptCompiler::kEagerCompile);
-}
+    : cache_size(cache_size) {}
 
 inspector_compile_script_event::V8CacheResult::ConsumeResult::ConsumeResult(
     v8::ScriptCompiler::CompileOptions consume_options,
@@ -1177,9 +1173,6 @@ std::unique_ptr<TracedValue> inspector_compile_script_event::Data(
   std::unique_ptr<TracedValue> value = FillLocation(url, text_position);
 
   if (cache_result.produce_result) {
-    value->SetString(
-        "cacheProduceOptions",
-        CompileOptionsString(cache_result.produce_result->produce_options));
     value->SetInteger("producedCacheSize",
                       cache_result.produce_result->cache_size);
   }

third_party/blink/renderer/core/inspector/inspector_trace_events.h

@@ -419,9 +419,7 @@ namespace inspector_compile_script_event {
 
 struct V8CacheResult {
   struct ProduceResult {
-    ProduceResult(v8::ScriptCompiler::CompileOptions produce_options,
-                  int cache_size);
-    v8::ScriptCompiler::CompileOptions produce_options;
+    explicit ProduceResult(int cache_size);
     int cache_size;
   };
   struct ConsumeResult {

third_party/blink/renderer/core/script/module_script_test.cc

@@ -106,10 +106,6 @@ class ModuleScriptTest : public ::testing::Test {
   }
 
   // Accessors for ModuleScript private members.
-  static v8::ScriptCompiler::CompileOptions GetCompileOptions(
-      const ModuleScript* module_script) {
-    return module_script->produce_cache_data_->GetCompileOptions();
-  }
   static V8CodeCache::ProduceCacheOptions GetProduceCacheOptions(
       const ModuleScript* module_script) {
     return module_script->produce_cache_data_->GetProduceCacheOptions();
@@ -160,8 +156,6 @@ TEST_F(ModuleScriptTest, V8CodeCache) {
             V8CodeCache::TagForCodeCache(cache_handler)));
         EXPECT_EQ(V8CodeCache::ProduceCacheOptions::kSetTimeStamp,
                   GetProduceCacheOptions(module_script));
-        EXPECT_EQ(v8::ScriptCompiler::kNoCompileOptions,
-                  GetCompileOptions(module_script));
         EXPECT_CALL(*sender_ptr, Send(_, _));
         break;
 
@@ -174,8 +168,6 @@ TEST_F(ModuleScriptTest, V8CodeCache) {
             V8CodeCache::TagForCodeCache(cache_handler)));
         EXPECT_EQ(V8CodeCache::ProduceCacheOptions::kProduceCodeCache,
                   GetProduceCacheOptions(module_script));
-        EXPECT_EQ(v8::ScriptCompiler::kNoCompileOptions,
-                  GetCompileOptions(module_script));
         EXPECT_CALL(*sender_ptr, Send(_, _));
         break;
 
@@ -186,8 +178,6 @@ TEST_F(ModuleScriptTest, V8CodeCache) {
             V8CodeCache::TagForTimeStamp(cache_handler)));
         EXPECT_TRUE(cache_handler->GetCachedMetadata(
             V8CodeCache::TagForCodeCache(cache_handler)));
-        EXPECT_EQ(v8::ScriptCompiler::kConsumeCodeCache,
-                  GetCompileOptions(module_script));
         EXPECT_EQ(V8CodeCache::ProduceCacheOptions::kNoProduceCache,
                   GetProduceCacheOptions(module_script));
         break;

third_party/blink/renderer/devtools/front_end/timeline/TimelineUIUtils.js

@@ -899,11 +899,9 @@ Timeline.TimelineUIUtils = class {
         if (url)
           contentHelper.appendLocationRow(ls`Script`, url, eventData['lineNumber'], eventData['columnNumber']);
         contentHelper.appendTextRow(ls`Streamed`, eventData['streamed']);
-        const cacheProduceOptions = eventData && eventData['cacheProduceOptions'];
-        if (cacheProduceOptions) {
-          contentHelper.appendTextRow(ls`Cache Produce Options`, cacheProduceOptions);
-          contentHelper.appendTextRow(ls`Produced Cache Size`, eventData['producedCacheSize']);
-        }
+        const producedCacheSize = eventData && eventData['producedCacheSize'];
+        if (producedCacheSize)
+          contentHelper.appendTextRow(ls`Produced Cache Size`, producedCacheSize);
         const cacheConsumeOptions = eventData && eventData['cacheConsumeOptions'];
         if (cacheConsumeOptions) {
           contentHelper.appendTextRow(ls`Cache Consume Options`, cacheConsumeOptions);

third_party/blink/web_tests/http/tests/devtools/isolated-code-cache/cross-origin-test-expected.txt

@@ -33,7 +33,6 @@ Text details for v8.compile: v8-cache-script.js:1
 v8.compile Properties:
 {
     data : {
-        cacheProduceOptions : "code"
         columnNumber : 0
         lineNumber : 0
         notStreamedReason : "already used streamed data"

third_party/blink/web_tests/http/tests/devtools/isolated-code-cache/same-origin-module-test-expected.txt

@@ -32,7 +32,6 @@ Text details for v8.compileModule: v8-cache-script.cgi
 v8.compileModule Properties:
 {
     data : {
-        cacheProduceOptions : "code"
         columnNumber : 1
         lineNumber : 1
         notStreamedReason : "module script"

third_party/blink/web_tests/http/tests/devtools/isolated-code-cache/same-origin-test-expected.txt

@@ -32,7 +32,6 @@ Text details for v8.compile: v8-cache-script.cgi:1
 v8.compile Properties:
 {
     data : {
-        cacheProduceOptions : "code"
         columnNumber : 0
         lineNumber : 0
         notStreamedReason : "already used streamed data"

third_party/blink/web_tests/http/tests/devtools/service-workers/service-worker-v8-cache-expected.txt

@@ -18,7 +18,6 @@ Text details for v8.compile: v8-cache-worker.js:1
 v8.compile Properties:
 {
     data : {
-        cacheProduceOptions : "full code"
         columnNumber : 0
         lineNumber : 0
         notStreamedReason : "script has code-cache available"

third_party/blink/web_tests/virtual/site-isolated-code-cache/http/tests/devtools/isolated-code-cache/cross-origin-test-expected.txt

@@ -33,7 +33,6 @@ Text details for v8.compile: v8-cache-script.js:1
 v8.compile Properties:
 {
     data : {
-        cacheProduceOptions : "code"
         columnNumber : 0
         lineNumber : 0
         notStreamedReason : "already used streamed data"