Cleanup: Remove experimental V8 cache strategies that we discarded.

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 21 matching lines @@
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8RecursionScope.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fetch/CachedMetadata.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/Platform.h"
-#include "third_party/snappy/src/snappy.h"
 #include "wtf/CurrentTime.h"
 
 #if defined(WTF_OS_WIN)
 #include <malloc.h>
 #else
 #include <alloca.h>
 #endif
 
 namespace blink {
 
@@ skipping 56 matching lines @@
 
 // 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 histogramScope(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.
-v8::MaybeLocal<v8::Script> compileAndConsumeCache(CachedMetadataHandler* cacheHandler, unsigned tag, v8::ScriptCompiler::CompileOptions compileOptions, bool compressed, v8::Isolate* isolate, v8::Local<v8::String> code, v8::ScriptOrigin origin)
+v8::MaybeLocal<v8::Script> compileAndConsumeCache(CachedMetadataHandler* cacheHandler, unsigned tag, v8::ScriptCompiler::CompileOptions compileOptions, v8::Isolate* isolate, v8::Local<v8::String> code, v8::ScriptOrigin origin)
 {
     V8CompileHistogram histogramScope(V8CompileHistogram::Cacheable);
     CachedMetadata* cachedMetadata = cacheHandler->cachedMetadata(tag);
     const char* data = cachedMetadata->data();
     int length = cachedMetadata->size();
-    std::string uncompressedOutput;
-    bool invalidCache = false;
-    if (compressed) {
-        if (snappy::Uncompress(data, length, &uncompressedOutput)) {
-            data = uncompressedOutput.data();
-            length = uncompressedOutput.length();
-        } else {
-            invalidCache = true;
-        }
-    }
-    v8::MaybeLocal<v8::Script> script;
-    if (invalidCache) {
-        v8::ScriptCompiler::Source source(code, origin);
-        script = v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &source, v8::ScriptCompiler::kNoCompileOptions);
-    } else {
-        v8::ScriptCompiler::CachedData* cachedData = new v8::ScriptCompiler::CachedData(
-            reinterpret_cast<const uint8_t*>(data), length, v8::ScriptCompiler::CachedData::BufferNotOwned);
-        v8::ScriptCompiler::Source source(code, origin, cachedData);
-        script = v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &source, compileOptions);
-        invalidCache = cachedData->rejected;
-    }
-    if (invalidCache)
+    v8::ScriptCompiler::CachedData* cachedData = new v8::ScriptCompiler::CachedData(
+        reinterpret_cast<const uint8_t*>(data), length, v8::ScriptCompiler::CachedData::BufferNotOwned);
+    v8::ScriptCompiler::Source source(code, origin, cachedData);
+    v8::MaybeLocal<v8::Script> script = v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &source, compileOptions);
+    if (cachedData->rejected)
         cacheHandler->clearCachedMetadata(CachedMetadataHandler::SendToPlatform);
     return script;
 }
 
 // Compile a script, and produce a V8 cache for future use.
-v8::MaybeLocal<v8::Script> compileAndProduceCache(CachedMetadataHandler* cacheHandler, unsigned tag, v8::ScriptCompiler::CompileOptions compileOptions, bool compressed, CachedMetadataHandler::CacheType cacheType, v8::Isolate* isolate, v8::Local<v8::String> code, v8::ScriptOrigin origin)
+v8::MaybeLocal<v8::Script> compileAndProduceCache(CachedMetadataHandler* cacheHandler, unsigned tag, v8::ScriptCompiler::CompileOptions compileOptions, CachedMetadataHandler::CacheType cacheType, v8::Isolate* isolate, v8::Local<v8::String> code, v8::ScriptOrigin origin)
 {
     V8CompileHistogram histogramScope(V8CompileHistogram::Cacheable);
     v8::ScriptCompiler::Source source(code, origin);
     v8::MaybeLocal<v8::Script> script = v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &source, compileOptions);
     const v8::ScriptCompiler::CachedData* cachedData = source.GetCachedData();
     if (cachedData) {
         const char* data = reinterpret_cast<const char*>(cachedData->data);
         int length = cachedData->length;
-        std::string compressedOutput;
-        if (compressed) {
-            snappy::Compress(data, length, &compressedOutput);
-            data = compressedOutput.data();
-            length = compressedOutput.length();
-        }
         if (length > 1024) {
             // Omit histogram samples for small cache data to avoid outliers.
             int cacheSizeRatio = static_cast<int>(100.0 * length / code->Length());
             Platform::current()->histogramCustomCounts("V8.CodeCacheSizeRatio", cacheSizeRatio, 0, 10000, 50);
         }
         cacheHandler->clearCachedMetadata(CachedMetadataHandler::CacheLocally);
         cacheHandler->setCachedMetadata(tag, data, length, cacheType);
     }
     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* cacheHandler, unsigned tag, v8::ScriptCompiler::CompileOptions consumeOptions, v8::ScriptCompiler::CompileOptions produceOptions, bool compressed, CachedMetadataHandler::CacheType cacheType, v8::Isolate* isolate, v8::Local<v8::String> code, v8::ScriptOrigin origin)
