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
|
/* -*- 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 IntegrityPolicy_h___
#define IntegrityPolicy_h___
#include "mozilla/EnumSet.h"
#include "mozilla/EnumTypeTraits.h"
#include "mozilla/Maybe.h"
#include "nsIContentPolicy.h"
#include "nsIIntegrityPolicy.h"
#include "nsTArray.h"
#define NS_INTEGRITYPOLICY_CONTRACTID "@mozilla.org/integritypolicy;1"
class nsISFVDictionary;
class nsILoadInfo;
namespace mozilla {
namespace ipc {
class IntegrityPolicyArgs;
} // namespace ipc
namespace dom {
class IntegrityPolicy : public nsIIntegrityPolicy {
public:
NS_DECL_ISUPPORTS
NS_DECL_NSISERIALIZABLE
NS_DECL_NSIINTEGRITYPOLICY
IntegrityPolicy() = default;
static nsresult ParseHeaders(const nsACString& aHeader,
const nsACString& aHeaderRO,
IntegrityPolicy** aPolicy);
enum class SourceType : uint8_t { Inline };
// Trimmed down version of dom::RequestDestination
enum class DestinationType : uint8_t { Script, Style };
using Sources = EnumSet<SourceType>;
using Destinations = EnumSet<DestinationType>;
void PolicyContains(DestinationType aDestination, bool* aContains,
bool* aROContains) const;
static Maybe<DestinationType> ContentTypeToDestinationType(
nsContentPolicyType aType);
static void ToArgs(const IntegrityPolicy* aPolicy,
mozilla::ipc::IntegrityPolicyArgs& aArgs);
static void FromArgs(const mozilla::ipc::IntegrityPolicyArgs& aArgs,
IntegrityPolicy** aPolicy);
void InitFromOther(IntegrityPolicy* aOther);
static IntegrityPolicy* Cast(nsIIntegrityPolicy* aPolicy) {
return static_cast<IntegrityPolicy*>(aPolicy);
}
static bool Equals(const IntegrityPolicy* aPolicy,
const IntegrityPolicy* aOtherPolicy);
protected:
virtual ~IntegrityPolicy();
private:
class Entry final {
public:
Entry(Sources aSources, Destinations aDestinations,
nsTArray<nsCString>&& aEndpoints)
: mSources(aSources),
mDestinations(aDestinations),
mEndpoints(std::move(aEndpoints)) {}
Entry(const Entry& aOther)
: mSources(aOther.mSources),
mDestinations(aOther.mDestinations),
mEndpoints(aOther.mEndpoints.Clone()) {}
~Entry() = default;
static bool Equals(const Maybe<Entry>& aPolicy,
const Maybe<Entry>& aOtherPolicy);
const Sources mSources;
const Destinations mDestinations;
const nsTArray<nsCString> mEndpoints;
};
Maybe<Entry> mEnforcement;
Maybe<Entry> mReportOnly;
};
} // namespace dom
template <>
struct MaxEnumValue<dom::IntegrityPolicy::SourceType> {
static constexpr unsigned int value =
static_cast<unsigned int>(dom::IntegrityPolicy::SourceType::Inline);
};
template <>
struct MaxEnumValue<dom::IntegrityPolicy::DestinationType> {
static constexpr unsigned int value =
static_cast<unsigned int>(dom::IntegrityPolicy::DestinationType::Script);
};
} // namespace mozilla
#endif /* IntegrityPolicy_h___ */
|
