| /* |
| * Copyright (C) 2009 Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| * THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "third_party/blink/renderer/bindings/core/v8/v8_script_runner.h" |
| |
| #include "base/feature_list.h" |
| #include "build/build_config.h" |
| #include "third_party/blink/public/common/features.h" |
| #include "third_party/blink/public/mojom/v8_cache_options.mojom-blink.h" |
| #include "third_party/blink/renderer/bindings/core/v8/binding_security.h" |
| #include "third_party/blink/renderer/bindings/core/v8/referrer_script_info.h" |
| #include "third_party/blink/renderer/bindings/core/v8/script_evaluation_result.h" |
| #include "third_party/blink/renderer/bindings/core/v8/script_function.h" |
| #include "third_party/blink/renderer/bindings/core/v8/script_source_code.h" |
| #include "third_party/blink/renderer/bindings/core/v8/script_streamer.h" |
| #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h" |
| #include "third_party/blink/renderer/bindings/core/v8/v8_code_cache.h" |
| #include "third_party/blink/renderer/bindings/core/v8/v8_initializer.h" |
| #include "third_party/blink/renderer/bindings/core/v8/v8_throw_dom_exception.h" |
| #include "third_party/blink/renderer/bindings/core/v8/worker_or_worklet_script_controller.h" |
| #include "third_party/blink/renderer/core/execution_context/agent.h" |
| #include "third_party/blink/renderer/core/execution_context/execution_context.h" |
| #include "third_party/blink/renderer/core/frame/local_dom_window.h" |
| #include "third_party/blink/renderer/core/frame/local_frame.h" |
| #include "third_party/blink/renderer/core/inspector/inspector_trace_events.h" |
| #include "third_party/blink/renderer/core/loader/modulescript/module_script_creation_params.h" |
| #include "third_party/blink/renderer/core/probe/core_probes.h" |
| #include "third_party/blink/renderer/core/script/classic_script.h" |
| #include "third_party/blink/renderer/core/script/modulator.h" |
| #include "third_party/blink/renderer/core/script/module_script.h" |
| #include "third_party/blink/renderer/core/workers/worker_or_worklet_global_scope.h" |
| #include "third_party/blink/renderer/platform/bindings/script_forbidden_scope.h" |
| #include "third_party/blink/renderer/platform/bindings/v8_throw_exception.h" |
| #include "third_party/blink/renderer/platform/instrumentation/histogram.h" |
| #include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h" |
| #include "third_party/blink/renderer/platform/loader/fetch/cached_metadata.h" |
| #include "third_party/blink/renderer/platform/loader/fetch/cached_metadata_handler.h" |
| #include "third_party/blink/renderer/platform/scheduler/public/event_loop.h" |
| #include "third_party/blink/renderer/platform/wtf/assertions.h" |
| #include "third_party/blink/renderer/platform/wtf/text/text_encoding.h" |
| |
| namespace blink { |
| |
| namespace { |
| |
| // Used to throw an exception before we exceed the C++ stack and crash. |
| // This limit was arrived at arbitrarily. crbug.com/449744 |
| const int kMaxRecursionDepth = 44; |
| |
| bool InDiscardExperiment() { |
| return base::FeatureList::IsEnabled( |
| blink::features::kDiscardCodeCacheAfterFirstUse); |
| } |
| |
| // In order to make sure all pending messages to be processed in |
| // v8::Function::Call, we don't call throwStackOverflowException |
| // directly. Instead, we create a v8::Function of |
| // throwStackOverflowException and call it. |
| void ThrowStackOverflowException( |
| const v8::FunctionCallbackInfo<v8::Value>& info) { |
| V8ThrowException::ThrowRangeError(info.GetIsolate(), |
| "Maximum call stack size exceeded."); |
| } |
| |
| void ThrowScriptForbiddenException(v8::Isolate* isolate) { |
| V8ThrowException::ThrowError(isolate, "Script execution is forbidden."); |
| } |
| |
| v8::MaybeLocal<v8::Value> ThrowStackOverflowExceptionIfNeeded( |
| v8::Isolate* isolate, |
| v8::MicrotaskQueue* microtask_queue) { |
| if (V8PerIsolateData::From(isolate)->IsHandlingRecursionLevelError()) { |
| // If we are already handling a recursion level error, we should |
| // not invoke v8::Function::Call. |
| return v8::Undefined(isolate); |
| } |
| v8::MicrotasksScope microtasks_scope( |
| isolate, microtask_queue, v8::MicrotasksScope::kDoNotRunMicrotasks); |
| V8PerIsolateData::From(isolate)->SetIsHandlingRecursionLevelError(true); |
| |
| ScriptForbiddenScope::AllowUserAgentScript allow_script; |
| v8::Local<v8::Context> context = isolate->GetCurrentContext(); |
| v8::MaybeLocal<v8::Value> result = |
| v8::Function::New(context, ThrowStackOverflowException, |
| v8::Local<v8::Value>(), 0, |
| v8::ConstructorBehavior::kThrow) |
| .ToLocalChecked() |
| ->Call(context, v8::Undefined(isolate), 0, nullptr); |
| |
| V8PerIsolateData::From(isolate)->SetIsHandlingRecursionLevelError(false); |
| return result; |
| } |
| |
| v8::MaybeLocal<v8::Script> CompileScriptInternal( |
| v8::Isolate* isolate, |
| ExecutionContext* execution_context, |
| const ScriptSourceCode& source_code, |
| v8::ScriptOrigin origin, |
| v8::ScriptCompiler::CompileOptions compile_options, |
| v8::ScriptCompiler::NoCacheReason no_cache_reason, |
| inspector_compile_script_event::V8CacheResult* cache_result) { |
| v8::Local<v8::String> code = V8String(isolate, source_code.Source()); |
| |
| if (ScriptStreamer* streamer = source_code.Streamer()) { |
| // Final compile call for a streamed compilation. |
| // Streaming compilation may involve use of code cache. |
| // TODO(leszeks): Add compile timer to streaming compilation. |
| DCHECK(streamer->IsFinished()); |
| DCHECK(!streamer->IsStreamingSuppressed()); |
| return v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), |
| streamer->Source(), code, origin); |
| } |
| |
| // Allow inspector to use its own compilation cache store. |
| v8::ScriptCompiler::CachedData* inspector_data = nullptr; |
| probe::ConsumeCompilationCache(execution_context, source_code, |
| &inspector_data); |
| if (inspector_data) { |
| v8::ScriptCompiler::Source source(code, origin, inspector_data); |
| v8::MaybeLocal<v8::Script> script = |
| v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &source, |
| v8::ScriptCompiler::kConsumeCodeCache); |
| return script; |
| } |
| |
| switch (compile_options) { |
| case v8::ScriptCompiler::kNoCompileOptions: |
| case v8::ScriptCompiler::kEagerCompile: { |
| v8::ScriptCompiler::Source source(code, origin); |
| return v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &source, |
| compile_options, no_cache_reason); |
| } |
| |
| case v8::ScriptCompiler::kConsumeCodeCache: { |
| // Compile a script, and consume a V8 cache that was generated previously. |
| SingleCachedMetadataHandler* cache_handler = source_code.CacheHandler(); |
| v8::ScriptCompiler::CachedData* cached_data = |
| V8CodeCache::CreateCachedData(cache_handler); |
| v8::ScriptCompiler::Source source(code, origin, cached_data); |
| v8::MaybeLocal<v8::Script> script = |
| v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &source, |
| v8::ScriptCompiler::kConsumeCodeCache); |
| |
| if (cached_data->rejected) { |
| cache_handler->ClearCachedMetadata( |
| CachedMetadataHandler::kClearPersistentStorage); |
| } else if (InDiscardExperiment()) { |
| // Experimentally free code cache from memory after first use. See |
| // http://crbug.com/1045052. |
| cache_handler->ClearCachedMetadata( |
| CachedMetadataHandler::kDiscardLocally); |
| } |
| if (cache_result) { |
| cache_result->consume_result = base::make_optional( |
| inspector_compile_script_event::V8CacheResult::ConsumeResult( |
| v8::ScriptCompiler::kConsumeCodeCache, cached_data->length, |
| cached_data->rejected)); |
| } |
| return script; |
| } |
| } |
| |
| // All switch branches should return and we should never get here. |
| // But some compilers aren't sure, hence this default. |
| NOTREACHED(); |
| return v8::MaybeLocal<v8::Script>(); |
| } |
| |
| int GetMicrotasksScopeDepth(v8::Isolate* isolate, |
| v8::MicrotaskQueue* microtask_queue) { |
| if (microtask_queue) |
| return microtask_queue->GetMicrotasksScopeDepth(); |
| return v8::MicrotasksScope::GetCurrentDepth(isolate); |
| } |
| |
| } // namespace |
| |
| v8::MaybeLocal<v8::Script> V8ScriptRunner::CompileScript( |
| ScriptState* script_state, |
| const ScriptSourceCode& source, |
| SanitizeScriptErrors sanitize_script_errors, |
| v8::ScriptCompiler::CompileOptions compile_options, |
| v8::ScriptCompiler::NoCacheReason no_cache_reason, |
| const ReferrerScriptInfo& referrer_info) { |
| v8::Isolate* isolate = script_state->GetIsolate(); |
| if (source.Source().length() >= v8::String::kMaxLength) { |
| V8ThrowException::ThrowError(isolate, "Source file too large."); |
| return v8::Local<v8::Script>(); |
| } |
| |
| const String& file_name = source.Url(); |
| const TextPosition& script_start_position = source.StartPosition(); |
| |
| constexpr const char* kTraceEventCategoryGroup = "v8,devtools.timeline"; |
| TRACE_EVENT_BEGIN1(kTraceEventCategoryGroup, "v8.compile", "fileName", |
| file_name.Utf8()); |
| ExecutionContext* execution_context = ExecutionContext::From(script_state); |
| probe::V8Compile probe(execution_context, file_name, |
| script_start_position.line_.ZeroBasedInt(), |
| script_start_position.column_.ZeroBasedInt()); |
| |
| // NOTE: For compatibility with WebCore, ScriptSourceCode's line starts at |
| // 1, whereas v8 starts at 0. |
| v8::ScriptOrigin origin( |
| V8String(isolate, file_name), script_start_position.line_.ZeroBasedInt(), |
| script_start_position.column_.ZeroBasedInt(), |
| sanitize_script_errors == SanitizeScriptErrors::kDoNotSanitize, -1, |
| V8String(isolate, source.SourceMapUrl()), |
| sanitize_script_errors == SanitizeScriptErrors::kSanitize, |
| false, // is_wasm |
| false, // is_module |
| referrer_info.ToV8HostDefinedOptions(isolate)); |
| |
| if (!*TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(kTraceEventCategoryGroup)) { |
| return CompileScriptInternal(isolate, execution_context, source, origin, |
| compile_options, no_cache_reason, nullptr); |
| } |
| |
| inspector_compile_script_event::V8CacheResult cache_result; |
| v8::MaybeLocal<v8::Script> script = |
| CompileScriptInternal(isolate, execution_context, source, origin, |
| compile_options, no_cache_reason, &cache_result); |
| TRACE_EVENT_END1(kTraceEventCategoryGroup, "v8.compile", "data", |
| inspector_compile_script_event::Data( |
| file_name, script_start_position, cache_result, |
| source.Streamer(), source.NotStreamingReason())); |
| return script; |
| } |
| |
| v8::MaybeLocal<v8::Module> V8ScriptRunner::CompileModule( |
| v8::Isolate* isolate, |
| const ModuleScriptCreationParams& params, |
| const TextPosition& start_position, |
| v8::ScriptCompiler::CompileOptions compile_options, |
| v8::ScriptCompiler::NoCacheReason no_cache_reason, |
| const ReferrerScriptInfo& referrer_info) { |
| const String file_name = params.SourceURL(); |
| constexpr const char* kTraceEventCategoryGroup = "v8,devtools.timeline"; |
| TRACE_EVENT_BEGIN1(kTraceEventCategoryGroup, "v8.compileModule", "fileName", |
| file_name.Utf8()); |
| |
| // |resource_is_shared_cross_origin| is always true and |resource_is_opaque| |
| // is always false because CORS is enforced to module scripts. |
| v8::ScriptOrigin origin(V8String(isolate, file_name), |
| start_position.line_.ZeroBasedInt(), |
| start_position.column_.ZeroBasedInt(), |
| true, // resource_is_shared_cross_origin |
| -1, // script id |
| v8::String::Empty(isolate), // source_map_url |
| false, // resource_is_opaque |
| false, // is_wasm |
| true, // is_module |
| referrer_info.ToV8HostDefinedOptions(isolate)); |
| |
| v8::Local<v8::String> code = V8String(isolate, params.GetSourceText()); |
| inspector_compile_script_event::V8CacheResult cache_result; |
| v8::MaybeLocal<v8::Module> script; |
| ScriptStreamer* streamer = params.GetScriptStreamer(); |
| if (streamer) { |
| // Final compile call for a streamed compilation. |
| // Streaming compilation may involve use of code cache. |
| // TODO(leszeks): Add compile timer to streaming compilation. |
| DCHECK(streamer->IsFinished()); |
| DCHECK(!streamer->IsStreamingSuppressed()); |
| script = v8::ScriptCompiler::CompileModule( |
| isolate->GetCurrentContext(), streamer->Source(), code, origin); |
| } else { |
| switch (compile_options) { |
| case v8::ScriptCompiler::kNoCompileOptions: |
| case v8::ScriptCompiler::kEagerCompile: { |
| v8::ScriptCompiler::Source source(code, origin); |
| script = v8::ScriptCompiler::CompileModule( |
| isolate, &source, compile_options, no_cache_reason); |
| break; |
| } |
| |
| case v8::ScriptCompiler::kConsumeCodeCache: { |
| // Compile a script, and consume a V8 cache that was generated |
| // previously. |
| SingleCachedMetadataHandler* cache_handler = params.CacheHandler(); |
| DCHECK(cache_handler); |
| v8::ScriptCompiler::CachedData* cached_data = |
| V8CodeCache::CreateCachedData(cache_handler); |
| v8::ScriptCompiler::Source source(code, origin, cached_data); |
| script = v8::ScriptCompiler::CompileModule( |
| isolate, &source, compile_options, no_cache_reason); |
| if (cached_data->rejected) { |
| cache_handler->ClearCachedMetadata( |
| CachedMetadataHandler::kClearPersistentStorage); |
| } else if (InDiscardExperiment()) { |
| // Experimentally free code cache from memory after first use. See |
| // http://crbug.com/1045052. |
| cache_handler->ClearCachedMetadata( |
| CachedMetadataHandler::kDiscardLocally); |
| } |
| cache_result.consume_result = base::make_optional( |
| inspector_compile_script_event::V8CacheResult::ConsumeResult( |
| compile_options, cached_data->length, cached_data->rejected)); |
| break; |
| } |
| } |
| } |
| |
| TRACE_EVENT_END1(kTraceEventCategoryGroup, "v8.compileModule", "data", |
| inspector_compile_script_event::Data( |
| file_name, start_position, cache_result, streamer, |
| params.NotStreamingReason())); |
| return script; |
| } |
| |
| v8::MaybeLocal<v8::Value> V8ScriptRunner::RunCompiledScript( |
| v8::Isolate* isolate, |
| v8::Local<v8::Script> script, |
| ExecutionContext* context) { |
| DCHECK(!script.IsEmpty()); |
| LocalDOMWindow* window = DynamicTo<LocalDOMWindow>(context); |
| ScopedFrameBlamer frame_blamer(window ? window->GetFrame() : nullptr); |
| |
| v8::Local<v8::Value> script_name = |
| script->GetUnboundScript()->GetScriptName(); |
| TRACE_EVENT1("v8", "v8.run", "fileName", |
| TRACE_STR_COPY(*v8::String::Utf8Value(isolate, script_name))); |
| RuntimeCallStatsScopedTracer rcs_scoped_tracer(isolate); |
| RUNTIME_CALL_TIMER_SCOPE(isolate, RuntimeCallStats::CounterId::kV8); |
| |
| v8::MicrotaskQueue* microtask_queue = ToMicrotaskQueue(context); |
| if (GetMicrotasksScopeDepth(isolate, microtask_queue) > kMaxRecursionDepth) |
| return ThrowStackOverflowExceptionIfNeeded(isolate, microtask_queue); |
| |
| CHECK(!context->ContextLifecycleObserverSet().IsIteratingOverObservers()); |
| |
| // Run the script and keep track of the current recursion depth. |
| v8::MaybeLocal<v8::Value> result; |
| { |
| if (ScriptForbiddenScope::IsScriptForbidden()) { |
| ThrowScriptForbiddenException(isolate); |
| return v8::MaybeLocal<v8::Value>(); |
| } |
| |
| v8::Isolate::SafeForTerminationScope safe_for_termination(isolate); |
| v8::MicrotasksScope microtasks_scope(isolate, microtask_queue, |
| v8::MicrotasksScope::kRunMicrotasks); |
| v8::Local<v8::String> script_url; |
| if (!script_name->ToString(isolate->GetCurrentContext()) |
| .ToLocal(&script_url)) |
| return result; |
| |
| // ToCoreString here should be zero copy due to externalized string |
| // unpacked. |
| probe::ExecuteScript probe(context, ToCoreString(script_url), |
| script->GetUnboundScript()->GetId()); |
| result = script->Run(isolate->GetCurrentContext()); |
| } |
| |
| CHECK(!isolate->IsDead()); |
| return result; |
| } |
| |
| ScriptEvaluationResult V8ScriptRunner::CompileAndRunScript( |
| ScriptState* script_state, |
| ClassicScript* classic_script, |
| ExecuteScriptPolicy policy, |
| RethrowErrorsOption rethrow_errors) { |
| if (!script_state) |
| return ScriptEvaluationResult::FromClassicNotRun(); |
| |
| // |script_state->GetContext()| must be initialized here already, typically |
| // due to a WindowProxy() call inside ToScriptState*() that is used to get the |
| // ScriptState. |
| |
| ExecutionContext* execution_context = ExecutionContext::From(script_state); |
| DCHECK(execution_context->IsContextThread()); |
| |
| if (policy == ExecuteScriptPolicy::kDoNotExecuteScriptWhenScriptsDisabled && |
| !execution_context->CanExecuteScripts(kAboutToExecuteScript)) { |
| return ScriptEvaluationResult::FromClassicNotRun(); |
| } |
| |
| v8::Isolate* isolate = script_state->GetIsolate(); |
| const ScriptSourceCode& source = classic_script->GetScriptSourceCode(); |
| const SanitizeScriptErrors sanitize_script_errors = |
| classic_script->GetSanitizeScriptErrors(); |
| |
| LocalDOMWindow* window = DynamicTo<LocalDOMWindow>(execution_context); |
| WorkerOrWorkletGlobalScope* worker_or_worklet_global_scope = |
| DynamicTo<WorkerOrWorkletGlobalScope>(execution_context); |
| LocalFrame* frame = window ? window->GetFrame() : nullptr; |
| |
| if (window && window->document()->IsInitialEmptyDocument()) { |
| window->GetFrame()->Loader().DidAccessInitialDocument(); |
| } else if (worker_or_worklet_global_scope) { |
| DCHECK_EQ( |
| script_state, |
| worker_or_worklet_global_scope->ScriptController()->GetScriptState()); |
| DCHECK(worker_or_worklet_global_scope->ScriptController() |
| ->IsContextInitialized()); |
| DCHECK(worker_or_worklet_global_scope->ScriptController() |
| ->IsReadyToEvaluate()); |
| } |
| |
| v8::Context::Scope scope(script_state->GetContext()); |
| |
| TRACE_EVENT1("devtools.timeline", "EvaluateScript", "data", |
| inspector_evaluate_script_event::Data( |
| frame, source.Url().GetString(), source.StartPosition())); |
| |
| // Scope for |v8::TryCatch|. |
| { |
| v8::TryCatch try_catch(isolate); |
| // Step 8.3. Otherwise, rethrow errors is false. Perform the following |
| // steps: [spec text] |
| // Step 8.3.1. Report the exception given by evaluationStatus.[[Value]] |
| // for script. [spec text] |
| // |
| // This will be done inside V8 by setting TryCatch::SetVerbose(true) here. |
| if (!rethrow_errors.ShouldRethrow()) { |
| try_catch.SetVerbose(true); |
| } |
| |
| // Omit storing base URL if it is same as source URL. |
| // Note: This improves chance of getting into a fast path in |
| // ReferrerScriptInfo::ToV8HostDefinedOptions. |
| const KURL base_url = classic_script->BaseURL(); |
| KURL stored_base_url = (base_url == source.Url()) ? KURL() : base_url; |
| |
| // TODO(hiroshige): Remove this code and related use counters once the |
| // measurement is done. |
| ReferrerScriptInfo::BaseUrlSource base_url_source = |
| ReferrerScriptInfo::BaseUrlSource::kOther; |
| if (source.SourceLocationType() == |
| ScriptSourceLocationType::kExternalFile && |
| !base_url.IsNull()) { |
| switch (sanitize_script_errors) { |
| case SanitizeScriptErrors::kDoNotSanitize: |
| base_url_source = |
| ReferrerScriptInfo::BaseUrlSource::kClassicScriptCORSSameOrigin; |
| break; |
| case SanitizeScriptErrors::kSanitize: |
| base_url_source = |
| ReferrerScriptInfo::BaseUrlSource::kClassicScriptCORSCrossOrigin; |
| break; |
| } |
| } |
| const ReferrerScriptInfo referrer_info( |
| stored_base_url, classic_script->FetchOptions(), base_url_source); |
| |
| v8::Local<v8::Script> script; |
| |
| v8::ScriptCompiler::CompileOptions compile_options; |
| V8CodeCache::ProduceCacheOptions produce_cache_options; |
| v8::ScriptCompiler::NoCacheReason no_cache_reason; |
| std::tie(compile_options, produce_cache_options, no_cache_reason) = |
| V8CodeCache::GetCompileOptions(execution_context->GetV8CacheOptions(), |
| source); |
| |
| v8::MaybeLocal<v8::Value> maybe_result; |
| if (V8ScriptRunner::CompileScript(script_state, source, |
| sanitize_script_errors, compile_options, |
| no_cache_reason, referrer_info) |
| .ToLocal(&script)) { |
| maybe_result = |
| V8ScriptRunner::RunCompiledScript(isolate, script, execution_context); |
| probe::ProduceCompilationCache(probe::ToCoreProbeSink(execution_context), |
| source, script); |
| V8CodeCache::ProduceCache(isolate, script, source, produce_cache_options); |
| } |
| |
| // TODO(crbug/1114601): Investigate whether to check CanContinue() in other |
| // script evaluation code paths. |
| if (!try_catch.CanContinue()) { |
| if (worker_or_worklet_global_scope) |
| worker_or_worklet_global_scope->ScriptController()->ForbidExecution(); |
| return ScriptEvaluationResult::FromClassicAborted(); |
| } |
| |
| if (!try_catch.HasCaught()) { |
| // Step 10. If evaluationStatus is a normal completion, then return |
| // evaluationStatus. [spec text] |
| v8::Local<v8::Value> result; |
| bool success = maybe_result.ToLocal(&result); |
| DCHECK(success); |
| return ScriptEvaluationResult::FromClassicSuccess(result); |
| } |
| |
| DCHECK(maybe_result.IsEmpty()); |
| |
| if (rethrow_errors.ShouldRethrow() && |
| sanitize_script_errors == SanitizeScriptErrors::kDoNotSanitize) { |
| // Step 8.1. If rethrow errors is true and script's muted errors is |
| // false, then: [spec text] |
| // |
| // Step 8.1.2. Rethrow evaluationStatus.[[Value]]. [spec text] |
| // |
| // We rethrow exceptions reported from importScripts() here. The |
| // original filename/lineno/colno information (which points inside of |
| // imported scripts) is kept through ReThrow(), and will be eventually |
| // reported to WorkerGlobalScope.onerror via `TryCatch::SetVerbose(true)` |
| // called at top-level worker script evaluation. |
| try_catch.ReThrow(); |
| return ScriptEvaluationResult::FromClassicException(); |
| } |
| } |
| // |v8::TryCatch| is (and should be) exited, before ThrowException() below. |
| |
| if (rethrow_errors.ShouldRethrow()) { |
| // kDoNotSanitize case is processed and early-exited above. |
| DCHECK_EQ(sanitize_script_errors, SanitizeScriptErrors::kSanitize); |
| |
| // Step 8.2. If rethrow errors is true and script's muted errors is |
| // true, then: [spec text] |
| // |
| // Step 8.2.2. Throw a "NetworkError" DOMException. [spec text] |
| // |
| // We don't supply any message here to avoid leaking details of muted |
| // errors. |
| V8ThrowException::ThrowException( |
| isolate, V8ThrowDOMException::CreateOrEmpty( |
| isolate, DOMExceptionCode::kNetworkError, |
| rethrow_errors.Message())); |
| return ScriptEvaluationResult::FromClassicException(); |
| } |
| |
| // #report-the-error for rethrow errors == true is already handled via |
| // |TryCatch::SetVerbose(true)| above. |
| return ScriptEvaluationResult::FromClassicException(); |
| } |
| |
| v8::MaybeLocal<v8::Value> V8ScriptRunner::CompileAndRunInternalScript( |
| v8::Isolate* isolate, |
| ScriptState* script_state, |
| const ScriptSourceCode& source_code) { |
| DCHECK_EQ(isolate, script_state->GetIsolate()); |
| |
| v8::ScriptCompiler::CompileOptions compile_options; |
| V8CodeCache::ProduceCacheOptions produce_cache_options; |
| v8::ScriptCompiler::NoCacheReason no_cache_reason; |
| std::tie(compile_options, produce_cache_options, no_cache_reason) = |
| V8CodeCache::GetCompileOptions(mojom::blink::V8CacheOptions::kDefault, |
| source_code); |
| // Currently internal scripts don't have cache handlers. So we should not |
| // produce cache for them. |
| DCHECK_EQ(produce_cache_options, |
| V8CodeCache::ProduceCacheOptions::kNoProduceCache); |
| v8::Local<v8::Script> script; |
| // Use default ScriptReferrerInfo here: |
| // - nonce: empty for internal script, and |
| // - parser_state: always "not parser inserted" for internal scripts. |
| if (!V8ScriptRunner::CompileScript( |
| script_state, source_code, SanitizeScriptErrors::kDoNotSanitize, |
| compile_options, no_cache_reason, ReferrerScriptInfo()) |
| .ToLocal(&script)) |
| return v8::MaybeLocal<v8::Value>(); |
| |
| TRACE_EVENT0("v8", "v8.run"); |
| RuntimeCallStatsScopedTracer rcs_scoped_tracer(isolate); |
| RUNTIME_CALL_TIMER_SCOPE(isolate, RuntimeCallStats::CounterId::kV8); |
| v8::Isolate::SafeForTerminationScope safe_for_termination(isolate); |
| v8::MicrotasksScope microtasks_scope( |
| isolate, ToMicrotaskQueue(script_state), |
| v8::MicrotasksScope::kDoNotRunMicrotasks); |
| v8::MaybeLocal<v8::Value> result = script->Run(isolate->GetCurrentContext()); |
| CHECK(!isolate->IsDead()); |
| return result; |
| } |
| |
| v8::MaybeLocal<v8::Value> V8ScriptRunner::CallAsConstructor( |
| v8::Isolate* isolate, |
| v8::Local<v8::Object> constructor, |
| ExecutionContext* context, |
| int argc, |
| v8::Local<v8::Value> argv[]) { |
| TRACE_EVENT0("v8", "v8.callAsConstructor"); |
| RUNTIME_CALL_TIMER_SCOPE(isolate, RuntimeCallStats::CounterId::kV8); |
| |
| v8::MicrotaskQueue* microtask_queue = ToMicrotaskQueue(context); |
| int depth = GetMicrotasksScopeDepth(isolate, microtask_queue); |
| if (depth >= kMaxRecursionDepth) |
| return ThrowStackOverflowExceptionIfNeeded(isolate, microtask_queue); |
| |
| CHECK(!context->ContextLifecycleObserverSet().IsIteratingOverObservers()); |
| |
| if (ScriptForbiddenScope::IsScriptForbidden()) { |
| ThrowScriptForbiddenException(isolate); |
| return v8::MaybeLocal<v8::Value>(); |
| } |
| |
| // TODO(dominicc): When inspector supports tracing object |
| // invocation, change this to use v8::Object instead of |
| // v8::Function. All callers use functions because |
| // CustomElementRegistry#define's IDL signature is Function. |
| CHECK(constructor->IsFunction()); |
| v8::Local<v8::Function> function = constructor.As<v8::Function>(); |
| |
| v8::Isolate::SafeForTerminationScope safe_for_termination(isolate); |
| v8::MicrotasksScope microtasks_scope(isolate, ToMicrotaskQueue(context), |
| v8::MicrotasksScope::kRunMicrotasks); |
| probe::CallFunction probe(context, function, depth); |
| |
| if (!depth) { |
| TRACE_EVENT_BEGIN1("devtools.timeline", "FunctionCall", "data", |
| inspector_function_call_event::Data(context, function)); |
| } |
| |
| v8::MaybeLocal<v8::Value> result = |
| constructor->CallAsConstructor(isolate->GetCurrentContext(), argc, argv); |
| CHECK(!isolate->IsDead()); |
| |
| if (!depth) |
| TRACE_EVENT_END0("devtools.timeline", "FunctionCall"); |
| |
| return result; |
| } |
| |
| v8::MaybeLocal<v8::Value> V8ScriptRunner::CallFunction( |
| v8::Local<v8::Function> function, |
| ExecutionContext* context, |
| v8::Local<v8::Value> receiver, |
| int argc, |
| v8::Local<v8::Value> args[], |
| v8::Isolate* isolate) { |
| LocalDOMWindow* window = DynamicTo<LocalDOMWindow>(context); |
| LocalFrame* frame = window ? window->GetFrame() : nullptr; |
| ScopedFrameBlamer frame_blamer(frame); |
| TRACE_EVENT0("v8", "v8.callFunction"); |
| RuntimeCallStatsScopedTracer rcs_scoped_tracer(isolate); |
| RUNTIME_CALL_TIMER_SCOPE(isolate, RuntimeCallStats::CounterId::kV8); |
| |
| v8::MicrotaskQueue* microtask_queue = ToMicrotaskQueue(context); |
| int depth = GetMicrotasksScopeDepth(isolate, microtask_queue); |
| if (depth >= kMaxRecursionDepth) |
| return ThrowStackOverflowExceptionIfNeeded(isolate, microtask_queue); |
| |
| CHECK(!context->ContextLifecycleObserverSet().IsIteratingOverObservers()); |
| |
| if (ScriptForbiddenScope::IsScriptForbidden()) { |
| ThrowScriptForbiddenException(isolate); |
| return v8::MaybeLocal<v8::Value>(); |
| } |
| |
| DCHECK(!frame || BindingSecurity::ShouldAllowAccessToFrame( |
| ToLocalDOMWindow(function->CreationContext()), frame, |
| BindingSecurity::ErrorReportOption::kDoNotReport)); |
| v8::Isolate::SafeForTerminationScope safe_for_termination(isolate); |
| v8::MicrotasksScope microtasks_scope(isolate, microtask_queue, |
| v8::MicrotasksScope::kRunMicrotasks); |
| if (!depth) { |
| TRACE_EVENT_BEGIN1("devtools.timeline", "FunctionCall", "data", |
| inspector_function_call_event::Data(context, function)); |
| } |
| |
| probe::CallFunction probe(context, function, depth); |
| v8::MaybeLocal<v8::Value> result = |
| function->Call(isolate->GetCurrentContext(), receiver, argc, args); |
| CHECK(!isolate->IsDead()); |
| |
| if (!depth) |
| TRACE_EVENT_END0("devtools.timeline", "FunctionCall"); |
| |
| return result; |
| } |
| |
| class ModuleEvaluationRejectionCallback final : public ScriptFunction { |
| public: |
| explicit ModuleEvaluationRejectionCallback(ScriptState* script_state) |
| : ScriptFunction(script_state) {} |
| |
| static v8::Local<v8::Function> CreateFunction(ScriptState* script_state) { |
| ModuleEvaluationRejectionCallback* self = |
| MakeGarbageCollected<ModuleEvaluationRejectionCallback>(script_state); |
| return self->BindToV8Function(); |
| } |
| |
| private: |
| ScriptValue Call(ScriptValue value) override { |
| ModuleRecord::ReportException(GetScriptState(), value.V8Value()); |
| return ScriptValue(); |
| } |
| }; |
| |
| // <specdef href="https://html.spec.whatwg.org/C/#run-a-module-script"> |
| // Spec with TLA: https://github.com/whatwg/html/pull/4352 |
| ScriptEvaluationResult V8ScriptRunner::EvaluateModule( |
| ModuleScript* module_script, |
| RethrowErrorsOption rethrow_errors) { |
| // <spec step="1">If rethrow errors is not given, let it be false.</spec> |
| |
| // <spec step="2">Let settings be the settings object of script.</spec> |
| // |
| // The settings object is |module_script->SettingsObject()|. |
| ScriptState* script_state = module_script->SettingsObject()->GetScriptState(); |
| DCHECK_EQ(Modulator::From(script_state), module_script->SettingsObject()); |
| ExecutionContext* execution_context = ExecutionContext::From(script_state); |
| v8::Isolate* isolate = script_state->GetIsolate(); |
| |
| // TODO(crbug.com/1151165): Ideally v8::Context should be entered before |
| // CanExecuteScripts(). |
| v8::Context::Scope scope(script_state->GetContext()); |
| |
| // <spec step="3">Check if we can run script with settings. If this returns |
| // "do not run" then return NormalCompletion(empty).</spec> |
| if (!execution_context->CanExecuteScripts(kAboutToExecuteScript)) { |
| return ScriptEvaluationResult::FromModuleNotRun(); |
| } |
| |
| // <spec step="4">Prepare to run script given settings.</spec> |
| // |
| // These are placed here to also cover ModuleRecord::ReportException(). |
| v8::MicrotasksScope microtasks_scope(isolate, |
| ToMicrotaskQueue(execution_context), |
| v8::MicrotasksScope::kRunMicrotasks); |
| |
| // Without TLA: <spec step="5">Let evaluationStatus be null.</spec> |
| ScriptEvaluationResult result = ScriptEvaluationResult::FromModuleNotRun(); |
| |
| // <spec step="6">If script's error to rethrow is not null, ...</spec> |
| if (module_script->HasErrorToRethrow()) { |
| // Without TLA: <spec step="6">... then set evaluationStatus to Completion |
| // { [[Type]]: throw, [[Value]]: script's error to rethrow, |
| // [[Target]]: empty }.</spec> |
| // With TLA: <spec step="5">If script's error to rethrow is not null, |
| // then let valuationPromise be a promise rejected with script's error |
| // to rethrow.</spec> |
| result = ScriptEvaluationResult::FromModuleException( |
| module_script->CreateErrorToRethrow().V8Value()); |
| } else { |
| // <spec step="7">Otherwise:</spec> |
| |
| // <spec step="7.1">Let record be script's record.</spec> |
| v8::Local<v8::Module> record = module_script->V8Module(); |
| CHECK(!record.IsEmpty()); |
| |
| // <spec step="7.2">Set evaluationStatus to record.Evaluate(). ...</spec> |
| |
| // Isolate exceptions that occur when executing the code. These exceptions |
| // should not interfere with javascript code we might evaluate from C++ |
| // when returning from here. |
| v8::TryCatch try_catch(isolate); |
| |
| // Script IDs are not available on errored modules or on non-source text |
| // modules, so we give them a default value. |
| probe::ExecuteScript probe(execution_context, module_script->SourceURL(), |
| record->GetStatus() != v8::Module::kErrored && |
| record->IsSourceTextModule() |
| ? record->ScriptId() |
| : v8::UnboundScript::kNoScriptId); |
| |
| TRACE_EVENT0("v8,devtools.timeline", "v8.evaluateModule"); |
| RUNTIME_CALL_TIMER_SCOPE(isolate, RuntimeCallStats::CounterId::kV8); |
| v8::Isolate::SafeForTerminationScope safe_for_termination(isolate); |
| |
| // Do not perform a microtask checkpoint here. A checkpoint is performed |
| // only after module error handling to ensure proper timing with and |
| // without top-level await. |
| |
| v8::MaybeLocal<v8::Value> maybe_result = |
| record->Evaluate(script_state->GetContext()); |
| |
| if (!try_catch.CanContinue()) |
| return ScriptEvaluationResult::FromModuleAborted(); |
| |
| v8::Local<v8::Value> v8_result; |
| if (!maybe_result.ToLocal(&v8_result)) { |
| DCHECK(try_catch.HasCaught()); |
| result = |
| ScriptEvaluationResult::FromModuleException(try_catch.Exception()); |
| } else { |
| DCHECK(!try_catch.HasCaught()); |
| result = ScriptEvaluationResult::FromModuleSuccess(v8_result); |
| } |
| |
| // <spec step="7.2">... If Evaluate fails to complete as a result of the |
| // user agent aborting the running script, then set evaluationStatus to |
| // Completion { [[Type]]: throw, [[Value]]: a new "QuotaExceededError" |
| // DOMException, [[Target]]: empty }.</spec> |
| } |
| |
| // [not specced] Store V8 code cache on successful evaluation. |
| if (result.GetResultType() == ScriptEvaluationResult::ResultType::kSuccess) { |
| execution_context->GetTaskRunner(TaskType::kNetworking) |
| ->PostTask(FROM_HERE, |
| WTF::Bind(&Modulator::ProduceCacheModuleTreeTopLevel, |
| WrapWeakPersistent(Modulator::From(script_state)), |
| WrapWeakPersistent(module_script))); |
| } |
| |
| if (!rethrow_errors.ShouldRethrow()) { |
| if (base::FeatureList::IsEnabled(features::kTopLevelAwait)) { |
| // <spec step="7"> If report errors is true, then upon rejection of |
| // evaluationPromise with reason, report the exception given by reason |
| // for script.</spec> |
| v8::Local<v8::Function> callback_failure = |
| ModuleEvaluationRejectionCallback::CreateFunction(script_state); |
| // Add a rejection handler to report back errors once the result |
| // promise is rejected. |
| result.GetPromise(script_state) |
| .Then(v8::Local<v8::Function>(), callback_failure); |
| } else { |
| // <spec step="8">If evaluationStatus is an abrupt completion, |
| // then:</spec> |
| if (result.GetResultType() == |
| ScriptEvaluationResult::ResultType::kException) { |
| // <spec step="8.2">Otherwise, report the exception given by |
| // evaluationStatus.[[Value]] for script.</spec> |
| ModuleRecord::ReportException(script_state, |
| result.GetExceptionForModule()); |
| } |
| } |
| } |
| |
| // <spec step="8">Clean up after running script with settings.</spec> |
| // Partially implemented in MicrotaskScope destructor and the |
| // v8::Context::Scope destructor. |
| return result; |
| } |
| |
| void V8ScriptRunner::ReportException(v8::Isolate* isolate, |
| v8::Local<v8::Value> exception) { |
| DCHECK(!exception.IsEmpty()); |
| |
| // https://html.spec.whatwg.org/C/#report-the-error |
| v8::Local<v8::Message> message = |
| v8::Exception::CreateMessage(isolate, exception); |
| if (IsMainThread()) |
| V8Initializer::MessageHandlerInMainThread(message, exception); |
| else |
| V8Initializer::MessageHandlerInWorker(message, exception); |
| } |
| |
| } // namespace blink |