+v8::MaybeLocal<v8::Script> compileAndConsumeOrProduce(CachedMetadataHandler* cacheHandler, unsigned tag, v8::ScriptCompiler::CompileOptions consumeOptions, v8::ScriptCompiler::CompileOptions produceOptions, CachedMetadataHandler::CacheType cacheType, v8::Isolate* isolate, v8::Local<v8::String> code, v8::ScriptOrigin origin)
 {
     return cacheHandler->cachedMetadata(tag)
-        ? compileAndConsumeCache(cacheHandler, tag, consumeOptions, compressed, isolate, code, origin)
-        : compileAndProduceCache(cacheHandler, tag, produceOptions, compressed, cacheType, isolate, code, origin);
+        ? compileAndConsumeCache(cacheHandler, tag, consumeOptions, isolate, code, origin)
+        : compileAndProduceCache(cacheHandler, tag, produceOptions, cacheType, isolate, code, origin);
 }
 
 enum CacheTagKind {
     CacheTagParser = 0,
     CacheTagCode = 1,
-    CacheTagCodeCompressed = 2,
     CacheTagTimeStamp = 3,
     CacheTagLast
 };
 
 static const int kCacheTagKindSize = 2;
 
 unsigned cacheTag(CacheTagKind kind, CachedMetadataHandler* cacheHandler)
 {
     static_assert((1 << kCacheTagKindSize) >= CacheTagLast, "CacheTagLast must be large enough");
 
@@ skipping 38 matching lines @@
     V8CompileHistogram histogramScope(V8CompileHistogram::Noncacheable);
     v8::MaybeLocal<v8::Script> script = v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), streamer->source(), code, origin);
 
     if (!cacheHandler)
         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 (cacheOptions) {
-    case V8CacheOptionsParseMemory:
     case V8CacheOptionsParse: {
         const v8::ScriptCompiler::CachedData* newCachedData = streamer->source()->GetCachedData();
         if (!newCachedData)
             break;
         CachedMetadataHandler::CacheType cacheType = (cacheOptions == V8CacheOptionsParse) ? CachedMetadataHandler::SendToPlatform : CachedMetadataHandler::CacheLocally;
         cacheHandler->clearCachedMetadata(cacheType);
         cacheHandler->setCachedMetadata(cacheTag(CacheTagParser, cacheHandler), reinterpret_cast<const char*>(newCachedData->data), newCachedData->length, cacheType);
         break;
     }
 
     case V8CacheOptionsDefault:
-    case V8CacheOptionsHeuristics:
-    case V8CacheOptionsHeuristicsMobile:
-    case V8CacheOptionsRecent:
-    case V8CacheOptionsRecentSmall:
+    case V8CacheOptionsCode:
         setCacheTimeStamp(cacheHandler);
         break;
 
-    default:
+    case V8CacheOptionsNone:
         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>
 PassOwnPtr<CompileFn> bind(const A&... args)
 {
     return WTF::bind<v8::Isolate*, v8::Local<v8::String>, v8::ScriptOrigin>(args...);
 }
 
 // Select a compile function from any of the above, mainly depending on
 // cacheOptions.
 PassOwnPtr<CompileFn> selectCompileFunction(V8CacheOptions cacheOptions, CachedMetadataHandler* cacheHandler, v8::Local<v8::String> code)
 {
     static const int minimalCodeLength = 1024;
+    static const int hotHours = 72;
 
     if (!cacheHandler)
         // Caching is not available in this case.
         return bind(compileWithoutOptions, V8CompileHistogram::Noncacheable);
 
     if (cacheOptions == V8CacheOptionsNone)
         return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
 
     // Caching is not worthwhile for small scripts.  Do not use caching
     // unless explicitly expected, indicated by the cache option.
-    if (code->Length() < minimalCodeLength && cacheOptions != V8CacheOptionsParse && cacheOptions != V8CacheOptionsCode)
+    if (code->Length() < minimalCodeLength)
         return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
 
     // The cacheOptions will guide our strategy:
-    // FIXME: Clean up code caching options. crbug.com/455187.
     switch (cacheOptions) {
-    case V8CacheOptionsParseMemory:
+    case V8CacheOptionsParse:
         // Use parser-cache; in-memory only.
-        return bind(compileAndConsumeOrProduce, cacheHandler, cacheTag(CacheTagParser, cacheHandler), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, false, CachedMetadataHandler::CacheLocally);
-        break;
-
-    case V8CacheOptionsParse:
-        // Use parser-cache.
-        return bind(compileAndConsumeOrProduce, cacheHandler, cacheTag(CacheTagParser, cacheHandler), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, false, CachedMetadataHandler::SendToPlatform);
-        break;
-
-    case V8CacheOptionsHeuristicsDefault:
-    case V8CacheOptionsCode:
-        // Use code caching.
-        return bind(compileAndConsumeOrProduce, cacheHandler, cacheTag(CacheTagCode, cacheHandler), v8::ScriptCompiler::kConsumeCodeCache, v8::ScriptCompiler::kProduceCodeCache, false, CachedMetadataHandler::SendToPlatform);
-        break;
-
-    case V8CacheOptionsHeuristicsDefaultMobile:
-    case V8CacheOptionsCodeCompressed:
-        // Use code caching with compression.
-        return bind(compileAndConsumeOrProduce, cacheHandler, cacheTag(CacheTagCodeCompressed, cacheHandler), v8::ScriptCompiler::kConsumeCodeCache, v8::ScriptCompiler::kProduceCodeCache, true, CachedMetadataHandler::SendToPlatform);
+        return bind(compileAndConsumeOrProduce, cacheHandler, cacheTag(CacheTagParser, cacheHandler), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, CachedMetadataHandler::CacheLocally);
         break;
 
     case V8CacheOptionsDefault:
-    case V8CacheOptionsHeuristics:
-    case V8CacheOptionsHeuristicsMobile:
-    case V8CacheOptionsRecent:
-    case V8CacheOptionsRecentSmall: {
+    case V8CacheOptionsCode: {
         // Use code caching for recently seen resources.
         // Use compression depending on the cache option.
-        bool compress = (cacheOptions == V8CacheOptionsRecentSmall || cacheOptions == V8CacheOptionsHeuristicsMobile);
-        unsigned codeCacheTag = cacheTag(compress ? CacheTagCodeCompressed : CacheTagCode, cacheHandler);
+        unsigned codeCacheTag = cacheTag(CacheTagCode, cacheHandler);
         CachedMetadata* codeCache = cacheHandler->cachedMetadata(codeCacheTag);
         if (codeCache)
-            return bind(compileAndConsumeCache, cacheHandler, codeCacheTag, v8::ScriptCompiler::kConsumeCodeCache, compress);
-        int hotHours = (cacheOptions == V8CacheOptionsRecent || cacheOptions == V8CacheOptionsRecentSmall) ? 36 : 72;
+            return bind(compileAndConsumeCache, cacheHandler, codeCacheTag, v8::ScriptCompiler::kConsumeCodeCache);
         if (!isResourceHotForCaching(cacheHandler, hotHours)) {
             setCacheTimeStamp(cacheHandler);
             return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
         }
-        return bind(compileAndProduceCache, cacheHandler, codeCacheTag, v8::ScriptCompiler::kProduceCodeCache, compress, CachedMetadataHandler::SendToPlatform);
+        return bind(compileAndProduceCache, cacheHandler, codeCacheTag, v8::ScriptCompiler::kProduceCodeCache, CachedMetadataHandler::SendToPlatform);
         break;
     }
 
     case V8CacheOptionsNone:
         // Shouldn't happen, as this is handled above.
         // Case is here so that compiler can check all cases are handled.
         ASSERT_NOT_REACHED();
         break;
     }
 
@@ skipping 181 matching lines @@
 {
     return cacheTag(CacheTagParser, cacheHandler);
 }
 
 unsigned V8ScriptRunner::tagForCodeCache(CachedMetadataHandler* cacheHandler)
 {
     return cacheTag(CacheTagCode, cacheHandler);
 }
 
 } // namespace blink