OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #ifndef V8PrivateProperty_h | |
6 #define V8PrivateProperty_h | |
7 | |
8 #include "bindings/core/v8/ScopedPersistent.h" | |
9 #include "bindings/core/v8/ScriptPromiseProperties.h" | |
10 #include "bindings/core/v8/V8BindingMacros.h" | |
11 #include "bindings/core/v8/V8PerIsolateData.h" | |
12 #include "core/CoreExport.h" | |
13 #include "wtf/Allocator.h" | |
14 #include "wtf/PtrUtil.h" | |
15 #include <memory> | |
16 #include <v8.h> | |
17 | |
18 namespace blink { | |
19 | |
20 class ScriptState; | |
21 class ScriptWrappable; | |
22 | |
23 // Apply |X| for each pair of (InterfaceName, PrivateKeyName). | |
24 #define V8_PRIVATE_PROPERTY_FOR_EACH(X) \ | |
25 X(MessageEvent, CachedData) | |
26 | |
27 // The getter's name for a private property. | |
28 #define V8_PRIVATE_PROPERTY_GETTER_NAME(InterfaceName, PrivateKeyName) \ | |
29 get##InterfaceName##PrivateKeyName | |
30 | |
31 // The member variable's name for a private property. | |
32 #define V8_PRIVATE_PROPERTY_MEMBER_NAME(InterfaceName, PrivateKeyName) \ | |
33 m_symbol##InterfaceName##PrivateKeyName | |
34 | |
35 // The string used to create a private symbol. Must be unique per V8 instance. | |
36 #define V8_PRIVATE_PROPERTY_SYMBOL_STRING(InterfaceName, PrivateKeyName) \ | |
37 #InterfaceName"#"#PrivateKeyName // NOLINT(whitespace/indent) | |
38 | |
39 // Provides access to V8's private properties. | |
40 // | |
41 // Usage 1) Fast path to use a pre-registered symbol. | |
42 // auto private = V8PrivateProperty::getMessageEventCachedData(isolate); | |
43 // v8::Local<v8::Context> context = ...; | |
44 // v8::Local<v8::Object> object = ...; | |
45 // v8::Local<v8::Value> value = private.get(context, object); | |
46 // value = ...; | |
47 // private.set(context, object, value); | |
48 // | |
49 // Usage 2) Slow path to create a global private symbol. | |
50 // const char symbolName[] = "Interface#PrivateKeyName"; | |
51 // auto private = V8PrivateProperty::createSymbol(isolate, symbolName, sizeof symbolName); | |
52 // ... | |
53 class CORE_EXPORT V8PrivateProperty { | |
54 USING_FAST_MALLOC(V8PrivateProperty); | |
55 WTF_MAKE_NONCOPYABLE(V8PrivateProperty); | |
56 public: | |
57 // Provides fast access to V8's private properties. | |
58 // | |
59 // Retrieving/creating a global private symbol from a string is very | |
60 // expensive compared to get or set a private property. This class | |
61 // provides a way to cache a private symbol and re-use it. | |
62 class CORE_EXPORT Symbol { | |
63 STACK_ALLOCATED(); | |
64 public: | |
65 v8::Local<v8::Value> get(v8::Local<v8::Context> context, v8::Local<v8::O bject> object) | |
66 { | |
67 if (!v8CallBoolean(object->HasPrivate(context, m_privateSymbol))) | |
68 return v8::Local<v8::Value>(); | |
69 v8::Local<v8::Value> value; | |
70 if (v8Call(object->GetPrivate(context, m_privateSymbol), value)) | |
haraken
2016/05/27 18:15:20
You were saying that you won't need to call HasPri
Yuki
2016/05/30 06:44:28
I thought we don't need a call to HasPrivate, but
| |
71 return value; | |
72 return v8::Local<v8::Value>(); | |
73 } | |
74 | |
75 bool set(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v 8::Local<v8::Value> value) | |
76 { | |
77 return v8CallBoolean(object->SetPrivate(context, m_privateSymbol, va lue)); | |
78 } | |
79 | |
80 private: | |
81 friend class V8PrivateProperty; | |
82 // V8ServiceWorkerMessageEventInternal is exceptionally allowed to call | |
83 // to getFromMainWorld. | |
84 friend class V8ServiceWorkerMessageEventInternal; | |
85 | |
86 Symbol(v8::Local<v8::Private> privateSymbol) | |
haraken
2016/05/27 18:15:20
Add explicit.
Yuki
2016/05/30 06:44:28
Done.
| |
87 : m_privateSymbol(privateSymbol) { } | |
88 | |
89 // Only V8ServiceWorkerMessageEventInternal is allowed to use this API. | |
90 v8::Local<v8::Value> getFromMainWorld(ScriptState*, ScriptWrappable*); | |
91 | |
92 v8::Local<v8::Private> m_privateSymbol; | |
93 }; | |
94 | |
95 static std::unique_ptr<V8PrivateProperty> create() | |
96 { | |
97 return wrapUnique(new V8PrivateProperty()); | |
98 } | |
99 | |
100 #define V8_PRIVATE_PROPERTY_DEFINE_GETTER(InterfaceName, KeyName) \ | |
101 static Symbol V8_PRIVATE_PROPERTY_GETTER_NAME(InterfaceName, KeyName)(v8::Is olate* isolate) /* NOLINT(readability/naming/underscores) */ \ | |
102 { \ | |
103 V8PrivateProperty* privateProp = V8PerIsolateData::from(isolate)->privat eProperty(); \ | |
104 if (UNLIKELY(privateProp->V8_PRIVATE_PROPERTY_MEMBER_NAME(InterfaceName, KeyName).isEmpty())) { \ | |
105 privateProp->V8_PRIVATE_PROPERTY_MEMBER_NAME(InterfaceName, KeyName) .set( \ | |
106 isolate, \ | |
107 createV8Private( \ | |
108 isolate, \ | |
109 V8_PRIVATE_PROPERTY_SYMBOL_STRING(InterfaceName, KeyName), \ | |
110 sizeof V8_PRIVATE_PROPERTY_SYMBOL_STRING(InterfaceName, KeyN ame))); /* NOLINT(readability/naming/underscores) */ \ | |
111 } \ | |
112 return Symbol(privateProp->V8_PRIVATE_PROPERTY_MEMBER_NAME(InterfaceName , KeyName).newLocal(isolate)); \ | |
113 } | |
114 V8_PRIVATE_PROPERTY_FOR_EACH(V8_PRIVATE_PROPERTY_DEFINE_GETTER) | |
115 #undef V8_PRIVATE_PROPERTY_DEFINE_GETTER | |
116 | |
117 static Symbol createSymbol(v8::Isolate* isolate, const char* symbol, size_t length) | |
118 { | |
119 return Symbol(createV8Private(isolate, symbol, length)); | |
120 } | |
121 | |
122 private: | |
123 V8PrivateProperty() { } | |
124 | |
125 static v8::Local<v8::Private> createV8Private(v8::Isolate*, const char* symb ol, size_t length); | |
126 | |
127 #define V8_PRIVATE_PROPERTY_DECLARE_MEMBER(InterfaceName, KeyName) \ | |
128 ScopedPersistent<v8::Private> V8_PRIVATE_PROPERTY_MEMBER_NAME(InterfaceName, KeyName); // NOLINT(readability/naming/underscores) | |
129 V8_PRIVATE_PROPERTY_FOR_EACH(V8_PRIVATE_PROPERTY_DECLARE_MEMBER) | |
130 #undef V8_PRIVATE_PROPERTY_DECLARE_MEMBER | |
131 }; | |
132 | |
133 } // namespace blink | |
134 | |
135 #endif // V8PrivateProperty_h | |
OLD | NEW |