| /* |
| * 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 "bindings/core/v8/V8ScriptRunner.h" |
| |
| #include "bindings/core/v8/BindingSecurity.h" |
| #include "bindings/core/v8/ScriptSourceCode.h" |
| #include "bindings/core/v8/ScriptStreamer.h" |
| #include "bindings/core/v8/V8BindingForCore.h" |
| #include "bindings/core/v8/V8GCController.h" |
| #include "bindings/core/v8/V8ThrowException.h" |
| #include "core/dom/Document.h" |
| #include "core/dom/ExecutionContext.h" |
| #include "core/frame/LocalDOMWindow.h" |
| #include "core/frame/LocalFrame.h" |
| #include "core/inspector/InspectorTraceEvents.h" |
| #include "core/inspector/ThreadDebugger.h" |
| #include "core/loader/resource/ScriptResource.h" |
| #include "core/probe/CoreProbes.h" |
| #include "platform/Histogram.h" |
| #include "platform/ScriptForbiddenScope.h" |
| #include "platform/instrumentation/tracing/TraceEvent.h" |
| #include "platform/loader/fetch/CachedMetadata.h" |
| #include "platform/wtf/CurrentTime.h" |
| #include "public/platform/Platform.h" |
| |
| #if OS(WIN) |
| #include <malloc.h> |
| #else |
| #include <alloca.h> |
| #endif |
| |
| 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; |
| |
| class V8CompileHistogram { |
| public: |
| enum Cacheability { kCacheable, kNoncacheable, kInlineScript }; |
| explicit V8CompileHistogram(Cacheability); |
| ~V8CompileHistogram(); |
| |
| private: |
| Cacheability cacheability_; |
| double time_stamp_; |
| }; |
| |
| V8CompileHistogram::V8CompileHistogram( |
| V8CompileHistogram::Cacheability cacheability) |
| : cacheability_(cacheability), time_stamp_(WTF::CurrentTime()) {} |
| |
| V8CompileHistogram::~V8CompileHistogram() { |
| int64_t elapsed_micro_seconds = |
| static_cast<int64_t>((WTF::CurrentTime() - time_stamp_) * 1000000); |
| switch (cacheability_) { |
| case kCacheable: { |
| DEFINE_THREAD_SAFE_STATIC_LOCAL( |
| CustomCountHistogram, compile_cacheable_histogram, |
| new CustomCountHistogram("V8.CompileCacheableMicroSeconds", 0, |
| 1000000, 50)); |
| compile_cacheable_histogram.Count(elapsed_micro_seconds); |
| break; |
| } |
| case kNoncacheable: { |
| DEFINE_THREAD_SAFE_STATIC_LOCAL( |
| CustomCountHistogram, compile_non_cacheable_histogram, |
| new CustomCountHistogram("V8.CompileNoncacheableMicroSeconds", 0, |
| 1000000, 50)); |
| compile_non_cacheable_histogram.Count(elapsed_micro_seconds); |
| break; |
| } |
| case kInlineScript: { |
| DEFINE_THREAD_SAFE_STATIC_LOCAL( |
| CustomCountHistogram, compile_inline_histogram, |
| new CustomCountHistogram("V8.CompileInlineScriptMicroSeconds", 0, |
| 1000000, 50)); |
| compile_inline_histogram.Count(elapsed_micro_seconds); |
| break; |
| } |
| } |
| } |
| |
| // 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::Local<v8::Value> ThrowStackOverflowExceptionIfNeeded(v8::Isolate* isolate) { |
| 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, v8::MicrotasksScope::kDoNotRunMicrotasks); |
| V8PerIsolateData::From(isolate)->SetIsHandlingRecursionLevelError(true); |
| v8::Local<v8::Value> result = |
| v8::Function::New(isolate->GetCurrentContext(), |
| ThrowStackOverflowException, v8::Local<v8::Value>(), 0, |
| v8::ConstructorBehavior::kThrow) |
| .ToLocalChecked() |
| ->Call(v8::Undefined(isolate), 0, 0); |
| V8PerIsolateData::From(isolate)->SetIsHandlingRecursionLevelError(false); |
| return result; |
| } |
| |
| // Compile a script without any caching or compile options. |
| v8::MaybeLocal<v8::Script> CompileWithoutOptions( |
| V8CompileHistogram::Cacheability cacheability, |
| v8::Isolate* isolate, |
| v8::Local<v8::String> code, |
| v8::ScriptOrigin origin) { |
| V8CompileHistogram histogram_scope(cacheability); |
| v8::ScriptCompiler::Source source(code, origin); |
| return v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &source, |
| v8::ScriptCompiler::kNoCompileOptions); |
| } |
| |
| // Compile a script, and consume a V8 cache that was generated previously. |
| static v8::MaybeLocal<v8::Script> CompileAndConsumeCache( |
| CachedMetadataHandler* cache_handler, |
| PassRefPtr<CachedMetadata> cached_metadata, |
| v8::ScriptCompiler::CompileOptions compile_options, |
| v8::Isolate* isolate, |
| v8::Local<v8::String> code, |
| v8::ScriptOrigin origin) { |
| V8CompileHistogram histogram_scope(V8CompileHistogram::kCacheable); |
| const char* data = cached_metadata->Data(); |
| int length = cached_metadata->size(); |
| v8::ScriptCompiler::CachedData* cached_data = |
| new v8::ScriptCompiler::CachedData( |
| reinterpret_cast<const uint8_t*>(data), length, |
| v8::ScriptCompiler::CachedData::BufferNotOwned); |
| v8::ScriptCompiler::Source source(code, origin, cached_data); |
| v8::MaybeLocal<v8::Script> script = v8::ScriptCompiler::Compile( |
| isolate->GetCurrentContext(), &source, compile_options); |
| if (cached_data->rejected) |
| cache_handler->ClearCachedMetadata(CachedMetadataHandler::kSendToPlatform); |
| return script; |
| } |
| |
| // Compile a script, and produce a V8 cache for future use. |
| v8::MaybeLocal<v8::Script> CompileAndProduceCache( |
| CachedMetadataHandler* cache_handler, |
| uint32_t tag, |
| v8::ScriptCompiler::CompileOptions compile_options, |
| CachedMetadataHandler::CacheType cache_type, |
| v8::Isolate* isolate, |
| v8::Local<v8::String> code, |
| v8::ScriptOrigin origin) { |
| V8CompileHistogram histogram_scope(V8CompileHistogram::kCacheable); |
| v8::ScriptCompiler::Source source(code, origin); |
| v8::MaybeLocal<v8::Script> script = v8::ScriptCompiler::Compile( |
| isolate->GetCurrentContext(), &source, compile_options); |
| const v8::ScriptCompiler::CachedData* cached_data = source.GetCachedData(); |
| if (cached_data) { |
| const char* data = reinterpret_cast<const char*>(cached_data->data); |
| int length = cached_data->length; |
| if (length > 1024) { |
| // Omit histogram samples for small cache data to avoid outliers. |
| int cache_size_ratio = static_cast<int>(100.0 * length / code->Length()); |
| DEFINE_THREAD_SAFE_STATIC_LOCAL( |
| CustomCountHistogram, code_cache_size_histogram, |
| new CustomCountHistogram("V8.CodeCacheSizeRatio", 0, 10000, 50)); |
| code_cache_size_histogram.Count(cache_size_ratio); |
| } |
| cache_handler->ClearCachedMetadata(CachedMetadataHandler::kCacheLocally); |
| cache_handler->SetCachedMetadata(tag, data, length, cache_type); |
| } |
| return script; |
| } |
| |
| // Compile a script, and consume or produce a V8 Cache, depending on whether the |
| // given resource already has cached data available. |
| v8::MaybeLocal<v8::Script> CompileAndConsumeOrProduce( |
| CachedMetadataHandler* cache_handler, |
| uint32_t tag, |
| v8::ScriptCompiler::CompileOptions consume_options, |
| v8::ScriptCompiler::CompileOptions produce_options, |
| CachedMetadataHandler::CacheType cache_type, |
| v8::Isolate* isolate, |
| v8::Local<v8::String> code, |
| v8::ScriptOrigin origin) { |
| RefPtr<CachedMetadata> code_cache(cache_handler->GetCachedMetadata(tag)); |
| return code_cache.Get() |
| ? CompileAndConsumeCache(cache_handler, code_cache, |
| consume_options, isolate, code, origin) |
| : CompileAndProduceCache(cache_handler, tag, produce_options, |
| cache_type, isolate, code, origin); |
| } |
| |
| enum CacheTagKind { |
| kCacheTagParser = 0, |
| kCacheTagCode = 1, |
| kCacheTagTimeStamp = 3, |
| kCacheTagLast |
| }; |
| |
| static const int kCacheTagKindSize = 2; |
| |
| uint32_t CacheTag(CacheTagKind kind, CachedMetadataHandler* cache_handler) { |
| static_assert((1 << kCacheTagKindSize) >= kCacheTagLast, |
| "CacheTagLast must be large enough"); |
| |
| static uint32_t v8_cache_data_version = |
| v8::ScriptCompiler::CachedDataVersionTag() << kCacheTagKindSize; |
| |
| // A script can be (successfully) interpreted with different encodings, |
| // depending on the page it appears in. The cache doesn't know anything |
| // about encodings, but the cached data is specific to one encoding. If we |
| // later load the script from the cache and interpret it with a different |
| // encoding, the cached data is not valid for that encoding. |
| return (v8_cache_data_version | kind) + |
| StringHash::GetHash(cache_handler->Encoding()); |
| } |
| |
| // Check previously stored timestamp. |
| bool IsResourceHotForCaching(CachedMetadataHandler* cache_handler, |
| int hot_hours) { |
| const double cache_within_seconds = hot_hours * 60 * 60; |
| uint32_t tag = CacheTag(kCacheTagTimeStamp, cache_handler); |
| RefPtr<CachedMetadata> cached_metadata = |
| cache_handler->GetCachedMetadata(tag); |
| if (!cached_metadata) |
| return false; |
| double time_stamp; |
| const int size = sizeof(time_stamp); |
| DCHECK_EQ(cached_metadata->size(), static_cast<unsigned long>(size)); |
| memcpy(&time_stamp, cached_metadata->Data(), size); |
| return (WTF::CurrentTime() - time_stamp) < cache_within_seconds; |
| } |
| |
| // Final compile call for a streamed compilation. Most decisions have already |
| // been made, but we need to write back data into the cache. |
| v8::MaybeLocal<v8::Script> PostStreamCompile( |
| V8CacheOptions cache_options, |
| CachedMetadataHandler* cache_handler, |
| ScriptStreamer* streamer, |
| v8::Isolate* isolate, |
| v8::Local<v8::String> code, |
| v8::ScriptOrigin origin) { |
| V8CompileHistogram histogram_scope(V8CompileHistogram::kNoncacheable); |
| v8::MaybeLocal<v8::Script> script = v8::ScriptCompiler::Compile( |
| isolate->GetCurrentContext(), streamer->Source(), code, origin); |
| |
| if (!cache_handler) |
| return script; |
| |
| // If the non-streaming compiler uses the parser cache, retrieve and store |
| // the cache data. If the code cache uses time stamp as heuristic, set that |
| // time stamp. |
| switch (cache_options) { |
| case kV8CacheOptionsParse: { |
| const v8::ScriptCompiler::CachedData* new_cached_data = |
| streamer->Source()->GetCachedData(); |
| if (!new_cached_data) |
| break; |
| CachedMetadataHandler::CacheType cache_type = |
| (cache_options == kV8CacheOptionsParse) |
| ? CachedMetadataHandler::kSendToPlatform |
| : CachedMetadataHandler::kCacheLocally; |
| cache_handler->ClearCachedMetadata(cache_type); |
| cache_handler->SetCachedMetadata( |
| CacheTag(kCacheTagParser, cache_handler), |
| reinterpret_cast<const char*>(new_cached_data->data), |
| new_cached_data->length, cache_type); |
| break; |
| } |
| |
| case kV8CacheOptionsDefault: |
| case kV8CacheOptionsCode: |
| V8ScriptRunner::SetCacheTimeStamp(cache_handler); |
| break; |
| |
| case kV8CacheOptionsAlways: |
| // Currently V8CacheOptionsAlways doesn't support streaming. |
| NOTREACHED(); |
| case kV8CacheOptionsNone: |
| break; |
| } |
| return script; |
| } |
| |
| typedef Function<v8::MaybeLocal<v8::Script>(v8::Isolate*, |
| v8::Local<v8::String>, |
| v8::ScriptOrigin)> |
| CompileFn; |
| |
| // A notation convenience: WTF::bind<...> needs to be given the right argument |
| // types. We have an awful lot of bind calls below, all with the same types, so |
| // this local bind lets WTF::bind to all the work, but 'knows' the right |
| // parameter types. |
| // This version isn't quite as smart as the real WTF::bind, though, so you |
| // sometimes may still have to call the original. |
| template <typename... A> |
| std::unique_ptr<CompileFn> Bind(const A&... args) { |
| return WTF::Bind(args...); |
| } |
| |
| // Select a compile function from any of the above, mainly depending on |
| // cacheOptions. |
| static std::unique_ptr<CompileFn> SelectCompileFunction( |
| V8CacheOptions cache_options, |
| CachedMetadataHandler* cache_handler, |
| PassRefPtr<CachedMetadata> code_cache, |
| v8::Local<v8::String> code, |
| V8CompileHistogram::Cacheability cacheability_if_no_handler) { |
| static const int kMinimalCodeLength = 1024; |
| static const int kHotHours = 72; |
| |
| // Caching is not available in this case. |
| if (!cache_handler) |
| return Bind(CompileWithoutOptions, cacheability_if_no_handler); |
| |
| if (cache_options == kV8CacheOptionsNone) |
| return Bind(CompileWithoutOptions, V8CompileHistogram::kCacheable); |
| |
| // Caching is not worthwhile for small scripts. Do not use caching |
| // unless explicitly expected, indicated by the cache option. |
| if (code->Length() < kMinimalCodeLength) |
| return Bind(CompileWithoutOptions, V8CompileHistogram::kCacheable); |
| |
| // The cacheOptions will guide our strategy: |
| switch (cache_options) { |
| case kV8CacheOptionsParse: |
| // Use parser-cache; in-memory only. |
| return Bind(CompileAndConsumeOrProduce, WrapPersistent(cache_handler), |
| CacheTag(kCacheTagParser, cache_handler), |
| v8::ScriptCompiler::kConsumeParserCache, |
| v8::ScriptCompiler::kProduceParserCache, |
| CachedMetadataHandler::kCacheLocally); |
| break; |
| |
| case kV8CacheOptionsDefault: |
| case kV8CacheOptionsCode: |
| case kV8CacheOptionsAlways: { |
| // Use code caching for recently seen resources. |
| // Use compression depending on the cache option. |
| if (code_cache) { |
| return Bind(CompileAndConsumeCache, WrapPersistent(cache_handler), |
| std::move(code_cache), |
| v8::ScriptCompiler::kConsumeCodeCache); |
| } |
| if (cache_options != kV8CacheOptionsAlways && |
| !IsResourceHotForCaching(cache_handler, kHotHours)) { |
| V8ScriptRunner::SetCacheTimeStamp(cache_handler); |
| return Bind(CompileWithoutOptions, V8CompileHistogram::kCacheable); |
| } |
| uint32_t code_cache_tag = CacheTag(kCacheTagCode, cache_handler); |
| return Bind(CompileAndProduceCache, WrapPersistent(cache_handler), |
| code_cache_tag, v8::ScriptCompiler::kProduceCodeCache, |
| CachedMetadataHandler::kSendToPlatform); |
| break; |
| } |
| |
| case kV8CacheOptionsNone: |
| // Shouldn't happen, as this is handled above. |
| // Case is here so that compiler can check all cases are handled. |
| NOTREACHED(); |
| break; |
| } |
| |
| // All switch branches should return and we should never get here. |
| // But some compilers aren't sure, hence this default. |
| NOTREACHED(); |
| return Bind(CompileWithoutOptions, V8CompileHistogram::kCacheable); |
| } |
| |
| // Select a compile function for a streaming compile. |
| std::unique_ptr<CompileFn> SelectCompileFunction(V8CacheOptions cache_options, |
| ScriptResource* resource, |
| ScriptStreamer* streamer) { |
| // We don't stream scripts which don't have a Resource. |
| DCHECK(resource); |
| // Failed resources should never get this far. |
| DCHECK(!resource->ErrorOccurred()); |
| DCHECK(streamer->IsFinished()); |
| DCHECK(!streamer->StreamingSuppressed()); |
| return WTF::Bind(PostStreamCompile, cache_options, |
| WrapPersistent(resource->CacheHandler()), |
| WrapPersistent(streamer)); |
| } |
| } // namespace |
| |
| v8::MaybeLocal<v8::Script> V8ScriptRunner::CompileScript( |
| const ScriptSourceCode& source, |
| v8::Isolate* isolate, |
| AccessControlStatus access_control_status, |
| V8CacheOptions cache_options) { |
| if (source.Source().length() >= v8::String::kMaxLength) { |
| V8ThrowException::ThrowError(isolate, "Source file too large."); |
| return v8::Local<v8::Script>(); |
| } |
| return CompileScript( |
| V8String(isolate, source.Source()), source.Url(), source.SourceMapUrl(), |
| source.StartPosition(), isolate, source.GetResource(), source.Streamer(), |
| source.GetResource() ? source.GetResource()->CacheHandler() : nullptr, |
| access_control_status, cache_options); |
| } |
| |
| v8::MaybeLocal<v8::Script> V8ScriptRunner::CompileScript( |
| const String& code, |
| const String& file_name, |
| const String& source_map_url, |
| const TextPosition& text_position, |
| v8::Isolate* isolate, |
| CachedMetadataHandler* cache_metadata_handler, |
| AccessControlStatus access_control_status, |
| V8CacheOptions v8_cache_options) { |
| if (code.length() >= v8::String::kMaxLength) { |
| V8ThrowException::ThrowError(isolate, "Source file too large."); |
| return v8::Local<v8::Script>(); |
| } |
| return CompileScript(V8String(isolate, code), file_name, source_map_url, |
| text_position, isolate, nullptr, nullptr, |
| cache_metadata_handler, access_control_status, |
| v8_cache_options); |
| } |
| |
| v8::MaybeLocal<v8::Script> V8ScriptRunner::CompileScript( |
| v8::Local<v8::String> code, |
| const String& file_name, |
| const String& source_map_url, |
| const TextPosition& script_start_position, |
| v8::Isolate* isolate, |
| ScriptResource* resource, |
| ScriptStreamer* streamer, |
| CachedMetadataHandler* cache_handler, |
| AccessControlStatus access_control_status, |
| V8CacheOptions cache_options) { |
| TRACE_EVENT2( |
| "v8,devtools.timeline", "v8.compile", "fileName", file_name.Utf8(), |
| "data", |
| InspectorCompileScriptEvent::Data(file_name, script_start_position)); |
| |
| DCHECK(!streamer || resource); |
| DCHECK(!resource || resource->CacheHandler() == cache_handler); |
| |
| // NOTE: For compatibility with WebCore, ScriptSourceCode's line starts at |
| // 1, whereas v8 starts at 0. |
| v8::ScriptOrigin origin( |
| V8String(isolate, file_name), |
| v8::Integer::New(isolate, script_start_position.line_.ZeroBasedInt()), |
| v8::Integer::New(isolate, script_start_position.column_.ZeroBasedInt()), |
| v8::Boolean::New(isolate, access_control_status == kSharableCrossOrigin), |
| v8::Local<v8::Integer>(), V8String(isolate, source_map_url), |
| v8::Boolean::New(isolate, access_control_status == kOpaqueResource)); |
| |
| V8CompileHistogram::Cacheability cacheability_if_no_handler = |
| V8CompileHistogram::Cacheability::kNoncacheable; |
| if (!cache_handler && (script_start_position.line_.ZeroBasedInt() == 0) && |
| (script_start_position.column_.ZeroBasedInt() == 0)) |
| cacheability_if_no_handler = |
| V8CompileHistogram::Cacheability::kInlineScript; |
| |
| RefPtr<CachedMetadata> code_cache( |
| cache_handler ? cache_handler->GetCachedMetadata( |
| CacheTag(kCacheTagCode, cache_handler)) |
| : nullptr); |
| std::unique_ptr<CompileFn> compile_fn = |
| streamer ? SelectCompileFunction(cache_options, resource, streamer) |
| : SelectCompileFunction(cache_options, cache_handler, code_cache, |
| code, cacheability_if_no_handler); |
| |
| return (*compile_fn)(isolate, code, origin); |
| } |
| |
| v8::MaybeLocal<v8::Module> V8ScriptRunner::CompileModule( |
| v8::Isolate* isolate, |
| const String& source, |
| const String& file_name, |
| AccessControlStatus access_control_status) { |
| TRACE_EVENT1("v8", "v8.compileModule", "fileName", file_name.Utf8()); |
| // TODO(adamk): Add Inspector integration? |
| // TODO(adamk): Pass more info into ScriptOrigin. |
| v8::ScriptOrigin origin( |
| V8String(isolate, file_name), |
| v8::Integer::New(isolate, 0), // line_offset |
| v8::Integer::New(isolate, 0), // col_offset |
| v8::Boolean::New(isolate, access_control_status == kSharableCrossOrigin), |
| v8::Local<v8::Integer>(), // script id |
| v8::String::Empty(isolate), // source_map_url |
| v8::Boolean::New(isolate, access_control_status == kOpaqueResource), |
| v8::False(isolate), // is_wasm |
| v8::True(isolate)); // is_module |
| |
| v8::ScriptCompiler::Source script_source(V8String(isolate, source), origin); |
| return v8::ScriptCompiler::CompileModule(isolate, &script_source); |
| } |
| |
| void V8ScriptRunner::ReportExceptionForModule(v8::Isolate* isolate, |
| v8::Local<v8::Value> exception, |
| const String& file_name) { |
| // |origin| is for compiling a fragment that throws |exception|. |
| // Therefore |is_module| is false and |access_control_status| is |
| // kSharableCrossOrigin. |
| AccessControlStatus access_control_status = kSharableCrossOrigin; |
| v8::ScriptOrigin origin( |
| V8String(isolate, file_name), |
| v8::Integer::New(isolate, 0), // line_offset |
| v8::Integer::New(isolate, 0), // col_offset |
| v8::Boolean::New(isolate, access_control_status == kSharableCrossOrigin), |
| v8::Local<v8::Integer>(), // script id |
| v8::String::Empty(isolate), // source_map_url |
| v8::Boolean::New(isolate, access_control_status == kOpaqueResource), |
| v8::False(isolate), // is_wasm |
| v8::False(isolate)); // is_module |
| |
| ThrowException(isolate, exception, origin); |
| } |
| |
| v8::MaybeLocal<v8::Value> V8ScriptRunner::RunCompiledScript( |
| v8::Isolate* isolate, |
| v8::Local<v8::Script> script, |
| ExecutionContext* context) { |
| DCHECK(!script.IsEmpty()); |
| ScopedFrameBlamer frame_blamer( |
| context->IsDocument() ? ToDocument(context)->GetFrame() : nullptr); |
| TRACE_EVENT1("v8", "v8.run", "fileName", |
| TRACE_STR_COPY(*v8::String::Utf8Value( |
| script->GetUnboundScript()->GetScriptName()))); |
| |
| if (v8::MicrotasksScope::GetCurrentDepth(isolate) >= kMaxRecursionDepth) |
| return ThrowStackOverflowExceptionIfNeeded(isolate); |
| |
| CHECK(!context->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::MicrotasksScope microtasks_scope(isolate, |
| v8::MicrotasksScope::kRunMicrotasks); |
| probe::ExecuteScript probe(context); |
| result = script->Run(isolate->GetCurrentContext()); |
| } |
| |
| CHECK(!isolate->IsDead()); |
| return result; |
| } |
| |
| v8::MaybeLocal<v8::Value> V8ScriptRunner::CompileAndRunInternalScript( |
| v8::Local<v8::String> source, |
| v8::Isolate* isolate, |
| const String& file_name, |
| const TextPosition& script_start_position) { |
| v8::Local<v8::Script> script; |
| if (!V8ScriptRunner::CompileScript( |
| source, file_name, String(), script_start_position, isolate, nullptr, |
| nullptr, nullptr, kSharableCrossOrigin, kV8CacheOptionsDefault) |
| .ToLocal(&script)) |
| return v8::MaybeLocal<v8::Value>(); |
| |
| TRACE_EVENT0("v8", "v8.run"); |
| v8::MicrotasksScope microtasks_scope( |
| isolate, v8::MicrotasksScope::kDoNotRunMicrotasks); |
| v8::MaybeLocal<v8::Value> result = script->Run(isolate->GetCurrentContext()); |
| CHECK(!isolate->IsDead()); |
| return result; |
| } |
| |
| v8::MaybeLocal<v8::Value> V8ScriptRunner::RunCompiledInternalScript( |
| v8::Isolate* isolate, |
| v8::Local<v8::Script> script) { |
| TRACE_EVENT0("v8", "v8.run"); |
| v8::MicrotasksScope microtasks_scope( |
| isolate, 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"); |
| |
| int depth = v8::MicrotasksScope::GetCurrentDepth(isolate); |
| if (depth >= kMaxRecursionDepth) |
| return v8::MaybeLocal<v8::Value>( |
| ThrowStackOverflowExceptionIfNeeded(isolate)); |
| |
| CHECK(!context->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::MicrotasksScope microtasks_scope(isolate, |
| v8::MicrotasksScope::kRunMicrotasks); |
| probe::CallFunction probe(context, function, depth); |
| v8::MaybeLocal<v8::Value> result = |
| constructor->CallAsConstructor(isolate->GetCurrentContext(), argc, argv); |
| CHECK(!isolate->IsDead()); |
| 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) { |
| LocalFrame* frame = |
| context->IsDocument() ? ToDocument(context)->GetFrame() : nullptr; |
| ScopedFrameBlamer frame_blamer(frame); |
| TRACE_EVENT0("v8", "v8.callFunction"); |
| |
| int depth = v8::MicrotasksScope::GetCurrentDepth(isolate); |
| if (depth >= kMaxRecursionDepth) |
| return v8::MaybeLocal<v8::Value>( |
| ThrowStackOverflowExceptionIfNeeded(isolate)); |
| |
| CHECK(!context->IsIteratingOverObservers()); |
| |
| if (ScriptForbiddenScope::IsScriptForbidden()) { |
| ThrowScriptForbiddenException(isolate); |
| return v8::MaybeLocal<v8::Value>(); |
| } |
| |
| DCHECK(!frame || BindingSecurity::ShouldAllowAccessToFrame( |
| ToLocalDOMWindow(function->CreationContext()), frame, |
| BindingSecurity::ErrorReportOption::kDoNotReport)); |
| CHECK(!ThreadState::Current()->IsWrapperTracingForbidden()); |
| v8::MicrotasksScope microtasks_scope(isolate, |
| v8::MicrotasksScope::kRunMicrotasks); |
| probe::CallFunction probe(context, function, depth); |
| v8::MaybeLocal<v8::Value> result = |
| function->Call(isolate->GetCurrentContext(), receiver, argc, args); |
| CHECK(!isolate->IsDead()); |
| |
| return result; |
| } |
| |
| v8::MaybeLocal<v8::Value> V8ScriptRunner::CallInternalFunction( |
| v8::Local<v8::Function> function, |
| v8::Local<v8::Value> receiver, |
| int argc, |
| v8::Local<v8::Value> args[], |
| v8::Isolate* isolate) { |
| TRACE_EVENT0("v8", "v8.callFunction"); |
| CHECK(!ThreadState::Current()->IsWrapperTracingForbidden()); |
| v8::MicrotasksScope microtasks_scope( |
| isolate, v8::MicrotasksScope::kDoNotRunMicrotasks); |
| v8::MaybeLocal<v8::Value> result = |
| function->Call(isolate->GetCurrentContext(), receiver, argc, args); |
| CHECK(!isolate->IsDead()); |
| return result; |
| } |
| |
| v8::MaybeLocal<v8::Value> V8ScriptRunner::EvaluateModule( |
| v8::Local<v8::Module> module, |
| v8::Local<v8::Context> context, |
| v8::Isolate* isolate) { |
| TRACE_EVENT0("v8", "v8.evaluateModule"); |
| v8::MicrotasksScope microtasks_scope(isolate, |
| v8::MicrotasksScope::kRunMicrotasks); |
| return module->Evaluate(context); |
| } |
| |
| uint32_t V8ScriptRunner::TagForParserCache( |
| CachedMetadataHandler* cache_handler) { |
| return CacheTag(kCacheTagParser, cache_handler); |
| } |
| |
| uint32_t V8ScriptRunner::TagForCodeCache(CachedMetadataHandler* cache_handler) { |
| return CacheTag(kCacheTagCode, cache_handler); |
| } |
| |
| // Store a timestamp to the cache as hint. |
| void V8ScriptRunner::SetCacheTimeStamp(CachedMetadataHandler* cache_handler) { |
| double now = WTF::CurrentTime(); |
| uint32_t tag = CacheTag(kCacheTagTimeStamp, cache_handler); |
| cache_handler->ClearCachedMetadata(CachedMetadataHandler::kCacheLocally); |
| cache_handler->SetCachedMetadata(tag, reinterpret_cast<char*>(&now), |
| sizeof(now), |
| CachedMetadataHandler::kSendToPlatform); |
| } |
| |
| void V8ScriptRunner::ThrowException(v8::Isolate* isolate, |
| v8::Local<v8::Value> exception, |
| const v8::ScriptOrigin& origin) { |
| // In order for the current TryCatch to catch this exception and |
| // call MessageCallback when SetVerbose(true), create a v8::Function |
| // that calls isolate->throwException(). |
| // Unlike throwStackOverflowExceptionIfNeeded(), create a temporary Script |
| // with the specified ScriptOrigin. When the exception was created but not |
| // thrown yet, the ScriptOrigin of the thrower is set to the exception. |
| // v8::Function::New() has empty ScriptOrigin, and thus the exception will |
| // be "muted" (sanitized in our terminology) if CORS does not allow. |
| // https://html.spec.whatwg.org/multipage/webappapis.html#report-the-error |
| // Avoid compile and run scripts when API is available: crbug.com/639739 |
| v8::Local<v8::Script> script = |
| CompileWithoutOptions( |
| V8CompileHistogram::Cacheability::kNoncacheable, isolate, |
| V8AtomicString(isolate, "((e) => { throw e; })"), origin) |
| .ToLocalChecked(); |
| v8::Local<v8::Function> thrower = RunCompiledInternalScript(isolate, script) |
| .ToLocalChecked() |
| .As<v8::Function>(); |
| v8::Local<v8::Value> args[] = {exception}; |
| CallInternalFunction(thrower, thrower, WTF_ARRAY_LENGTH(args), args, isolate); |
| } |
| |
| v8::MaybeLocal<v8::Value> V8ScriptRunner::CallExtraHelper( |
| ScriptState* script_state, |
| const char* name, |
| size_t num_args, |
| v8::Local<v8::Value>* args) { |
| v8::Isolate* isolate = script_state->GetIsolate(); |
| v8::Local<v8::Value> function_value; |
| v8::Local<v8::Context> context = script_state->GetContext(); |
| if (!context->GetExtrasBindingObject() |
| ->Get(context, V8AtomicString(isolate, name)) |
| .ToLocal(&function_value)) |
| return v8::MaybeLocal<v8::Value>(); |
| v8::Local<v8::Function> function = function_value.As<v8::Function>(); |
| return V8ScriptRunner::CallInternalFunction(function, v8::Undefined(isolate), |
| num_args, args, isolate); |
| } |
| |
| } // namespace blink |
