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

Source/bindings/scripts/code_generator_v8.pm

 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006 Apple Computer, Inc.
 # Copyright (C) 2007, 2008, 2009, 2012 Google Inc.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 # Copyright (C) 2012 Ericsson AB. All rights reserved.
@@ skipping 436 matching lines @@
     if (IsTypedArrayType($interfaceName)) {
         push(@includes, "wtf/${interfaceName}.h");
     } elsif (!SkipIncludeHeader($interfaceName)) {
         my $idlFilename = Cwd::abs_path(IDLFileForInterface($interfaceName)) or die("Could NOT find IDL file for interface \"$interfaceName\" $!\n");
         my $idlRelPath = File::Spec->abs2rel($idlFilename, $sourceRoot);
         push(@includes, dirname($idlRelPath) . "/" . $implClassName . ".h");
     }
     return @includes;
 }
 
-sub NeedsOpaqueRootForGC
+sub NeedResolveWrapperReachability
 {
     my $interface = shift;
-    return $interface->extendedAttributes->{"GenerateIsReachable"} || $interface->extendedAttributes->{"CustomIsReachable"};
+    return $interface->extendedAttributes->{"GenerateIsReachable"} || $interface->extendedAttributes->{"CustomIsReachable"} || $interface->extendedAttributes->{"ReachableTo"};
 }
 
