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) const |
| 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)) |
| 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) const |
| 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 explicit Symbol(v8::Local<v8::Private> privateSymbol) |
| 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 |