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
|
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_BINDINGS_CALLBACK_INTERFACE_BASE_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_BINDINGS_CALLBACK_INTERFACE_BASE_H_
#include "third_party/blink/renderer/platform/bindings/name_client.h"
#include "third_party/blink/renderer/platform/bindings/script_state.h"
#include "third_party/blink/renderer/platform/bindings/trace_wrapper_v8_reference.h"
#include "third_party/blink/renderer/platform/heap/handle.h"
namespace blink {
// CallbackInterfaceBase is the common base class of all the callback interface
// classes. Most importantly this class provides a way of type dispatching (e.g.
// overload resolutions, SFINAE technique, etc.) so that it's possible to
// distinguish callback interfaces from anything else. Also it provides a common
// implementation of callback interfaces.
//
// As the signatures of callback interface's operations vary, this class does
// not implement any operation. Subclasses will implement it.
class PLATFORM_EXPORT CallbackInterfaceBase
: public GarbageCollected<CallbackInterfaceBase>,
public NameClient {
public:
// Whether the callback interface is a "single operation callback interface"
// or not.
// https://heycam.github.io/webidl/#dfn-single-operation-callback-interface
enum SingleOperationOrNot {
kNotSingleOperation,
kSingleOperation,
};
virtual ~CallbackInterfaceBase() = default;
virtual void Trace(Visitor*) const;
// Check the identity of |callback_object_|. There can be multiple
// CallbackInterfaceBase objects that have the same |callback_object_| but
// have different |incumbent_script_state_|s.
bool HasTheSameCallbackObject(const CallbackInterfaceBase& other) const {
return callback_object_ == other.callback_object_;
}
v8::Local<v8::Object> CallbackObject() {
return callback_object_.NewLocal(GetIsolate());
}
v8::Isolate* GetIsolate() { return incumbent_script_state_->GetIsolate(); }
// Returns the ScriptState of the relevant realm of the callback object.
//
// NOTE: This function must be used only when it's pretty sure that the
// callcack object is the same origin-domain. Otherwise,
// |CallbackRelevantScriptStateOrReportError| or
// |CallbackRelevantScriptStateOrThrowException| must be used instead.
ScriptState* CallbackRelevantScriptState() {
DCHECK(callback_relevant_script_state_);
return callback_relevant_script_state_;
}
// Returns the ScriptState of the relevant realm of the callback object iff
// the callback is the same origin-domain. Otherwise, reports an error and
// returns nullptr.
ScriptState* CallbackRelevantScriptStateOrReportError(
const char* interface_name,
const char* operation_name);
// Returns the ScriptState of the relevant realm of the callback object iff
// the callback is the same origin-domain. Otherwise, throws an exception and
// returns nullptr.
ScriptState* CallbackRelevantScriptStateOrThrowException(
const char* interface_name,
const char* operation_name);
DOMWrapperWorld& GetWorld() const { return incumbent_script_state_->World(); }
// NodeIteratorBase counts the invocation of those which are callable and
// those which are not.
bool IsCallbackObjectCallableForNodeIteratorBase() const {
return IsCallbackObjectCallable();
}
protected:
explicit CallbackInterfaceBase(v8::Local<v8::Object> callback_object,
SingleOperationOrNot);
// Returns true iff the callback interface is a single operation callback
// interface and the callback interface type value is callable.
bool IsCallbackObjectCallable() const { return is_callback_object_callable_; }
ScriptState* IncumbentScriptState() { return incumbent_script_state_; }
private:
// The "callback interface type" value.
TraceWrapperV8Reference<v8::Object> callback_object_;
bool is_callback_object_callable_ = false;
// The associated Realm of the callback interface type value. Note that the
// callback interface type value can be different from the function object
// to be invoked.
Member<ScriptState> callback_relevant_script_state_;
// The callback context, i.e. the incumbent Realm when an ECMAScript value is
// converted to an IDL value.
// https://heycam.github.io/webidl/#dfn-callback-context
Member<ScriptState> incumbent_script_state_;
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_PLATFORM_BINDINGS_CALLBACK_INTERFACE_BASE_H_
|
