Implement Blink-side changes to enable V8 code caching.

Source/bindings/core/v8/V8ScriptRunner.cpp

 /*
  * 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
@@ skipping 44 matching lines @@
         // If we are already handling a recursion level error, we should
         // not invoke v8::Function::Call.
         return v8::Undefined(isolate);
     }
     V8PerIsolateData::from(isolate)->setIsHandlingRecursionLevelError(true);
     v8::Local<v8::Value> result = v8::Function::New(isolate, throwStackOverflowException)->Call(v8::Undefined(isolate), 0, 0);
     V8PerIsolateData::from(isolate)->setIsHandlingRecursionLevelError(false);
     return result;
 }
 
+// Make a decision on whether we want to use V8 caching and how.
+// dataType, produceOption, consumeOption are out parameters.
+bool CacheDecider(
+    const v8::Handle<v8::String> code,
+    const ScriptResource* resource,
+    const String& cacheOptions,
+    unsigned* dataType,
+    v8::ScriptCompiler::CompileOptions* compileOption,
+    bool* produce)
+{
+    *compileOption = v8::ScriptCompiler::kNoCompileOptions;
+    if (cacheOptions.isEmpty() || !resource || !resource->url().protocolIsInHTTPFamily() || code->Length() < 1024) {
+        return false;
+    }
+
+    unsigned v8VersionHash = StringHash::hash(v8::V8::GetVersion());
+    if (cacheOptions == "parse") {
+        *dataType = v8VersionHash * 2;
+        *produce = resource->cachedMetadata(*dataType);
+        *compileOption = *produce ? v8::ScriptCompiler::kProduceParserCache : v8::ScriptCompiler::kConsumeParserCache;
+        return true;
+    }
+    if (cacheOptions == "code") {
+        *dataType = v8VersionHash * 2 + 1;
+        *produce = resource->cachedMetadata(*dataType);
+        *compileOption = *produce ? v8::ScriptCompiler::kProduceCodeCache : v8::ScriptCompiler::kConsumeCodeCache;
+        return true;
+    }
+    return false;
+}
+
 } // namespace
 
-v8::Local<v8::Script> V8ScriptRunner::compileScript(const ScriptSourceCode& source, v8::Isolate* isolate, AccessControlStatus corsStatus)
+v8::Local<v8::Script> V8ScriptRunner::compileScript(const ScriptSourceCode& source, v8::Isolate* isolate, AccessControlStatus corsStatus, const String& cacheOptions)
 {
-    return compileScript(v8String(isolate, source.source()), source.url(), source.startPosition(), source.resource(), isolate, corsStatus);
+    return compileScript(v8String(isolate, source.source()), source.url(), source.startPosition(), source.resource(), isolate, corsStatus, cacheOptions);
 }
 
-v8::Local<v8::Script> V8ScriptRunner::compileScript(v8::Handle<v8::String> code, const String& fileName, const TextPosition& scriptStartPosition, ScriptResource* resource, v8::Isolate* isolate, AccessControlStatus corsStatus)
+v8::Local<v8::Script> V8ScriptRunner::compileScript(v8::Handle<v8::String> code, const String& fileName, const TextPosition& scriptStartPosition, ScriptResource* resource, v8::Isolate* isolate, AccessControlStatus corsStatus, const String& cacheOptions)
 {
-    // A pseudo-randomly chosen ID used to store and retrieve V8 ScriptData from
-    // the ScriptResource. If the format changes, this ID should be changed too.
-    static const unsigned dataTypeID = 0xECC13BD7;
-
-    // Very small scripts are not worth the effort to store cached data.
-    static const int minLengthForCachedData = 1024;
-
     TRACE_EVENT1("v8", "v8.compile", "fileName", fileName.utf8());
     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Compile");
 
     // NOTE: For compatibility with WebCore, ScriptSourceCode's line starts at
     // 1, whereas v8 starts at 0.
     v8::Handle<v8::String> name = v8String(isolate, fileName);
     v8::Handle<v8::Integer> line = v8::Integer::New(isolate, scriptStartPosition.m_line.zeroBasedInt());
     v8::Handle<v8::Integer> column = v8::Integer::New(isolate, scriptStartPosition.m_column.zeroBasedInt());
     v8::Handle<v8::Boolean> isSharedCrossOrigin = corsStatus == SharableCrossOrigin ? v8::True(isolate) : v8::False(isolate);
     v8::ScriptOrigin origin(name, line, column, isSharedCrossOrigin);
 
-    v8::ScriptCompiler::CompileOptions options = v8::ScriptCompiler::kNoCompileOptions;
-    OwnPtr<v8::ScriptCompiler::CachedData> cachedData;
-    if (resource) {
-        CachedMetadata* cachedMetadata = resource->cachedMetadata(dataTypeID);
-        if (cachedMetadata) {
-            // Ownership of the buffer is not transferred to CachedData.
-            cachedData = adoptPtr(new v8::ScriptCompiler::CachedData(reinterpret_cast<const uint8_t*>(cachedMetadata->data()), cachedMetadata->size()));
-        } else if (code->Length() >= minLengthForCachedData) {
-            options = v8::ScriptCompiler::kProduceDataToCache;
+    // V8 supports several forms of caching. Decide on the cache mode and call
+    // ScriptCompiler::Compile with suitable options.
+    unsigned dataTypeID = 0;
+    v8::ScriptCompiler::CompileOptions compileOption = v8::ScriptCompiler::kNoCompileOptions;
+    bool produce;
+    v8::Local<v8::Script> script;
+    if (CacheDecider(code, resource, cacheOptions, &dataTypeID, &compileOption, &produce)) {
+        if (produce) {
+            // Produce new cache data:
+            v8::ScriptCompiler::Source source(code, origin);
+            script = v8::ScriptCompiler::Compile(isolate, &source, compileOption);
+            const v8::ScriptCompiler::CachedData* cachedData = source.GetCachedData();
+            if (cachedData) {
+                resource->clearCachedMetadata();
+                resource->setCachedMetadata(
+                    dataTypeID,
+                    reinterpret_cast<const char*>(cachedData->data),
+                    cachedData->length);
+            }
+        } else {
+            // Consume existing cache data:
+            CachedMetadata* cachedMetadata = resource->cachedMetadata(dataTypeID);
+            v8::ScriptCompiler::CachedData* cachedData = new v8::ScriptCompiler::CachedData(
+                reinterpret_cast<const uint8_t*>(cachedMetadata->data()),
+                cachedMetadata->size(),
+                v8::ScriptCompiler::CachedData::BufferNotOwned);
+            v8::ScriptCompiler::Source source(code, origin, cachedData);
+            script = v8::ScriptCompiler::Compile(isolate, &source, compileOption);
         }
-    }
-    // source takes ownership of cachedData.
-    v8::ScriptCompiler::Source source(code, origin, cachedData.leakPtr());
-    v8::Local<v8::Script> script = v8::ScriptCompiler::Compile(isolate, &source, options);
-    if (options == v8::ScriptCompiler::kProduceDataToCache) {
-        const v8::ScriptCompiler::CachedData* newCachedData = source.GetCachedData();
-        if (newCachedData) {
-            // Ownership of the buffer is not transferred; source's cachedData continues to own it.
-            resource->setCachedMetadata(dataTypeID, reinterpret_cast<const char*>(newCachedData->data), newCachedData->length);
-        }
+    } else {
+        // No caching:
+        v8::ScriptCompiler::Source source(code, origin);
+        script = v8::ScriptCompiler::Compile(
+            isolate, &source, v8::ScriptCompiler::kNoCompileOptions);
     }
     return script;
 }
 
 v8::Local<v8::Value> V8ScriptRunner::runCompiledScript(v8::Handle<v8::Script> script, ExecutionContext* context, v8::Isolate* isolate)
 {
     if (script.IsEmpty())
         return v8::Local<v8::Value>();
     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
     TRACE_EVENT1("v8", "v8.run", "fileName", TRACE_STR_COPY(*v8::String::Utf8Value(script->GetUnboundScript()->GetScriptName())));
@@ skipping 94 matching lines @@
 {
     TRACE_EVENT0("v8", "v8.newInstance");
     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
     V8RecursionScope scope(isolate, context);
     v8::Local<v8::Object> result = function->NewInstance(argc, argv);
     crashIfV8IsDead();
     return result;
 }
 
 } // namespace blink