diff options
Diffstat (limited to 'dom/asmjscache/AsmJSCache.h')
| -rw-r--r-- | dom/asmjscache/AsmJSCache.h | 194 |
1 files changed, 194 insertions, 0 deletions
diff --git a/dom/asmjscache/AsmJSCache.h b/dom/asmjscache/AsmJSCache.h new file mode 100644 index 000000000..92bb7780a --- /dev/null +++ b/dom/asmjscache/AsmJSCache.h @@ -0,0 +1,194 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_asmjscache_asmjscache_h +#define mozilla_dom_asmjscache_asmjscache_h + +#include "ipc/IPCMessageUtils.h" +#include "js/TypeDecls.h" +#include "js/Vector.h" +#include "jsapi.h" + +class nsIPrincipal; + +namespace mozilla { + +namespace ipc { + +class PrincipalInfo; + +} // namespace ipc + +namespace dom { + +namespace quota { +class Client; +} // namespace quota + +namespace asmjscache { + +class PAsmJSCacheEntryChild; +class PAsmJSCacheEntryParent; + +enum OpenMode +{ + eOpenForRead, + eOpenForWrite, + NUM_OPEN_MODES +}; + +// Each origin stores a fixed size (kNumEntries) LRU cache of compiled asm.js +// modules. Each compiled asm.js module is stored in a separate file with one +// extra metadata file that stores the LRU cache and enough information for a +// client to pick which cached module's file to open. +struct Metadata +{ + static const unsigned kNumEntries = 16; + static const unsigned kLastEntry = kNumEntries - 1; + + struct Entry + { + uint32_t mFastHash; + uint32_t mNumChars; + uint32_t mFullHash; + unsigned mModuleIndex; + + void clear() { + mFastHash = -1; + mNumChars = -1; + mFullHash = -1; + } + }; + + Entry mEntries[kNumEntries]; +}; + +// Parameters specific to opening a cache entry for writing +struct WriteParams +{ + int64_t mSize; + int64_t mFastHash; + int64_t mNumChars; + int64_t mFullHash; + bool mInstalled; + + WriteParams() + : mSize(0), + mFastHash(0), + mNumChars(0), + mFullHash(0), + mInstalled(false) + { } +}; + +// Parameters specific to opening a cache entry for reading +struct ReadParams +{ + const char16_t* mBegin; + const char16_t* mLimit; + + ReadParams() + : mBegin(nullptr), + mLimit(nullptr) + { } +}; + +// Implementation of AsmJSCacheOps, installed for the main JSRuntime by +// nsJSEnvironment.cpp and DOM Worker JSRuntimes in RuntimeService.cpp. +// +// The Open* functions cannot be called directly from AsmJSCacheOps: they take +// an nsIPrincipal as the first argument instead of a Handle<JSObject*>. The +// caller must map the object to an nsIPrincipal. +// +// These methods may be called off the main thread and guarantee not to +// access the given aPrincipal except on the main thread. In exchange, the +// caller must ensure the given principal is alive from when OpenEntryForX is +// called to when CloseEntryForX returns. + +bool +OpenEntryForRead(nsIPrincipal* aPrincipal, + const char16_t* aBegin, + const char16_t* aLimit, + size_t* aSize, + const uint8_t** aMemory, + intptr_t *aHandle); +void +CloseEntryForRead(size_t aSize, + const uint8_t* aMemory, + intptr_t aHandle); +JS::AsmJSCacheResult +OpenEntryForWrite(nsIPrincipal* aPrincipal, + bool aInstalled, + const char16_t* aBegin, + const char16_t* aEnd, + size_t aSize, + uint8_t** aMemory, + intptr_t* aHandle); +void +CloseEntryForWrite(size_t aSize, + uint8_t* aMemory, + intptr_t aHandle); + +// Called from QuotaManager.cpp: + +quota::Client* +CreateClient(); + +// Called from ipc/ContentParent.cpp: + +PAsmJSCacheEntryParent* +AllocEntryParent(OpenMode aOpenMode, WriteParams aWriteParams, + const mozilla::ipc::PrincipalInfo& aPrincipalInfo); + +void +DeallocEntryParent(PAsmJSCacheEntryParent* aActor); + +// Called from ipc/ContentChild.cpp: + +void +DeallocEntryChild(PAsmJSCacheEntryChild* aActor); + +} // namespace asmjscache +} // namespace dom +} // namespace mozilla + +namespace IPC { + +template <> +struct ParamTraits<mozilla::dom::asmjscache::OpenMode> : + public ContiguousEnumSerializer<mozilla::dom::asmjscache::OpenMode, + mozilla::dom::asmjscache::eOpenForRead, + mozilla::dom::asmjscache::NUM_OPEN_MODES> +{ }; + +template <> +struct ParamTraits<mozilla::dom::asmjscache::Metadata> +{ + typedef mozilla::dom::asmjscache::Metadata paramType; + static void Write(Message* aMsg, const paramType& aParam); + static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult); + static void Log(const paramType& aParam, std::wstring* aLog); +}; + +template <> +struct ParamTraits<mozilla::dom::asmjscache::WriteParams> +{ + typedef mozilla::dom::asmjscache::WriteParams paramType; + static void Write(Message* aMsg, const paramType& aParam); + static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult); + static void Log(const paramType& aParam, std::wstring* aLog); +}; + +template <> +struct ParamTraits<JS::AsmJSCacheResult> : + public ContiguousEnumSerializer<JS::AsmJSCacheResult, + JS::AsmJSCache_MIN, + JS::AsmJSCache_LIMIT> +{ }; + +} // namespace IPC + +#endif // mozilla_dom_asmjscache_asmjscache_h |