[Bindings] Specialize WindowDocument symbol in V8PrivateProperty

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 21 matching lines @@
   X(IDBObserver, Callback)                            \
   X(IntersectionObserver, Callback)                   \
   X(MessageEvent, CachedData)                         \
   X(MutationObserver, Callback)                       \
   X(NamedConstructor, Initialized)                    \
   X(PerformanceObserver, Callback)                    \
   X(SameObject, NotificationActions)                  \
   X(SameObject, NotificationData)                     \
   X(SameObject, NotificationVibrate)                  \
   X(SameObject, PerformanceLongTaskTimingAttribution) \
-  X(V8NodeFilterCondition, Filter)                    \
-  X(Window, DocumentCachedAccessor)
+  X(V8NodeFilterCondition, Filter)
 
 // 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.
@@ skipping 93 matching lines @@
                       InterfaceName,                                           \
                       KeyName))); /* NOLINT(readability/naming/underscores) */ \
     }                                                                          \
     return Symbol(                                                             \
         privateProp->V8_PRIVATE_PROPERTY_MEMBER_NAME(InterfaceName, KeyName)   \
             .Get(isolate));                                                    \
   }
   V8_PRIVATE_PROPERTY_FOR_EACH(V8_PRIVATE_PROPERTY_DEFINE_GETTER)
 #undef V8_PRIVATE_PROPERTY_DEFINE_GETTER
 
+  static Symbol getWindowDocumentCachedAccessor(v8::Isolate* isolate) {
+    static constexpr char kSymbol[] = "Window#DocumentCachedAccessor";
+    V8PrivateProperty* privateProp =
+        V8PerIsolateData::from(isolate)->privateProperty();
+    if (UNLIKELY(privateProp->m_symbolWindowDocumentCachedAccessor.isEmpty())) {
+      privateProp->m_symbolWindowDocumentCachedAccessor.set(
+          isolate, createCachedV8Private(isolate, kSymbol, sizeof(kSymbol)));
+    }
+    return Symbol(
+        privateProp->m_symbolWindowDocumentCachedAccessor.newLocal(isolate));
+  }
+
   static Symbol createSymbol(v8::Isolate* isolate,
                              const char* symbol,
                              size_t length) {
     return Symbol(createV8Private(isolate, symbol, length));
   }
 
  private:
   V8PrivateProperty() {}
 
   static v8::Local<v8::Private> createV8Private(v8::Isolate*,
                                                 const char* symbol,
                                                 size_t length);
+  static v8::Local<v8::Private> createCachedV8Private(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
+
+  // TODO(peria): Do not use this specialized hack for
+  // Window#DocumentCachedAccessor. This is required to put v8::Private key in
+  // a snapshot, and it cannot be a v8::Eternal<> due to V8 serializer's
+  // requirement.
+  ScopedPersistent<v8::Private> m_symbolWindowDocumentCachedAccessor;

[jbroman, 2017/03/30 15:55:55]

Out of curiosity, now that we're using v8::Private::ForApi, the only reason this
is not an eternal is that the snapshot creator currently complains in that case,
right? (Because it seems to me that we would end up populating it correctly,
given the private symbol table is serialized correctly.)

[peria, 2017/03/31 04:26:50]

Yes, I'm thinking so.

 };
 
 }  // namespace blink
 
 #endif  // V8PrivateProperty_h