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
|
/* -*- 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_IPC_JSACTOR_JSIPCVALUEUTILS_H_
#define MOZILLA_DOM_IPC_JSACTOR_JSIPCVALUEUTILS_H_
#include "js/RootingAPI.h"
#include "js/Value.h"
#include "jstypes.h"
#include "mozilla/Maybe.h"
#include "mozilla/dom/JSActor.h"
#include "mozilla/dom/JSIPCValue.h"
// This file contains a number of useful methods for JSIPCValue, mostly dealing
// with turning it to and from a JS value.
namespace mozilla::dom {
// Return true if a message for an actor with the given name should be
// sent typed.
bool JSActorSupportsTypedSend(const nsACString& aName);
class JSIPCValueUtils {
public:
struct Context {
explicit Context(JSContext* aCx, bool aStrict = true)
: mCx(aCx), mStrict(aStrict) {}
MOZ_IMPLICIT operator JSContext*() const { return mCx; }
JSContext* mCx;
// If we encounter a JS value that can't be directly serialized to
// JSIPCValue, we fall back to using structured cloning. mStrict
// determines the behavior if this structured cloning fails. If mStrict is
// true, then the entire serialization will fail. If it is false, we'll
// instead serialize to a fallback value. See UntypedFromJSVal for details.
bool mStrict;
};
// Convert a JS value to an IPDL representation of that value, or return
// Nothing if the value isn't supported. If aSendTyped is false, the result
// will always just be a wrapper around a StructuredCloneData.
static JSIPCValue FromJSVal(Context& aCx, JS::Handle<JS::Value> aVal,
bool aSendTyped, ErrorResult& aError);
// Same as the above, except with support for a transfers object, if needed.
static JSIPCValue FromJSVal(Context& aCx, JS::Handle<JS::Value> aVal,
JS::Handle<JS::Value> aTransferable,
bool aSendTyped, ErrorResult& aError);
// This is equivalent to calling FromJSVal with aSendTyped equal to true.
static JSIPCValue TypedFromJSVal(Context& aCx, JS::Handle<JS::Value> aVal,
ErrorResult& aError);
// Wrapper class to abstract away the details of the auxiliary data structure
// needed for PrepareForSending.
class SCDHolder final {
public:
SCDHolder() = default;
~SCDHolder() = default;
friend class JSIPCValueUtils;
private:
nsTArray<UniquePtr<ipc::StructuredCloneData>> mSCDs;
};
// Prepare a JSIPCValue for IPC by turning any StructuredCloneData it
// contains into ClonedMessageData. Auxiliary data needed for IPC
// serialization will be added to aHolder, so it needs to be kept alive
// until aValue is sent over IPC.
[[nodiscard]] static bool PrepareForSending(SCDHolder& aHolder,
JSIPCValue& aValue);
// Convert the IPDL representation of a JS value back into the equivalent
// JS value. This will return false on failure.
static void ToJSVal(JSContext* aCx, JSIPCValue&& aIn,
JS::MutableHandle<JS::Value> aOut, ErrorResult& aError);
};
} // namespace mozilla::dom
#endif // MOZILLA_DOM_IPC_JSACTOR_JSIPCVALUEUTILS_H_
|
