Reland: Reland: Implement new Blink IDL attribute [SetReference]

Source/bindings/v8/WrapperTypeInfo.h

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 42 matching lines @@
     enum WrapperWorldType {
         MainWorld,
         IsolatedWorld,
         WorkerWorld
     };
 
     typedef v8::Handle<v8::FunctionTemplate> (*GetTemplateFunction)(v8::Isolate*, WrapperWorldType);
     typedef void (*DerefObjectFunction)(void*);
     typedef ActiveDOMObject* (*ToActiveDOMObjectFunction)(v8::Handle<v8::Object>);
     typedef EventTarget* (*ToEventTargetFunction)(v8::Handle<v8::Object>);
-    typedef void* (*OpaqueRootForGC)(void*, v8::Isolate*);
+    typedef void (*ResolveWrapperReachabilityFunction)(void*, const v8::Persistent<v8::Object>& wrapper, v8::Isolate*);

[haraken, 2013/10/17 03:28:22]

|wrapper| is not needed.

[kouhei (in TOK), 2013/10/17 05:17:23]

Done.

     typedef void (*InstallPerContextPrototypePropertiesFunction)(v8::Handle<v8::Object>, v8::Isolate*);
 
     enum WrapperTypePrototype {
         WrapperTypeObjectPrototype,
         WrapperTypeErrorPrototype
     };
 
+    inline void setObjectGroup(void* object, const v8::Persistent<v8::Object>& wrapper, v8::Isolate* isolate)
+    {
+        // FIXME: remove reinterpret_cast after http://crrev.com/27512003 has rolled.
+        isolate->SetObjectGroupId(reinterpret_cast<const v8::Persistent<v8::Value>&>(wrapper), v8::UniqueId(reinterpret_cast<intptr_t>(object)));
+    }
+
     // This struct provides a way to store a bunch of information that is helpful when unwrapping
     // v8 objects. Each v8 bindings class has exactly one static WrapperTypeInfo member, so
     // comparing pointers is a safe way to determine if types match.
     struct WrapperTypeInfo {
 
         static WrapperTypeInfo* unwrap(v8::Handle<v8::Value> typeInfoWrapper)
         {
             return reinterpret_cast<WrapperTypeInfo*>(v8::External::Cast(*typeInfoWrapper)->Value());
         }
 
@@ skipping 34 matching lines @@
             return toActiveDOMObjectFunction(object);
         }
 
         EventTarget* toEventTarget(v8::Handle<v8::Object> object)
         {
             if (!toEventTargetFunction)
                 return 0;
             return toEventTargetFunction(object);
         }
 
-        void* opaqueRootForGC(void* object, v8::Isolate* isolate)
+        void resolveWrapperReachability(void* object, const v8::Persistent<v8::Object>& wrapper, v8::Isolate* isolate)
         {
-            if (!opaqueRootForGCFunction)
-                return object;
-            return opaqueRootForGCFunction(object, isolate);
+            if (!resolveWrapperReachabilityFunction)
+                setObjectGroup(object, wrapper, isolate);
+            else
+                resolveWrapperReachabilityFunction(object, wrapper, isolate);
         }
 
         const GetTemplateFunction getTemplateFunction;
         const DerefObjectFunction derefObjectFunction;
         const ToActiveDOMObjectFunction toActiveDOMObjectFunction;
         const ToEventTargetFunction toEventTargetFunction;
-        const OpaqueRootForGC opaqueRootForGCFunction;
+        const ResolveWrapperReachabilityFunction resolveWrapperReachabilityFunction;
         const InstallPerContextPrototypePropertiesFunction installPerContextPrototypePropertiesFunction;
         const WrapperTypeInfo* parentClass;
         const WrapperTypePrototype wrapperTypePrototype;
     };
 
     template<typename T, int offset>
     inline T* getInternalField(const v8::Persistent<v8::Object>& persistent)
     {
         // This would be unsafe, but InternalFieldCount and GetAlignedPointerFromInternalField are guaranteed not to allocate
         const v8::Handle<v8::Object>& object = reinterpret_cast<const v8::Handle<v8::Object>&>(persistent);
@@ skipping 57 matching lines @@
         return configuration;
     }
 
     template<class ElementType>
     class WrapperTypeTraits {
         // specialized classes have thier own functions, which are generated by binding generator.
     };
 }
 
 #endif // WrapperTypeInfo_h