Abstract out ThreadDebugger from V8PerIsolateData

third_party/WebKit/Source/bindings/core/v8/V8PrivateProperty.h

 // Copyright 2016 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 V8PrivateProperty_h
 #define V8PrivateProperty_h
 
+#include <v8.h>
+#include <memory>
 #include "bindings/core/v8/ScopedPersistent.h"
-#include "bindings/core/v8/ScriptPromiseProperties.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
 #include "core/CoreExport.h"
 #include "wtf/Allocator.h"
 #include "wtf/PtrUtil.h"
-#include <memory>
-#include <v8.h>
 
 namespace blink {
 
 class ScriptState;
 class ScriptWrappable;
 
 // Apply |X| for each pair of (InterfaceName, PrivateKeyName).
 #define V8_PRIVATE_PROPERTY_FOR_EACH(X)      \
   X(CustomEvent, Detail)                     \
   X(CustomElement, ConnectedCallback)        \
@@ skipping 33 matching lines @@
 //   v8::Local<v8::Object> object = ...;
 //   v8::Local<v8::Value> value = private.get(context, object);
 //   value = ...;
 //   private.set(context, object, value);
 //
 // Usage 2) Slow path to create a global private symbol.
 //   const char symbolName[] = "Interface#PrivateKeyName";
 //   auto private = V8PrivateProperty::createSymbol(isolate, symbolName,
 //                                                  sizeof symbolName);
 //   ...
-class CORE_EXPORT V8PrivateProperty {
+class CORE_EXPORT V8PrivateProperty : public V8PerIsolateData::Data {
   USING_FAST_MALLOC(V8PrivateProperty);
   WTF_MAKE_NONCOPYABLE(V8PrivateProperty);
 
  public:
   // Provides fast access to V8's private properties.
   //
   // Retrieving/creating a global private symbol from a string is very
   // expensive compared to get or set a private property.  This class
   // provides a way to cache a private symbol and re-use it.
   class CORE_EXPORT Symbol {
@@ skipping 39 matching lines @@
 
     explicit Symbol(v8::Local<v8::Private> privateSymbol)
         : m_privateSymbol(privateSymbol) {}
 
     // Only friend classes are allowed to use this API.
     v8::Local<v8::Value> getFromMainWorld(ScriptState*, ScriptWrappable*);
 
     v8::Local<v8::Private> m_privateSymbol;
   };
 
-  static std::unique_ptr<V8PrivateProperty> create() {
-    return WTF::wrapUnique(new V8PrivateProperty());
+  static void initialize(v8::Isolate* isolate) {
+    V8PerIsolateData::from(isolate)->setPrivateProperty(
+        new V8PrivateProperty());
+  }
+  static V8PrivateProperty* from(v8::Isolate* isolate) {

[Yuki, 2017/02/15 10:00:40]

No need to expose this method as public:.
Should be private:.

+    return static_cast<V8PrivateProperty*>(
+        V8PerIsolateData::from(isolate)->privateProperty());
   }
 
 #define V8_PRIVATE_PROPERTY_DEFINE_GETTER(InterfaceName, KeyName)              \
   static Symbol V8_PRIVATE_PROPERTY_GETTER_NAME(InterfaceName, KeyName)(       \
       v8::Isolate * isolate) /* NOLINT(readability/naming/underscores) */      \
   {                                                                            \
-    V8PrivateProperty* privateProp =                                           \
-        V8PerIsolateData::from(isolate)->privateProperty();                    \
+    V8PrivateProperty* privateProp = from(isolate);                            \
     if (UNLIKELY(privateProp                                                   \
                      ->V8_PRIVATE_PROPERTY_MEMBER_NAME(InterfaceName, KeyName) \
                      .isEmpty())) {                                            \
       privateProp->V8_PRIVATE_PROPERTY_MEMBER_NAME(InterfaceName, KeyName)     \
           .set(                                                                \
               isolate,                                                         \
               createV8Private(                                                 \
                   isolate,                                                     \
                   V8_PRIVATE_PROPERTY_SYMBOL_STRING(InterfaceName, KeyName),   \
                   sizeof V8_PRIVATE_PROPERTY_SYMBOL_STRING(                    \
@@ skipping 23 matching lines @@
 #define V8_PRIVATE_PROPERTY_DECLARE_MEMBER(InterfaceName, KeyName) \
   ScopedPersistent<v8::Private> V8_PRIVATE_PROPERTY_MEMBER_NAME(   \
       InterfaceName, KeyName);  // NOLINT(readability/naming/underscores)
   V8_PRIVATE_PROPERTY_FOR_EACH(V8_PRIVATE_PROPERTY_DECLARE_MEMBER)
 #undef V8_PRIVATE_PROPERTY_DECLARE_MEMBER
 };
 
 }  // namespace blink
 
 #endif  // V8PrivateProperty_h