Refactor V8PrivateProperty to use an array.

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 <memory>
 
 #include "bindings/core/v8/ScriptPromiseProperties.h"
@@ skipping 28 matching lines @@
   X(SameObject, NotificationData)                     \
   X(SameObject, NotificationVibrate)                  \
   X(SameObject, PerformanceLongTaskTimingAttribution) \
   X(V8NodeFilterCondition, Filter)                    \
   X(Window, DocumentCachedAccessor)
 
 // The getter's name for a private property.
 #define V8_PRIVATE_PROPERTY_GETTER_NAME(InterfaceName, PrivateKeyName) \
   get##InterfaceName##PrivateKeyName
 
-// The member variable's name for a private property.
-#define V8_PRIVATE_PROPERTY_MEMBER_NAME(InterfaceName, PrivateKeyName) \
-  m_symbol##InterfaceName##PrivateKeyName
-
 // The string used to create a private symbol.  Must be unique per V8 instance.
 #define V8_PRIVATE_PROPERTY_SYMBOL_STRING(InterfaceName, PrivateKeyName) \
   #InterfaceName "#" #PrivateKeyName  // NOLINT(whitespace/indent)
 
 // Provides access to V8's private properties.
 //
 // Usage 1) Fast path to use a pre-registered symbol.
 //   auto private = V8PrivateProperty::getMessageEventCachedData(isolate);
 //   v8::Local<v8::Context> context = ...;
 //   v8::Local<v8::Object> object = ...;
@@ skipping 63 matching lines @@
     // 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());
   }
 
-#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();                    \
-    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(                    \
-                      InterfaceName,                                           \
-                      KeyName))); /* NOLINT(readability/naming/underscores) */ \
-    }                                                                          \
-    return Symbol(                                                             \
-        privateProp->V8_PRIVATE_PROPERTY_MEMBER_NAME(InterfaceName, KeyName)   \
-            .Get(isolate));                                                    \
+  enum SymbolID {
+#define V8_PRIVATE_PROPERTY_ENUMERATOR(InterfaceName, PrivateKeyName) \
+  k##InterfaceName##PrivateKeyName,
+    V8_PRIVATE_PROPERTY_FOR_EACH(V8_PRIVATE_PROPERTY_ENUMERATOR)
+#undef V8_PRIVATE_PROPERTY_ENUMERATOR
+        kSymbolCount
+  };
+
+  static Symbol get(v8::Isolate* isolate, SymbolID symbolID) {
+    V8PrivateProperty* privateProp =
+        V8PerIsolateData::from(isolate)->privateProperty();
+    DCHECK_GE(symbolID, 0);
+    DCHECK_LT(symbolID, kSymbolCount);
+    auto& symbol = privateProp->m_symbols[symbolID];
+    if (UNLIKELY(symbol.IsEmpty()))
+      privateProp->initialize(isolate, symbolID);
+    DCHECK(!symbol.IsEmpty());
+    return Symbol(symbol.Get(isolate));
+  }
+
+#define V8_PRIVATE_PROPERTY_DEFINE_GETTER(InterfaceName, KeyName)         \
+  static Symbol V8_PRIVATE_PROPERTY_GETTER_NAME(InterfaceName, KeyName)(  \
+      v8::Isolate * isolate) /* NOLINT(readability/naming/underscores) */ \
+  {                                                                       \
+    return get(isolate, k##InterfaceName##KeyName);                       \
   }
   V8_PRIVATE_PROPERTY_FOR_EACH(V8_PRIVATE_PROPERTY_DEFINE_GETTER)
 #undef V8_PRIVATE_PROPERTY_DEFINE_GETTER
 
   static Symbol createSymbol(v8::Isolate* isolate,
                              const char* symbol,
                              size_t length) {
     return Symbol(createV8Private(isolate, symbol, length));
   }
 
  private:
   V8PrivateProperty() {}
 
+  void initialize(v8::Isolate*, SymbolID);
+
   static v8::Local<v8::Private> createV8Private(v8::Isolate*,
                                                 const char* symbol,
                                                 size_t length);
 
-#define V8_PRIVATE_PROPERTY_DECLARE_MEMBER(InterfaceName, KeyName) \
-  v8::Eternal<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
+  v8::Eternal<v8::Private> m_symbols[kSymbolCount];
 };
 
 }  // namespace blink
 
 #endif  // V8PrivateProperty_h