Move mediastream module to oilpan transition types

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 5411 matching lines @@
     $code .= $nativeValue . "\n" if $nativeValue;  # Skip blank line for void return type
 
     return $code;
 }
 
 sub GetNativeType
 {
     my $type = shift;
     my $extendedAttributes = shift;
     my $isParameter = shift;
+    my $isMember = shift;
 
     my $svgNativeType = GetSVGTypeNeedingTearOff($type);
     if ($svgNativeType) {
         if ($svgNativeType =~ /List$/) {
             return "${svgNativeType}*";
         } else {
             return "RefPtr<${svgNativeType} >";
         }
     }
 
@@ skipping 30 matching lines @@
     }
 
     # We need to check [ImplementedAs] extended attribute for wrapper types.
     return "RefPtrWillBeRawPtr<$type>" if $type eq "XPathNSResolver";  # FIXME: Remove custom bindings for XPathNSResolver.
     if (IsWrapperType($type)) {
         my $interface = ParseInterface($type);
         my $implClassName = GetImplName($interface);
         if ($isParameter) {
             return "$implClassName*";
         } elsif (IsWillBeGarbageCollectedType($interface->name)) {
-            return "RefPtrWillBeRawPtr<$implClassName>";
+            if ($isMember) {
+                return "RefPtrWillBeMember<$implClassName>";

[Nils Barth (inactive), 2014/02/26 07:17:54]

Keishi, could you please add a test case?

Since this is "[WillBeGarbageCollected] on another interface"
(that's being used as an interface type: i.e., not on the current interface),
(correct?)
the relevant file is:
bindings/tests/idls/TestObjectPython.idl
...and you can put it after the other [WillBeGarbageCollected] test case.

This will ensure that we get updated test results, and
run-bindings-tests (r-b-t) catches changes.

You'll also need to update the Python CG (r-b-t enforces this),
or you can wait until we switch to Python (today or tomorrow)
and just work there.

Thanks!

[keishi, 2014/02/27 07:33:34]

I'm not sure if it is right but I've added a test.

[Nils Barth (inactive), 2014/02/27 11:20:53]

Thanks, looks generally ok;
I'll take a closer look later.

[Nils Barth (inactive), 2014/03/03 02:47:53]

Current test case looks ok, but you need one more for callback interfaces.
To check test coverage, first look at changes to output,
and see that all your new code appears.

Currently this is:
https://codereview.chromium.org/173363002/diff/340001/Source/bindings/tests/r...
...and it does include 'WillBeHeapVector' and 'toRefPtrWillBeMemberNativeArray'.

(Also, this gives full test coverage of v8_types.py;
to get this output the code needs to cover all your new code,
and you're just adding a test, without changing existing output,
so this gives full test coverage.)

However, since you're also changing v8_callback_interface.py,
you need to add a test case to TestCallbackInterface.idl.

Could you put the following at the end of TestCallbackInterface.idl ?
(Same test case as you put in TestObjectPython.idl, but different
behavior for callback interfaces.)

void
voidMethodSequenceTestInterfaceWillBeGarbageCollectedArg(sequence<TestInterfaceWillBeGarbageCollected>
sequenceTestInterfaceWillBeGarbageCollectedArg); // [WillBeGarbageCollected]

Thanks!

+            } else {
+                return "RefPtrWillBeRawPtr<$implClassName>";
+            }
         } else {
             return "RefPtr<$implClassName>";
         }
     }
     return "RefPtr<$type>" if IsRefPtrType($type) and (not $isParameter or $nonWrapperTypes{$type});
 
     my $arrayOrSequenceType = GetArrayOrSequenceType($type);
 
     if ($arrayOrSequenceType) {
-        my $nativeType = GetNativeType($arrayOrSequenceType);
-        $nativeType .= " " if ($nativeType =~ />$/);
-        return "Vector<${nativeType}>";
+        if (IsWillBeGarbageCollectedType($arrayOrSequenceType)) {
+            my $nativeType = GetNativeType($arrayOrSequenceType, {}, "", "member");
+            $nativeType .= " " if ($nativeType =~ />$/);
+            return "WillBeHeapVector<${nativeType}>";
+        } else {
+            my $nativeType = GetNativeType($arrayOrSequenceType);
+            $nativeType .= " " if ($nativeType =~ />$/);
+            return "Vector<${nativeType}>";
+        }
     }
 
     # Default, assume native type is a pointer with same type name as idl type
     return "${type}*";
 }
 
 sub GetNativeTypeForCallbacks
 {
     my $type = shift;
     return "const String&" if $type eq "DOMString";
     return "PassRefPtr<SerializedScriptValue>" if $type eq "SerializedScriptValue";
     return "void" if $type eq "void";
 
     # Callbacks use raw pointers, so pass isParameter = 1
     my $nativeType = GetNativeType($type, {}, "parameter");
     return "const $nativeType&" if $nativeType =~ /^Vector/;
+    return "const $nativeType&" if $nativeType =~ /^WillBeHeapVector/;
     return $nativeType;
 }
 
 sub JSValueToNativeStatement
 {
     my $type = shift;
     my $extendedAttributes = shift;
     my $argIndexOrZero = shift;
     my $jsValue = shift;
     my $variableName = shift;
@@ skipping 88 matching lines @@
         return "$value->Is${type}() ? V8${type}::toNative(v8::Handle<v8::${type}>::Cast($value)) : 0"
     }
 
     if ($type eq "XPathNSResolver") {
         return "toXPathNSResolver($value, $getIsolate)";
     }
 
     my $arrayOrSequenceType = GetArrayOrSequenceType($type);
 
     if ($arrayOrSequenceType) {
+        if (IsWillBeGarbageCollectedType($arrayOrSequenceType)) {
+            AddToImplIncludes("V8${arrayOrSequenceType}.h");
+            return "(toRefPtrWillBeMemberNativeArray<${arrayOrSequenceType}, V8${arrayOrSequenceType}>($value, $argIndexOrZero, $getIsolate))";

[haraken, 2014/02/26 13:58:37]

Still I don't fully understand why we need toRefPtrWillBeMemberNativeArray() and
toRefPtrNativeArray(). What we need would be toMemberNativeArray() and
toRefPtrNativeArray(), wouldn't it? I think it's enough to have the Member
version and the RefPtr version in order to make both the oilpan build and the
non-oilpan build compilable.

[keishi, 2014/02/27 07:33:34]

I misunderstood. Done.

+        }
         if (IsRefPtrType($arrayOrSequenceType)) {
             AddToImplIncludes("V8${arrayOrSequenceType}.h");
             return "(toRefPtrNativeArray<${arrayOrSequenceType}, V8${arrayOrSequenceType}>($value, $argIndexOrZero, $getIsolate))";
         }
         return "toNativeArray<" . GetNativeType($arrayOrSequenceType) . ">($value, $argIndexOrZero, $getIsolate)";
     }
 
     AddIncludesForType($type);
 
     AddToImplIncludes("V8${type}.h");
@@ skipping 830 matching lines @@
         if ($parameter->type eq "SerializedScriptValue") {
             return 1;
         } elsif (IsIntegerType($parameter->type)) {
             return 1;
         }
     }
     return 0;
 }
 
 1;