CachedMetadata support for ServiceWorker script.

Source/core/workers/WorkerThread.cpp

 /*
  * Copyright (C) 2008 Apple 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 13 matching lines @@
  *
  */
 
 #include "config.h"
 
 #include "core/workers/WorkerThread.h"
 
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8Initializer.h"
 #include "core/dom/Microtask.h"
+#include "core/fetch/CachedMetadata.h"
+#include "core/fetch/CachedMetadataHandler.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/WorkerInspectorController.h"
 #include "core/workers/DedicatedWorkerGlobalScope.h"
 #include "core/workers/WorkerClients.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "platform/PlatformThreadData.h"
 #include "platform/Task.h"
 #include "platform/ThreadTimers.h"
 #include "platform/heap/ThreadState.h"
@@ skipping 30 matching lines @@
                 scriptController->rejectedPromises()->processQueue();
         }
     }
 
 private:
     // Thread owns the microtask runner; reference remains
     // valid for the lifetime of this object.
     WorkerThread* m_workerThread;
 };
 
+class WorkerScriptCachedMetadataHandler : public CachedMetadataHandler {

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

This class can be probably in its own file, as it's not really related to
WorkerThread.

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

Done.

+public:
+    WorkerScriptCachedMetadataHandler(WorkerGlobalScope* workerGlobalScope, const KURL& scriptURL, const Vector<char>* metaData)
+        : m_workerGlobalScope(workerGlobalScope)
+        , m_scriptURL(scriptURL)
+    {
+        if (metaData)
+            m_cachedMetadata = CachedMetadata::deserialize(metaData->data(), metaData->size());
+    }
+    ~WorkerScriptCachedMetadataHandler() override { }
+    void setCachedMetadata(unsigned dataTypeID, const char* data, size_t size, CacheType type) override
+    {
+        if (type != SendToPlatform)
+            return;
+        m_cachedMetadata = CachedMetadata::create(dataTypeID, data, size);
+        const Vector<char>& serializedData = m_cachedMetadata->serialize();
+        m_workerGlobalScope->setCachedMetadata(m_scriptURL, serializedData.data(), serializedData.size());
+    }
+    void clearCachedMetadata(CacheType type) override
+    {
+        if (type != SendToPlatform)
+            return;
+        m_cachedMetadata = nullptr;
+        m_workerGlobalScope->clearCachedMetadata(m_scriptURL);
+    }
+    CachedMetadata* cachedMetadata(unsigned dataTypeID) const override
+    {
+        if (!m_cachedMetadata || m_cachedMetadata->dataTypeID() != dataTypeID)
+            return nullptr;
+        return m_cachedMetadata.get();
+    }
+    String encoding() const override { return ""; }
+
+private:
+    WorkerGlobalScope* m_workerGlobalScope;
+    KURL m_scriptURL;
+    RefPtr<CachedMetadata> m_cachedMetadata;
+};
+
 } // namespace
 
 static Mutex& threadSetMutex()
 {
     AtomicallyInitializedStaticReference(Mutex, mutex, new Mutex);
     return mutex;
 }
 
 static HashSet<WorkerThread*>& workerThreads()
 {
@@ skipping 210 matching lines @@
     if (!m_thread)
         return 0;
     return m_thread->platformThread().threadId();
 }
 
 void WorkerThread::initialize()
 {
     KURL scriptURL = m_startupData->m_scriptURL;
     String sourceCode = m_startupData->m_sourceCode;
     WorkerThreadStartMode startMode = m_startupData->m_startMode;
+    OwnPtr<Vector<char>> cachedMetaData = m_startupData->m_cachedMetaData.release();
+    V8CacheOptions v8CacheOptions = m_startupData->m_v8CacheOptions;
 
     {
         MutexLocker lock(m_threadCreationMutex);
 
         // The worker was terminated before the thread had a chance to run.
         if (m_terminated) {
             // Notify the proxy that the WorkerGlobalScope has been disposed of.
             // This can free this thread object, hence it must not be touched afterwards.
             m_workerReportingProxy.workerThreadTerminated();
             return;
@@ skipping 11 matching lines @@
     // The corresponding call to stopRunLoop() is in ~WorkerScriptController().
     didStartRunLoop();
 
     // Notify proxy that a new WorkerGlobalScope has been created and started.
     m_workerReportingProxy.workerGlobalScopeStarted(m_workerGlobalScope.get());
 
     WorkerScriptController* script = m_workerGlobalScope->script();
     if (!script->isExecutionForbidden())
         script->initializeContextIfNeeded();
     InspectorInstrumentation::willEvaluateWorkerScript(workerGlobalScope(), startMode);
-    bool success = script->evaluate(ScriptSourceCode(sourceCode, scriptURL));
+    WorkerScriptCachedMetadataHandler handler(workerGlobalScope(), scriptURL, cachedMetaData.get());
+    bool success = script->evaluate(ScriptSourceCode(sourceCode, scriptURL), nullptr, &handler, v8CacheOptions);
     m_workerGlobalScope->didEvaluateWorkerScript();
     m_workerReportingProxy.didEvaluateWorkerScript(success);
 
     postInitialize();
 
     postDelayedTask(createSameThreadTask(&WorkerThread::idleHandler, this), kShortIdleHandlerDelayMs);
 }
 
 void WorkerThread::cleanup()
 {
@@ skipping 210 matching lines @@
     InspectorInstrumentation::didLeaveNestedRunLoop(m_workerGlobalScope.get());
 }
 
 void WorkerThread::setWorkerInspectorController(WorkerInspectorController* workerInspectorController)
 {
     MutexLocker locker(m_workerInspectorControllerMutex);
     m_workerInspectorController = workerInspectorController;
 }
 
 } // namespace blink