File: AsmJSCache.h

package info (click to toggle)
thunderbird 1:60.8.0-1~deb9u1
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 2,339,208 kB
  • sloc: cpp: 5,456,704; ansic: 2,360,384; python: 596,095; asm: 340,963; java: 326,291; xml: 258,664; sh: 84,366; makefile: 23,702; perl: 17,317; objc: 3,768; yacc: 1,766; ada: 1,681; lex: 1,364; pascal: 1,264; cs: 879; exp: 527; php: 436; lisp: 258; ruby: 153; awk: 152; sed: 53; csh: 27
file content (156 lines) | stat: -rw-r--r-- 4,921 bytes parent folder | download | duplicates (7)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
/* -*- 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;

  WriteParams() : mSize(0), mFastHash(0), mNumChars(0), mFullHash(0) {}
};

// 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,
                                       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