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
|
/* -*- 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_SharedStyleSheetCache_h__
#define mozilla_SharedStyleSheetCache_h__
// The shared style sheet cache is a cache that allows us to share sheets across
// documents.
//
// It's generally a singleton, but it is different from GlobalStyleSheetCache in
// the sense that:
//
// * It needs to be cycle-collectable, as it can keep alive style sheets from
// various documents.
//
// * It is conceptually a singleton, but given its cycle-collectable nature, we
// might re-create it.
#include "mozilla/MemoryReporting.h"
#include "mozilla/SharedSubResourceCache.h"
#include "mozilla/css/Loader.h"
namespace mozilla {
class StyleSheet;
class SheetLoadDataHashKey;
namespace css {
class SheetLoadData;
class Loader;
} // namespace css
struct SharedStyleSheetCacheTraits {
using Loader = css::Loader;
using Key = SheetLoadDataHashKey;
using Value = StyleSheet;
using LoadingValue = css::SheetLoadData;
static SheetLoadDataHashKey KeyFromLoadingValue(const LoadingValue& aValue) {
return SheetLoadDataHashKey(aValue);
}
};
class SharedStyleSheetCache final
: public SharedSubResourceCache<SharedStyleSheetCacheTraits,
SharedStyleSheetCache>,
public nsIMemoryReporter {
public:
using Base = SharedSubResourceCache<SharedStyleSheetCacheTraits,
SharedStyleSheetCache>;
NS_DECL_ISUPPORTS
NS_DECL_NSIMEMORYREPORTER
SharedStyleSheetCache();
void Init();
// This has to be static because it's also called for loaders that don't have
// a sheet cache (loaders that are not owned by a document).
static void LoadCompleted(SharedStyleSheetCache*, css::SheetLoadData&,
nsresult);
using Base::LoadCompleted;
static void LoadCompletedInternal(SharedStyleSheetCache*, css::SheetLoadData&,
nsTArray<RefPtr<css::SheetLoadData>>&);
static void Clear(const Maybe<bool>& aChrome = Nothing(),
const Maybe<nsCOMPtr<nsIPrincipal>>& aPrincipal = Nothing(),
const Maybe<nsCString>& aSchemelessSite = Nothing(),
const Maybe<OriginAttributesPattern>& aPattern = Nothing(),
const Maybe<nsCString>& aURL = Nothing());
void EvictPrincipal(nsIPrincipal* aPrincipal) {
Base::EvictPrincipal(aPrincipal);
mInlineSheets.Remove(aPrincipal);
}
void ClearInProcess(const Maybe<bool>& aChrome,
const Maybe<nsCOMPtr<nsIPrincipal>>& aPrincipal,
const Maybe<nsCString>& aSchemelessSite,
const Maybe<OriginAttributesPattern>& aPattern,
const Maybe<nsCString>& aURL);
size_t SizeOfIncludingThis(MallocSizeOf) const;
auto LookupInline(nsIPrincipal* aPrincipal, const nsAString& aBuffer) {
auto& principalMap = mInlineSheets.LookupOrInsert(aPrincipal);
return principalMap.Lookup(aBuffer);
}
struct InlineSheetEntry {
RefPtr<StyleSheet> mSheet;
bool mWasLoadedAsImage = false;
};
using InlineSheetCandidates = nsTArray<InlineSheetEntry>;
void InsertInline(nsIPrincipal* aPrincipal, const nsAString& aBuffer,
InlineSheetEntry&& aEntry) {
// TODO(emilio): Maybe a better eviction policy for inline sheets, or an
// expiration tracker or so?
auto& principalMap = mInlineSheets.LookupOrInsert(aPrincipal);
principalMap
.LookupOrInsertWith(aBuffer, [] { return InlineSheetCandidates(); })
.AppendElement(std::move(aEntry));
}
protected:
void InsertIfNeeded(css::SheetLoadData&);
nsTHashMap<PrincipalHashKey,
nsTHashMap<nsStringHashKey, InlineSheetCandidates>>
mInlineSheets;
~SharedStyleSheetCache();
};
} // namespace mozilla
#endif
|