-sub GenerateOpaqueRootForGC
+sub GenerateResolveWrapperReachability
 {
     my $interface = shift;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
     if ($interface->extendedAttributes->{"CustomIsReachable"}) {
         return;
     }
 
     my $code = <<END;
-void* ${v8ClassName}::opaqueRootForGC(void* object, v8::Isolate* isolate)
+void ${v8ClassName}::resolveWrapperReachability(void* object, const v8::Persistent<v8::Object>& wrapper, v8::Isolate* isolate)
 {
     ${implClassName}* impl = fromInternalPointer(object);
 END
+    if ($interface->extendedAttributes->{"ReachableTo"}) {
+        $code .= "    v8::Local<v8::Object> creationContext = v8::Local<v8::Object>::New(isolate, wrapper);\n";
+    }
+    for my $reachableTo (@{$interface->extendedAttributes->{"ReachableTo"}}) {
+        my $reachableToType = $reachableTo->type;
+        my $reachableToName = $reachableTo->name;
+
+        AddIncludesForType($reachableToType);
+        $code .= <<END;
+    ${reachableToType}* ${reachableToName} = impl->${reachableToName}();
+    if (filter) {
+        UnsafePersistent<v8::Object> target = toV8Persistent(${reachableToName}, creationContext, isolate);
+        isolate->SetReference(wrapper, *reinterpret_cast<v8::Persistent<v8::Value>*>(target.persistent()));
+    }
+END
+    }
+
     my $isReachableMethod = $interface->extendedAttributes->{"GenerateIsReachable"};
     if ($isReachableMethod) {
         AddToImplIncludes("bindings/v8/V8GCController.h");
         AddToImplIncludes("core/dom/Element.h");
         $code .= <<END;
-    if (Node* owner = impl->${isReachableMethod}())
-        return V8GCController::opaqueRootForGC(owner, isolate);
+    if (Node* owner = impl->${isReachableMethod}()) {
+        setObjectGroup(V8GCController::opaqueRootForGC(owner, isolate), wrapper, isolate);
+        return;
+    }
 END
     }
 
     $code .= <<END;
-    return object;
+    setObjectGroup(object, wrapper, isolate);
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 sub GetSVGPropertyTypes
 {
     my $implType = shift;
 
@@ skipping 162 matching lines @@
     static bool HasInstanceInAnyWorld(v8::Handle<v8::Value>, v8::Isolate*);
     static v8::Handle<v8::FunctionTemplate> GetTemplate(v8::Isolate*, WrapperWorldType);
     static ${nativeType}* toNative(v8::Handle<v8::Object> object)
     {
         return fromInternalPointer(object->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex));
     }
     static void derefObject(void*);
     static WrapperTypeInfo info;
 END
 
-    if (NeedsOpaqueRootForGC($interface)) {
-        $header{classPublic}->add("    static void* opaqueRootForGC(void*, v8::Isolate*);\n");
+    if (NeedResolveWrapperReachability($interface)) {
+        $header{classPublic}->add("    static void resolveWrapperReachability(void*, const v8::Persistent<v8::Object>&, v8::Isolate*);\n");
     }
 
     if (InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
         $header{classPublic}->add("    static ActiveDOMObject* toActiveDOMObject(v8::Handle<v8::Object>);\n");
     }
 
     if (InheritsInterface($interface, "EventTarget")) {
         $header{classPublic}->add("    static EventTarget* toEventTarget(v8::Handle<v8::Object>);\n");
     }
 
@@ skipping 204 matching lines @@
 inline v8::Handle<v8::Value> toV8(${nativeType}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     if (UNLIKELY(!impl))
         return v8NullWithCheck(isolate);
     v8::Handle<v8::Value> wrapper = DOMDataStore::getWrapper<${v8ClassName}>(impl, isolate);
     if (!wrapper.IsEmpty())
         return wrapper;
     return wrap(impl, creationContext, isolate);
 }
 
+inline UnsafePersistent<v8::Object> toV8Persistent(${nativeType}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)

[jochen (gone - plz use gerrit), 2013/10/15 05:26:43]

we shouldn't introduce code using UnsafePersistent

what about returning a local and creating a persistent again from it when we
need it?

+{
+    ASSERT(impl);
+
+    UnsafePersistent<v8::Object> wrapperPersistent = DOMDataStore::getWrapperPersistent<${v8ClassName}>(impl, isolate);
+    if (LIKELY(!wrapperPersistent.isEmpty()))
+        return wrapperPersistent;
+
+    wrap(impl, creationContext, isolate);
+
+    wrapperPersistent = DOMDataStore::getWrapperPersistent<${v8ClassName}>(impl, isolate);
+    ASSERT(!wrapperPersistent.isEmpty());
+    return wrapperPersistent;
+}
+
 template<typename CallbackInfo>
 inline void v8SetReturnValue(const CallbackInfo& callbackInfo, ${nativeType}* impl, v8::Handle<v8::Object> creationContext)
 {
     if (UNLIKELY(!impl)) {
         v8SetReturnValueNull(callbackInfo);
         return;
     }
     if (DOMDataStore::setReturnValueFromWrapper<${v8ClassName}>(callbackInfo.GetReturnValue(), impl))
         return;
     v8::Handle<v8::Object> wrapper = wrap(impl, creationContext, callbackInfo.GetIsolate());
@@ skipping 3047 matching lines @@
     AddToImplIncludes("bindings/v8/V8DOMWrapper.h");
     AddToImplIncludes("core/dom/ContextFeatures.h");
     AddToImplIncludes("core/dom/Document.h");
     AddToImplIncludes("RuntimeEnabledFeatures.h");
     AddToImplIncludes("platform/TraceEvent.h");
 
     AddIncludesForType($interfaceName);
 
     my $toActiveDOMObject = InheritsExtendedAttribute($interface, "ActiveDOMObject") ? "${v8ClassName}::toActiveDOMObject" : "0";
     my $toEventTarget = InheritsInterface($interface, "EventTarget") ? "${v8ClassName}::toEventTarget" : "0";
-    my $rootForGC = NeedsOpaqueRootForGC($interface) ? "${v8ClassName}::opaqueRootForGC" : "0";
+    my $resolveWrapperReachability = NeedResolveWrapperReachability($interface) ? "${v8ClassName}::resolveWrapperReachability" : "0";
 
     # Find the super descriptor.
     my $parentClass = "";
     my $parentClassTemplate = "";
     if ($interface->parent) {
         my $parent = $interface->parent;
         AddToImplIncludes("V8${parent}.h");
         $parentClass = "V8" . $parent;
         $parentClassTemplate = $parentClass . "::GetTemplate(isolate, currentWorldType)";
     }
@@ skipping 29 matching lines @@
 {
     WebCore::initializeScriptWrappableForInterface(object);
 }
 
 namespace WebCore {
 END
         $implementation{nameSpaceWebCore}->addHeader($code);
     }
 
     my $code = "WrapperTypeInfo ${v8ClassName}::info = { ${v8ClassName}::GetTemplate, ${v8ClassName}::derefObject, $toActiveDOMObject, $toEventTarget, ";
-    $code .= "$rootForGC, ${v8ClassName}::installPerContextPrototypeProperties, $parentClassInfo, $WrapperTypePrototype };\n";
+    $code .= "$resolveWrapperReachability, ${v8ClassName}::installPerContextPrototypeProperties, $parentClassInfo, $WrapperTypePrototype };\n";
     $implementation{nameSpaceWebCore}->addHeader($code);
 
     $implementation{nameSpaceInternal}->add("template <typename T> void V8_USE(T) { }\n\n");
 
     my $hasConstructors = 0;
     my $hasReplaceable = 0;
 
     # Generate property accessors for attributes.
     for (my $index = 0; $index < @{$interface->attributes}; $index++) {
         my $attribute = @{$interface->attributes}[$index];
@@ skipping 36 matching lines @@
 
     if ($hasConstructors) {
         GenerateConstructorGetter($interface);
     }
 
     if ($hasConstructors || $hasReplaceable) {
         GenerateReplaceableAttributeSetter($interface);
         GenerateReplaceableAttributeSetterCallback($interface);
     }
 
-    if (NeedsOpaqueRootForGC($interface)) {
-        GenerateOpaqueRootForGC($interface);
+    if (NeedResolveWrapperReachability($interface)) {
+        GenerateResolveWrapperReachability($interface);
     }
 
     if ($interface->extendedAttributes->{"CheckSecurity"} && $interface->name ne "Window") {
         GenerateSecurityCheckFunctions($interface);
     }
 
     if (IsConstructorTemplate($interface, "TypedArray")) {
         my ($nativeType, $arrayType) = GetNativeTypeOfTypedArray($interface);
         $implementation{nameSpaceWebCore}->add(<<END);
 v8::Handle<v8::Object> wrap($implClassName* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
@@ skipping 788 matching lines @@
     GenerateSpecialWrap($interface, $v8ClassName, $nativeType);
 
     my $createWrapperArgumentType = GetPassRefPtrType($nativeType);
     my $baseType = BaseInterfaceName($interface);
 
     # FIXME: Do we really need to treat "GenerateIsReachable", "CustomIsReachable" and /SVG/
     # as dependent DOM objects?
     my $wrapperConfiguration = "WrapperConfiguration::Independent";
     if (InheritsExtendedAttribute($interface, "ActiveDOMObject")
         || InheritsExtendedAttribute($interface, "DependentLifetime")
-        || InheritsExtendedAttribute($interface, "GenerateIsReachable")
-        || InheritsExtendedAttribute($interface, "CustomIsReachable")
+        || NeedResolveWrapperReachability($interface)
         || $v8ClassName =~ /SVG/) {
         $wrapperConfiguration = "WrapperConfiguration::Dependent";
     }
 
     my $code = "";
     $code .= <<END;
 v8::Handle<v8::Object> ${v8ClassName}::createWrapper(${createWrapperArgumentType} impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     ASSERT(impl);
     ASSERT(!DOMDataStore::containsWrapper<${v8ClassName}>(impl.get(), isolate));
@@ skipping 1283 matching lines @@
     my $interface = shift;
 
     return 1 if $interface->extendedAttributes->{"CustomToV8"};
     return 1 if $interface->extendedAttributes->{"SpecialWrapFor"};
     return 1 if InheritsInterface($interface, "Document");
 
     return 0;
 }
 
 1;