src/third_party/WebKit/Source/bindings/core/v8/V8ScriptRunner.cpp

   1 /*
   2  * Copyright (C) 2009 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "bindings/core/v8/V8ScriptRunner.h"
  28
  29 #include "bindings/core/v8/ScriptSourceCode.h"
  30 #include "bindings/core/v8/ScriptStreamer.h"
  31 #include "bindings/core/v8/V8Binding.h"
  32 #include "bindings/core/v8/V8GCController.h"
  33 #include "bindings/core/v8/V8RecursionScope.h"
  34 #include "bindings/core/v8/V8ThrowException.h"
  35 #include "core/dom/ExecutionContext.h"
  36 #include "core/fetch/CachedMetadata.h"
  37 #include "core/fetch/ScriptResource.h"
  38 #include "platform/TraceEvent.h"
  39
  40 namespace blink {
  41
  42 namespace {
  43
  44 // In order to make sure all pending messages to be processed in
  45 // v8::Function::Call, we don't call handleMaxRecursionDepthExceeded
  46 // directly. Instead, we create a v8::Function of
  47 // throwStackOverflowException and call it.
  48 void throwStackOverflowException(const v8::FunctionCallbackInfo<v8::Value>& info)
  49 {
  50     V8ThrowException::throwRangeError("Maximum call stack size exceeded.", info.GetIsolate());
  51 }
  52
  53 v8::Local<v8::Value> throwStackOverflowExceptionIfNeeded(v8::Isolate* isolate)
  54 {
  55     if (V8PerIsolateData::from(isolate)->isHandlingRecursionLevelError()) {
  56         // If we are already handling a recursion level error, we should
  57         // not invoke v8::Function::Call.
  58         return v8::Undefined(isolate);
  59     }
  60     V8PerIsolateData::from(isolate)->setIsHandlingRecursionLevelError(true);
  61     v8::Local<v8::Value> result = v8::Function::New(isolate, throwStackOverflowException)->Call(v8::Undefined(isolate), 0, 0);
  62     V8PerIsolateData::from(isolate)->setIsHandlingRecursionLevelError(false);
  63     return result;
  64 }
  65
  66 v8::Local<v8::Script> compileAndProduceCache(v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin, ScriptResource* resource, v8::ScriptCompiler::CompileOptions options, unsigned cacheTag, Resource::MetadataCacheType cacheType)
  67 {
  68     v8::ScriptCompiler::Source source(code, origin);
  69     v8::Local<v8::Script> script = v8::ScriptCompiler::Compile(isolate, &source, options);
  70     const v8::ScriptCompiler::CachedData* cachedData = source.GetCachedData();
  71     if (resource && cachedData) {
  72         resource->clearCachedMetadata();
  73         resource->setCachedMetadata(
  74             cacheTag,
  75             reinterpret_cast<const char*>(cachedData->data),
  76             cachedData->length,
  77             cacheType);
  78     }
  79     return script;
  80 }
  81
  82 v8::Local<v8::Script> compileAndConsumeCache(v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin, ScriptResource* resource, v8::ScriptCompiler::CompileOptions options, unsigned cacheTag)
  83 {
  84     // Consume existing cache data:
  85     CachedMetadata* cachedMetadata = resource->cachedMetadata(cacheTag);
  86     v8::ScriptCompiler::CachedData* cachedData = new v8::ScriptCompiler::CachedData(
  87         reinterpret_cast<const uint8_t*>(cachedMetadata->data()),
  88         cachedMetadata->size(),
  89         v8::ScriptCompiler::CachedData::BufferNotOwned);
  90     v8::ScriptCompiler::Source source(code, origin, cachedData);
  91     return v8::ScriptCompiler::Compile(isolate, &source, options);
  92 }
  93
  94 } // namespace
  95
  96 v8::Local<v8::Script> V8ScriptRunner::compileScript(const ScriptSourceCode& source, v8::Isolate* isolate, AccessControlStatus corsStatus, V8CacheOptions cacheOptions)
  97 {
  98     return compileScript(v8String(isolate, source.source()), source.url(), source.startPosition(), source.resource(), source.streamer(), isolate, corsStatus, cacheOptions);
  99 }
 100
 101 v8::Local<v8::Script> V8ScriptRunner::compileScript(v8::Handle<v8::String> code, const String& fileName, const TextPosition& scriptStartPosition, ScriptResource* resource, ScriptStreamer* streamer, v8::Isolate* isolate, AccessControlStatus corsStatus, V8CacheOptions cacheOptions)
 102 {
 103     TRACE_EVENT1("v8", "v8.compile", "fileName", fileName.utf8());
 104     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Compile");
 105
 106     // NOTE: For compatibility with WebCore, ScriptSourceCode's line starts at
 107     // 1, whereas v8 starts at 0.
 108     v8::Handle<v8::String> name = v8String(isolate, fileName);
 109     v8::Handle<v8::Integer> line = v8::Integer::New(isolate, scriptStartPosition.m_line.zeroBasedInt());
 110     v8::Handle<v8::Integer> column = v8::Integer::New(isolate, scriptStartPosition.m_column.zeroBasedInt());
 111     v8::Handle<v8::Boolean> isSharedCrossOrigin = corsStatus == SharableCrossOrigin ? v8::True(isolate) : v8::False(isolate);
 112     v8::ScriptOrigin origin(name, line, column, isSharedCrossOrigin);
 113
 114     v8::Local<v8::Script> script;
 115     unsigned cacheTag = 0;
 116     if (streamer) {
 117         // We don't stream scripts which don't have a Resource.
 118         ASSERT(resource);
 119         // Failed resources should never get this far.
 120         ASSERT(!resource->errorOccurred());
 121         ASSERT(streamer->isFinished());
 122         ASSERT(!streamer->streamingSuppressed());
 123         script = v8::ScriptCompiler::Compile(isolate, streamer->source(), code, origin);
 124         // Whether to produce the cached data or not is decided when the
 125         // streamer is started. Here we only need to get the data out.
 126         const v8::ScriptCompiler::CachedData* newCachedData = streamer->source()->GetCachedData();
 127         if (newCachedData) {
 128             resource->clearCachedMetadata();
 129             resource->setCachedMetadata(streamer->cachedDataType(), reinterpret_cast<const char*>(newCachedData->data), newCachedData->length);
 130         }
 131     } else if (!resource || !resource->url().protocolIsInHTTPFamily() || code->Length() < 1024) {
 132         v8::ScriptCompiler::Source source(code, origin);
 133         script = v8::ScriptCompiler::Compile(isolate, &source, v8::ScriptCompiler::kNoCompileOptions);
 134     } else {
 135         switch (cacheOptions) {
 136         case V8CacheOptionsParse:
 137             cacheTag = tagForParserCache();
 138             script = resource->cachedMetadata(cacheTag)
 139                 ? compileAndConsumeCache(isolate, code, origin, resource, v8::ScriptCompiler::kConsumeParserCache, cacheTag)
 140                 : compileAndProduceCache(isolate, code, origin, resource, v8::ScriptCompiler::kProduceParserCache, cacheTag, Resource::SendToPlatform);
 141             break;
 142         case V8CacheOptionsCode:
 143             cacheTag = tagForCodeCache();
 144             script = resource->cachedMetadata(cacheTag)
 145                 ? compileAndConsumeCache(isolate, code, origin, resource, v8::ScriptCompiler::kConsumeCodeCache, cacheTag)
 146                 : compileAndProduceCache(isolate, code, origin, resource, v8::ScriptCompiler::kProduceCodeCache, cacheTag, Resource::SendToPlatform);
 147             break;
 148         case V8CacheOptionsOff:
 149             // Previous behaviour was to always generate an in-memory parser
 150             // cache. We emulate this here.
 151             // FIXME: Determine whether this should get its own setting, so we
 152             //        can also have a true 'off'.
 153             cacheTag = tagForParserCache();
 154             script = resource->cachedMetadata(cacheTag)
 155                 ? compileAndConsumeCache(isolate, code, origin, resource, v8::ScriptCompiler::kConsumeParserCache, cacheTag)
 156                 : compileAndProduceCache(isolate, code, origin, resource, v8::ScriptCompiler::kProduceParserCache, cacheTag, Resource::CacheLocally);
 157             break;
 158         }
 159     }
 160     return script;
 161 }
 162
 163 v8::Local<v8::Value> V8ScriptRunner::runCompiledScript(v8::Handle<v8::Script> script, ExecutionContext* context, v8::Isolate* isolate)
 164 {
 165     if (script.IsEmpty())
 166         return v8::Local<v8::Value>();
 167     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
 168     TRACE_EVENT1("v8", "v8.run", "fileName", TRACE_STR_COPY(*v8::String::Utf8Value(script->GetUnboundScript()->GetScriptName())));
 169
 170     if (V8RecursionScope::recursionLevel(isolate) >= kMaxRecursionDepth)
 171         return throwStackOverflowExceptionIfNeeded(isolate);
 172
 173     RELEASE_ASSERT(!context->isIteratingOverObservers());
 174
 175     // Run the script and keep track of the current recursion depth.
 176     v8::Local<v8::Value> result;
 177     {
 178         V8RecursionScope recursionScope(isolate);
 179         result = script->Run();
 180     }
 181
 182     if (result.IsEmpty())
 183         return v8::Local<v8::Value>();
 184
 185     crashIfV8IsDead();
 186     return result;
 187 }
 188
 189 v8::Local<v8::Value> V8ScriptRunner::compileAndRunInternalScript(v8::Handle<v8::String> source, v8::Isolate* isolate, const String& fileName, const TextPosition& scriptStartPosition)
 190 {
 191     v8::Handle<v8::Script> script = V8ScriptRunner::compileScript(source, fileName, scriptStartPosition, 0, 0, isolate);
 192     if (script.IsEmpty())
 193         return v8::Local<v8::Value>();
 194
 195     TRACE_EVENT0("v8", "v8.run");
 196     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
 197     V8RecursionScope::MicrotaskSuppression recursionScope(isolate);
 198     v8::Local<v8::Value> result = script->Run();
 199     crashIfV8IsDead();
 200     return result;
 201 }
 202
 203 v8::Local<v8::Value> V8ScriptRunner::runCompiledInternalScript(v8::Handle<v8::Script> script, v8::Isolate* isolate)
 204 {
 205     TRACE_EVENT0("v8", "v8.run");
 206     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
 207     V8RecursionScope::MicrotaskSuppression recursionScope(isolate);
 208     v8::Local<v8::Value> result = script->Run();
 209     crashIfV8IsDead();
 210     return result;
 211 }
 212
 213 v8::Local<v8::Value> V8ScriptRunner::callFunction(v8::Handle<v8::Function> function, ExecutionContext* context, v8::Handle<v8::Value> receiver, int argc, v8::Handle<v8::Value> args[], v8::Isolate* isolate)
 214 {
 215     TRACE_EVENT0("v8", "v8.callFunction");
 216     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
 217
 218     if (V8RecursionScope::recursionLevel(isolate) >= kMaxRecursionDepth)
 219         return throwStackOverflowExceptionIfNeeded(isolate);
 220
 221     RELEASE_ASSERT(!context->isIteratingOverObservers());
 222
 223     V8RecursionScope recursionScope(isolate);
 224     v8::Local<v8::Value> result = function->Call(receiver, argc, args);
 225     crashIfV8IsDead();
 226     return result;
 227 }
 228
 229 v8::Local<v8::Value> V8ScriptRunner::callInternalFunction(v8::Handle<v8::Function> function, v8::Handle<v8::Value> receiver, int argc, v8::Handle<v8::Value> args[], v8::Isolate* isolate)
 230 {
 231     TRACE_EVENT0("v8", "v8.callFunction");
 232     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
 233     V8RecursionScope::MicrotaskSuppression recursionScope(isolate);
 234     v8::Local<v8::Value> result = function->Call(receiver, argc, args);
 235     crashIfV8IsDead();
 236     return result;
 237 }
 238
 239 v8::Local<v8::Value> V8ScriptRunner::callAsFunction(v8::Isolate* isolate, v8::Handle<v8::Object> object, v8::Handle<v8::Value> receiver, int argc, v8::Handle<v8::Value> args[])
 240 {
 241     TRACE_EVENT0("v8", "v8.callFunction");
 242     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
 243
 244     V8RecursionScope::MicrotaskSuppression recursionScope(isolate);
 245     v8::Local<v8::Value> result = object->CallAsFunction(receiver, argc, args);
 246     crashIfV8IsDead();
 247     return result;
 248 }
 249
 250 v8::Local<v8::Object> V8ScriptRunner::instantiateObject(v8::Isolate* isolate, v8::Handle<v8::ObjectTemplate> objectTemplate)
 251 {
 252     TRACE_EVENT0("v8", "v8.newInstance");
 253     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
 254
 255     V8RecursionScope::MicrotaskSuppression scope(isolate);
 256     v8::Local<v8::Object> result = objectTemplate->NewInstance();
 257     crashIfV8IsDead();
 258     return result;
 259 }
 260
 261 v8::Local<v8::Object> V8ScriptRunner::instantiateObject(v8::Isolate* isolate, v8::Handle<v8::Function> function, int argc, v8::Handle<v8::Value> argv[])
 262 {
 263     TRACE_EVENT0("v8", "v8.newInstance");
 264     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
 265
 266     V8RecursionScope::MicrotaskSuppression scope(isolate);
 267     v8::Local<v8::Object> result = function->NewInstance(argc, argv);
 268     crashIfV8IsDead();
 269     return result;
 270 }
 271
 272 v8::Local<v8::Object> V8ScriptRunner::instantiateObjectInDocument(v8::Isolate* isolate, v8::Handle<v8::Function> function, ExecutionContext* context, int argc, v8::Handle<v8::Value> argv[])
 273 {
 274     TRACE_EVENT0("v8", "v8.newInstance");
 275     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
 276     V8RecursionScope scope(isolate);
 277     v8::Local<v8::Object> result = function->NewInstance(argc, argv);
 278     crashIfV8IsDead();
 279     return result;
 280 }
 281
 282 unsigned V8ScriptRunner::tagForParserCache()
 283 {
 284     return StringHash::hash(v8::V8::GetVersion()) * 2;
 285 }
 286
 287 unsigned V8ScriptRunner::tagForCodeCache()
 288 {
 289     return StringHash::hash(v8::V8::GetVersion()) * 2 + 1;
 290 }
 291
 292 } // namespace blink