CachedMetadata support for ServiceWorker script.

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 92 matching lines @@
 
 // Compile a script without any caching or compile options.
 v8::Local<v8::Script> compileWithoutOptions(V8CompileHistogram::Cacheability cacheability, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
 {
     V8CompileHistogram histogramScope(cacheability);
     v8::ScriptCompiler::Source source(code, origin);
     return v8::ScriptCompiler::Compile(isolate, &source, v8::ScriptCompiler::kNoCompileOptions);
 }
 
 // Compile a script, and consume a V8 cache that was generated previously.
-v8::Local<v8::Script> compileAndConsumeCache(ScriptResource* resource, unsigned tag, v8::ScriptCompiler::CompileOptions compileOptions, bool compressed, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
+v8::Local<v8::Script> compileAndConsumeCache(CachedMetadataHandler* cacheHandler, unsigned tag, v8::ScriptCompiler::CompileOptions compileOptions, bool compressed, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
 {
     V8CompileHistogram histogramScope(V8CompileHistogram::Cacheable);
-    CachedMetadata* cachedMetadata = resource->cachedMetadata(tag);
+    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::Local<v8::Script> script;
     if (invalidCache) {
         v8::ScriptCompiler::Source source(code, origin);
         script = v8::ScriptCompiler::Compile(isolate, &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, &source, compileOptions);
         invalidCache = cachedData->rejected;
     }
     if (invalidCache)
-        resource->clearCachedMetadata(Resource::SendToPlatform);
+        cacheHandler->clearCachedMetadata(CachedMetadataHandler::SendToPlatform);
     return script;
 }
 
 // Compile a script, and produce a V8 cache for future use.
-v8::Local<v8::Script> compileAndProduceCache(ScriptResource* resource, unsigned tag, v8::ScriptCompiler::CompileOptions compileOptions, bool compressed, Resource::MetadataCacheType cacheType, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
+v8::Local<v8::Script> compileAndProduceCache(CachedMetadataHandler* cacheHandler, unsigned tag, v8::ScriptCompiler::CompileOptions compileOptions, bool compressed, CachedMetadataHandler::CacheType cacheType, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
 {
     V8CompileHistogram histogramScope(V8CompileHistogram::Cacheable);
     v8::ScriptCompiler::Source source(code, origin);
     v8::Local<v8::Script> script = v8::ScriptCompiler::Compile(isolate, &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());
             blink::Platform::current()->histogramCustomCounts("V8.CodeCacheSizeRatio", cacheSizeRatio, 0, 10000, 50);
         }
-        resource->clearCachedMetadata();
-        resource->setCachedMetadata(tag, data, length, cacheType);
+        cacheHandler->clearCachedMetadata();
+        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::Local<v8::Script> compileAndConsumeOrProduce(ScriptResource* resource, unsigned tag, v8::ScriptCompiler::CompileOptions consumeOptions, v8::ScriptCompiler::CompileOptions produceOptions, bool compressed, Resource::MetadataCacheType cacheType, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
+v8::Local<v8::Script> compileAndConsumeOrProduce(CachedMetadataHandler* cacheHandler, unsigned tag, v8::ScriptCompiler::CompileOptions consumeOptions, v8::ScriptCompiler::CompileOptions produceOptions, bool compressed, CachedMetadataHandler::CacheType cacheType, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
 {
-    return resource->cachedMetadata(tag)
-        ? compileAndConsumeCache(resource, tag, consumeOptions, compressed, isolate, code, origin)
-        : compileAndProduceCache(resource, tag, produceOptions, compressed, cacheType, isolate, code, origin);
+    return cacheHandler->cachedMetadata(tag)
+        ? compileAndConsumeCache(cacheHandler, tag, consumeOptions, compressed, isolate, code, origin)
+        : compileAndProduceCache(cacheHandler, tag, produceOptions, compressed, cacheType, isolate, code, origin);
 }
 
 enum CacheTagKind {
     CacheTagParser = 0,
     CacheTagCode = 1,
     CacheTagCodeCompressed = 2,
     CacheTagTimeStamp = 3,
     CacheTagLast
 };
 
 static const int kCacheTagKindSize = 2;
 
-unsigned cacheTag(CacheTagKind kind, Resource* resource)
+unsigned cacheTag(CacheTagKind kind, CachedMetadataHandler* cacheHandler)
 {
     static_assert((1 << kCacheTagKindSize) >= CacheTagLast, "CacheTagLast must be large enough");
 
     static unsigned v8CacheDataVersion = 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 (v8CacheDataVersion | kind) + StringHash::hash(resource->encoding());
+    return (v8CacheDataVersion | kind) + StringHash::hash(cacheHandler->encoding());
 }
 
 // Store a timestamp to the cache as hint.
-void setCacheTimeStamp(ScriptResource* resource)
+void setCacheTimeStamp(CachedMetadataHandler* cacheHandler)
 {
     double now = WTF::currentTime();
-    unsigned tag = cacheTag(CacheTagTimeStamp, resource);
-    resource->setCachedMetadata(tag, reinterpret_cast<char*>(&now), sizeof(now), Resource::SendToPlatform);
+    unsigned tag = cacheTag(CacheTagTimeStamp, cacheHandler);
+    cacheHandler->setCachedMetadata(tag, reinterpret_cast<char*>(&now), sizeof(now), CachedMetadataHandler::SendToPlatform);
 }
 
 // Check previously stored timestamp.
-bool isResourceHotForCaching(ScriptResource* resource, int hotHours)
+bool isResourceHotForCaching(CachedMetadataHandler* cacheHandler, int hotHours)
 {
     const double kCacheWithinSeconds = hotHours * 60 * 60;
-    unsigned tag = cacheTag(CacheTagTimeStamp, resource);
-    CachedMetadata* cachedMetadata = resource->cachedMetadata(tag);
+    unsigned tag = cacheTag(CacheTagTimeStamp, cacheHandler);
+    CachedMetadata* cachedMetadata = cacheHandler->cachedMetadata(tag);
     if (!cachedMetadata)
         return false;
     double timeStamp;
     const int size = sizeof(timeStamp);
     ASSERT(cachedMetadata->size() == size);
     memcpy(&timeStamp, cachedMetadata->data(), size);
     return (WTF::currentTime() - timeStamp) < kCacheWithinSeconds;
 }
 
 // Final compile call for a streamed compilation. Most decisions have already
 // been made, but we need to write back data into the cache.
-v8::Local<v8::Script> postStreamCompile(ScriptResource* resource, ScriptStreamer* streamer, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
+v8::Local<v8::Script> postStreamCompile(CachedMetadataHandler* cacheHandler, ScriptStreamer* streamer, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
 {
     V8CompileHistogram histogramScope(V8CompileHistogram::Noncacheable);
     v8::Local<v8::Script> script = v8::ScriptCompiler::Compile(isolate, streamer->source(), code, origin);
 
     // Whether to produce the cached data or not is decided when the
     // streamer is started. Here we only need to get the data out.
     const v8::ScriptCompiler::CachedData* newCachedData = streamer->source()->GetCachedData();
     if (newCachedData) {
-        resource->clearCachedMetadata();
+        cacheHandler->clearCachedMetadata();
         v8::ScriptCompiler::CompileOptions options = streamer->compileOptions();
         switch (options) {
         case v8::ScriptCompiler::kProduceParserCache:
-            resource->setCachedMetadata(cacheTag(CacheTagParser, resource), reinterpret_cast<const char*>(newCachedData->data), newCachedData->length, Resource::CacheLocally);
+            cacheHandler->setCachedMetadata(cacheTag(CacheTagParser, cacheHandler), reinterpret_cast<const char*>(newCachedData->data), newCachedData->length, CachedMetadataHandler::CacheLocally);
             break;
         case v8::ScriptCompiler::kProduceCodeCache:
-            resource->setCachedMetadata(cacheTag(CacheTagCode, resource), reinterpret_cast<const char*>(newCachedData->data), newCachedData->length, Resource::SendToPlatform);
+            cacheHandler->setCachedMetadata(cacheTag(CacheTagCode, cacheHandler), reinterpret_cast<const char*>(newCachedData->data), newCachedData->length, CachedMetadataHandler::SendToPlatform);
             break;
         default:
             break;
         }
     }
 
     return script;
 }
 
 typedef Function<v8::Local<v8::Script>(v8::Isolate*, v8::Handle<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::Handle<v8::String>, v8::ScriptOrigin>(args...);
 }
 
 // Select a compile function from any of the above, mainly depending on
 // cacheOptions.
-PassOwnPtr<CompileFn> selectCompileFunction(V8CacheOptions cacheOptions, ScriptResource* resource, v8::Handle<v8::String> code)
+PassOwnPtr<CompileFn> selectCompileFunction(V8CacheOptions cacheOptions, ScriptResource* resource, CachedMetadataHandler* cacheHandler, v8::Handle<v8::String> code)
 {
     static const int minimalCodeLength = 1024;
 
-    if (!resource || !resource->url().protocolIsInHTTPFamily())
+    if ((resource && !resource->url().protocolIsInHTTPFamily()) || (!resource && !cacheHandler))

[vogelheim, 2015/02/16 13:12:04]

Hmm.. I find this odd. Below, all usages of resource have been replaced with
cacheHandler. Which makes perfect sense, since the point cacheHandler is to be
the abstraction for the cache. But then why are we checking for the resource
here? In fact, why is Resource* even still a parameter?


Maybe one point of confusion and/or fixing this is the ...protocolIsInHTTPFamily
check: I originally added this check because the main cache implementation will
CHECK for the protocol. The intention is that e.g. scripts from extensions
shouldn't end up in the disk cache, since they're stored locally anyhow. So
without this check, the renderer terminates with a CHECK. IMHO, the best way out
of that problem is to make the Resource never return a CachedMetadataHandler if
it can't actually cache that type of resource.

In other words: If the Resource - or whatever- gives you a MetadataCacheHandler,
it should no longer be necessary to even make this check.

[horo, 2015/02/16 16:20:11]

I agree.
I changed Resource.cacheHandler() to return null when the resource isn't
cacheable.

         // Caching is not available in this case.
         return bind(compileWithoutOptions, V8CompileHistogram::Noncacheable);
 

[kinuko, 2015/02/16 14:18:38]

It looks it's possible to reach here when cacheHandler is null, but we don't
check if cacheHandler != nullptr in compileAndConsumeOrProduce.  Is it ok?

(Probably it's not necessary in the current possible code paths, but it's not
very obvious from the code)

[horo, 2015/02/16 16:20:11]

Done.

     if (cacheOptions == V8CacheOptionsNone)
         return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
 
     // The cacheOptions will guide our strategy:
     // FIXME: Clean up code caching options. crbug.com/455187.
     switch (cacheOptions) {
     case V8CacheOptionsDefault:
     case V8CacheOptionsParseMemory:
         if (code->Length() < minimalCodeLength) {
             // Do not cache for small scripts, though caching is available.
             return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
         }
         // Use parser-cache; in-memory only.
-        return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagParser, resource), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, false, Resource::CacheLocally);
+        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, resource, cacheTag(CacheTagParser, resource), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, false, Resource::SendToPlatform);
+        return bind(compileAndConsumeOrProduce, cacheHandler, cacheTag(CacheTagParser, cacheHandler), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, false, CachedMetadataHandler::SendToPlatform);
         break;
 
     case V8CacheOptionsHeuristicsDefault:
     case V8CacheOptionsCode:
         // Always use code caching.
-        return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagCode, resource), v8::ScriptCompiler::kConsumeCodeCache, v8::ScriptCompiler::kProduceCodeCache, false, Resource::SendToPlatform);
+        return bind(compileAndConsumeOrProduce, cacheHandler, cacheTag(CacheTagCode, cacheHandler), v8::ScriptCompiler::kConsumeCodeCache, v8::ScriptCompiler::kProduceCodeCache, false, CachedMetadataHandler::SendToPlatform);
         break;
 
     case V8CacheOptionsHeuristicsDefaultMobile:
     case V8CacheOptionsCodeCompressed:
         // Always use code caching. Compress depending on cacheOptions.
-        return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagCodeCompressed, resource), v8::ScriptCompiler::kConsumeCodeCache, v8::ScriptCompiler::kProduceCodeCache, true, Resource::SendToPlatform);
+        return bind(compileAndConsumeOrProduce, cacheHandler, cacheTag(CacheTagCodeCompressed, cacheHandler), v8::ScriptCompiler::kConsumeCodeCache, v8::ScriptCompiler::kProduceCodeCache, true, CachedMetadataHandler::SendToPlatform);
         break;
 
     case V8CacheOptionsHeuristics:
     case V8CacheOptionsHeuristicsMobile:
     case V8CacheOptionsRecent:
     case V8CacheOptionsRecentSmall: {
         bool compress = (cacheOptions == V8CacheOptionsRecentSmall || cacheOptions == V8CacheOptionsHeuristicsMobile);
-        unsigned codeCacheTag = cacheTag(compress ? CacheTagCodeCompressed : CacheTagCode, resource);
-        CachedMetadata* codeCache = resource->cachedMetadata(codeCacheTag);
+        unsigned codeCacheTag = cacheTag(compress ? CacheTagCodeCompressed : CacheTagCode, cacheHandler);
+        CachedMetadata* codeCache = cacheHandler->cachedMetadata(codeCacheTag);
         if (codeCache)
-            return bind(compileAndConsumeCache, resource, codeCacheTag, v8::ScriptCompiler::kConsumeCodeCache, compress);
+            return bind(compileAndConsumeCache, cacheHandler, codeCacheTag, v8::ScriptCompiler::kConsumeCodeCache, compress);
         int hotHours = (cacheOptions == V8CacheOptionsRecent || cacheOptions == V8CacheOptionsRecentSmall) ? 36 : 72;
-        if (!isResourceHotForCaching(resource, hotHours)) {
-            setCacheTimeStamp(resource);
+        if (!isResourceHotForCaching(cacheHandler, hotHours)) {
+            setCacheTimeStamp(cacheHandler);
             return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
         }
-        return bind(compileAndProduceCache, resource, codeCacheTag, v8::ScriptCompiler::kProduceCodeCache, compress, Resource::SendToPlatform);
+        return bind(compileAndProduceCache, cacheHandler, codeCacheTag, v8::ScriptCompiler::kProduceCodeCache, compress, 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(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::Handle<v8::String>, v8::ScriptOrigin>(postStreamCompile, resource, streamer);
+    return WTF::bind<v8::Isolate*, v8::Handle<v8::String>, v8::ScriptOrigin>(postStreamCompile, resource->cacheHandler(), streamer);
 }
 } // namespace
 
 v8::Local<v8::Script> V8ScriptRunner::compileScript(const ScriptSourceCode& source, v8::Isolate* isolate, AccessControlStatus corsStatus, V8CacheOptions cacheOptions)
 {
-    return compileScript(v8String(isolate, source.source()), source.url(), source.startPosition(), source.resource(), source.streamer(), isolate, corsStatus, cacheOptions);
+    return compileScript(v8String(isolate, source.source()), source.url(), source.startPosition(), isolate, source.resource(), source.streamer(), nullptr, corsStatus, cacheOptions);
 }
 
-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, bool isInternalScript)
+v8::Local<v8::Script> V8ScriptRunner::compileScript(v8::Handle<v8::String> code, const String& fileName, const TextPosition& scriptStartPosition, v8::Isolate* isolate, ScriptResource* resource, ScriptStreamer* streamer, CachedMetadataHandler* cacheHandler, AccessControlStatus corsStatus, V8CacheOptions cacheOptions, bool isInternalScript)
 {
     TRACE_EVENT1("v8", "v8.compile", "fileName", fileName.utf8());
     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Compile");
 
+    if (!cacheHandler && resource)
+        cacheHandler = resource->cacheHandler();
+
     // NOTE: For compatibility with WebCore, ScriptSourceCode's line starts at
     // 1, whereas v8 starts at 0.
     v8::ScriptOrigin origin(
         v8String(isolate, fileName),
         v8::Integer::New(isolate, scriptStartPosition.m_line.zeroBasedInt()),
         v8::Integer::New(isolate, scriptStartPosition.m_column.zeroBasedInt()),
         v8Boolean(corsStatus == SharableCrossOrigin, isolate),
         v8::Handle<v8::Integer>(),
         v8Boolean(isInternalScript, isolate));
 
     OwnPtr<CompileFn> compileFn = streamer
         ? selectCompileFunction(resource, streamer)
-        : selectCompileFunction(cacheOptions, resource, code);
+        : selectCompileFunction(cacheOptions, resource, cacheHandler, code);
 
     return (*compileFn)(isolate, code, origin);
 }
 
 v8::Local<v8::Value> V8ScriptRunner::runCompiledScript(v8::Isolate* isolate, v8::Handle<v8::Script> script, ExecutionContext* context)
 {
     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 14 matching lines @@
 
     if (result.IsEmpty())
         return v8::Local<v8::Value>();
 
     crashIfV8IsDead();
     return result;
 }
 
 v8::Local<v8::Value> V8ScriptRunner::compileAndRunInternalScript(v8::Handle<v8::String> source, v8::Isolate* isolate, const String& fileName, const TextPosition& scriptStartPosition)
 {
-    v8::Handle<v8::Script> script = V8ScriptRunner::compileScript(source, fileName, scriptStartPosition, 0, 0, isolate, SharableCrossOrigin, V8CacheOptionsDefault, true);
+    v8::Handle<v8::Script> script = V8ScriptRunner::compileScript(source, fileName, scriptStartPosition, isolate, nullptr, nullptr, nullptr, SharableCrossOrigin, V8CacheOptionsDefault, true);
     if (script.IsEmpty())
         return v8::Local<v8::Value>();
 
     TRACE_EVENT0("v8", "v8.run");
     TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Execution");
     V8RecursionScope::MicrotaskSuppression recursionScope(isolate);
     v8::Local<v8::Value> result = script->Run();
     crashIfV8IsDead();
     return result;
 }
@@ skipping 76 matching lines @@
     if (ScriptForbiddenScope::isScriptForbidden())
         return v8::Local<v8::Object>();
     V8RecursionScope scope(isolate);
     v8::Local<v8::Object> result = function->NewInstance(argc, argv);
     crashIfV8IsDead();
     return result;
 }
 
 unsigned V8ScriptRunner::tagForParserCache(Resource* resource)
 {
-    return cacheTag(CacheTagParser, resource);
+    return cacheTag(CacheTagParser, resource->cacheHandler());
 }
 
 unsigned V8ScriptRunner::tagForCodeCache(Resource* resource)
 {
-    return cacheTag(CacheTagCode, resource);
+    return cacheTag(CacheTagCode, resource->cacheHandler());
 }
 
 } // namespace blink