[K6] Replace bind() + GCed pointers with retainedRef()

third_party/WebKit/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 245 matching lines @@
 
 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)
+PassOwnPtr<CompileFn> bind(A&&... args)
 {
-    return WTF::bind<v8::Isolate*, v8::Local<v8::String>, v8::ScriptOrigin>(args...);
+    return WTF::bind<v8::Isolate*, v8::Local<v8::String>, v8::ScriptOrigin>(std::forward<A>(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, V8CompileHistogram::Cacheability cacheabilityIfNoHandler)
 {
     static const int minimalCodeLength = 1024;
     static const int hotHours = 72;
 
     // Caching is not available in this case.
     if (!cacheHandler)
         return bind(compileWithoutOptions, cacheabilityIfNoHandler);
 
     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)
         return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
 
     // The cacheOptions will guide our strategy:
     switch (cacheOptions) {
     case V8CacheOptionsParse:
         // Use parser-cache; in-memory only.
-        return bind(compileAndConsumeOrProduce, cacheHandler, cacheTag(CacheTagParser, cacheHandler), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, CachedMetadataHandler::CacheLocally);
+        return bind(compileAndConsumeOrProduce, retainedRef(cacheHandler), cacheTag(CacheTagParser, cacheHandler), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, CachedMetadataHandler::CacheLocally);
         break;
 
     case V8CacheOptionsDefault:
     case V8CacheOptionsCode: {
         // Use code caching for recently seen resources.
         // Use compression depending on the cache option.
         unsigned codeCacheTag = cacheTag(CacheTagCode, cacheHandler);
         CachedMetadata* codeCache = cacheHandler->cachedMetadata(codeCacheTag);
         if (codeCache)
-            return bind(compileAndConsumeCache, cacheHandler, codeCacheTag, v8::ScriptCompiler::kConsumeCodeCache);
+            return bind(compileAndConsumeCache, retainedRef(cacheHandler), codeCacheTag, v8::ScriptCompiler::kConsumeCodeCache);
         if (!isResourceHotForCaching(cacheHandler, hotHours)) {
             V8ScriptRunner::setCacheTimeStamp(cacheHandler);
             return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
         }
-        return bind(compileAndProduceCache, cacheHandler, codeCacheTag, v8::ScriptCompiler::kProduceCodeCache, CachedMetadataHandler::SendToPlatform);
+        return bind(compileAndProduceCache, retainedRef(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;
     }
 
     // All switch branches should return and we should never get here.
     // But some compilers aren't sure, hence this default.
     ASSERT_NOT_REACHED();
     return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
 }
 
 // Select a compile function for a streaming compile.
 PassOwnPtr<CompileFn> selectCompileFunction(V8CacheOptions cacheOptions, ScriptResource* resource, ScriptStreamer* streamer)
 {
     // We don't stream scripts which don't have a Resource.
     ASSERT(resource);
     // Failed resources should never get this far.
     ASSERT(!resource->errorOccurred());
     ASSERT(streamer->isFinished());
     ASSERT(!streamer->streamingSuppressed());
-    return WTF::bind<v8::Isolate*, v8::Local<v8::String>, v8::ScriptOrigin>(postStreamCompile, cacheOptions, resource->cacheHandler(), streamer);
+    return WTF::bind<v8::Isolate*, v8::Local<v8::String>, v8::ScriptOrigin>(postStreamCompile, cacheOptions, retainedRef(resource->cacheHandler()), retainedRef(streamer));
 }
 } // namespace
 
 v8::MaybeLocal<v8::Script> V8ScriptRunner::compileScript(const ScriptSourceCode& source, v8::Isolate* isolate, AccessControlStatus accessControlStatus, V8CacheOptions cacheOptions)
 {
     if (source.source().length() >= v8::String::kMaxLength) {
         V8ThrowException::throwGeneralError(isolate, "Source file too large.");
         return v8::Local<v8::Script>();
     }
     return compileScript(v8String(isolate, source.source()), source.url(), source.sourceMapUrl(), source.startPosition(), isolate, source.resource(), source.streamer(), source.resource() ? source.resource()->cacheHandler() : nullptr, accessControlStatus, cacheOptions);
@@ skipping 177 matching lines @@
 // Store a timestamp to the cache as hint.
 void V8ScriptRunner::setCacheTimeStamp(CachedMetadataHandler* cacheHandler)
 {
     double now = WTF::currentTime();
     unsigned tag = cacheTag(CacheTagTimeStamp, cacheHandler);
     cacheHandler->clearCachedMetadata(CachedMetadataHandler::CacheLocally);
     cacheHandler->setCachedMetadata(tag, reinterpret_cast<char*>(&now), sizeof(now), CachedMetadataHandler::SendToPlatform);
 }
 
 } // namespace blink