Move mediastream module to oilpan transition types

Source/bindings/scripts/unstable/v8_types.py

 # Copyright (C) 2013 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
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 229 matching lines @@
     'Date': 'double',
     'Dictionary': 'Dictionary',
     'EventHandler': 'EventListener*',
     'Promise': 'ScriptPromise',
     'ScriptValue': 'ScriptValue',
     # FIXME: Eliminate custom bindings for XPathNSResolver  http://crbug.com/345529
     'XPathNSResolver': 'RefPtrWillBeRawPtr<XPathNSResolver>',
     'boolean': 'bool',
 }
 
-def cpp_type(idl_type, extended_attributes=None, used_as_argument=False):
+
+def cpp_type(idl_type, extended_attributes=None, used_as_argument=False, used_as_member=False):

[haraken, 2014/02/27 15:32:43]

Is |used_as_member| necessary?

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

Keishi, could you add some documentation to the docstring to explain
used_as_member?

Format (and suggested contents) is:

Args:
    used_as_member: bool, is idl_type a member of an array or sequence? (in C++
represented as a vector)

Reference:
http://google-styleguide.googlecode.com/svn/trunk/pyguide.html?showone=Commen...

     """Returns C++ type corresponding to IDL type."""
     def string_mode():
         # FIXME: the Web IDL spec requires 'EmptyString', not 'NullString',
         # but we use NullString for performance.
         if extended_attributes.get('TreatNullAs') != 'NullString':
             return ''
         if extended_attributes.get('TreatUndefinedAs') != 'NullString':
             return 'WithNullCheck'
         return 'WithUndefinedOrNullCheck'
 
@@ skipping 14 matching lines @@
         if not used_as_argument:
             return 'String'
         return 'V8StringResource<%s>' % string_mode()
     if is_union_type(idl_type):
         # Attribute 'union_member_types' use is ok, but pylint can't infer this
         # pylint: disable=E1103
         return (cpp_type(union_member_type)
                 for union_member_type in idl_type.union_member_types)
     this_array_or_sequence_type = array_or_sequence_type(idl_type)
     if this_array_or_sequence_type:
+        if is_will_be_garbage_collected(this_array_or_sequence_type):
+            return cpp_template_type('WillBeHeapVector', cpp_type(this_array_or_sequence_type, used_as_member=True))

[haraken, 2014/02/27 15:32:43]

I don't quite understand that you're adding |used_as_member| to cpp_type() but
passing |used_as_member| to cpp_template_type().

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

? Keishi's code makes sense AFAICT;
it's using |used_as_member| in cpp_type to select with template to use;
it's not passed to cpp_template_type(), which just fills in "Template<Class>"

         return cpp_template_type('Vector', cpp_type(this_array_or_sequence_type))
 
     if is_typed_array_type(idl_type) and used_as_argument:
         return idl_type + '*'
     if is_interface_type(idl_type):
         implemented_as_class = implemented_as(idl_type)
         if used_as_argument:
             return implemented_as_class + '*'
         if is_will_be_garbage_collected(idl_type):
+            if used_as_member:
+                return cpp_template_type('RefPtrWillBeMember', implemented_as_class)
             return cpp_template_type('RefPtrWillBeRawPtr', implemented_as_class)
         return cpp_template_type('RefPtr', implemented_as_class)
     # Default, assume native type is a pointer with same type name as idl type
     return idl_type + '*'
 
 
 def cpp_template_type(template, inner_type):
     """Returns C++ template specialized to type, with space added if needed."""
     if inner_type.endswith('>'):
         format_string = '{template}<{inner_type} >'
@@ skipping 158 matching lines @@
 def v8_value_to_cpp_value_array_or_sequence(this_array_or_sequence_type, v8_value, index):
     # Index is None for setters, index (starting at 0) for method arguments,
     # and is used to provide a human-readable exception message
     if index is None:
         index = 0  # special case, meaning "setter"
     else:
         index += 1  # human-readable index
     if (is_interface_type(this_array_or_sequence_type) and
         this_array_or_sequence_type != 'Dictionary'):
         this_cpp_type = None
-        expression_format = '(toRefPtrNativeArray<{array_or_sequence_type}, V8{array_or_sequence_type}>({v8_value}, {index}, info.GetIsolate()))'
+        if is_will_be_garbage_collected(this_array_or_sequence_type):
+            expression_format = '(toMemberNativeArray<{array_or_sequence_type}, V8{array_or_sequence_type}>({v8_value}, {index}, info.GetIsolate()))'

[sof, 2014/03/02 20:10:55]

To my eyes, it would read better if you instead created a local binding
(to_native_array_function, or something like that) which was bound to
'toMemberNativeArray' or 'torRefPtrNativeArray' & substituted that in here. Less
duplication.

(This comment applies to the other special cases added here.)

+        else:
+            expression_format = '(toRefPtrNativeArray<{array_or_sequence_type}, V8{array_or_sequence_type}>({v8_value}, {index}, info.GetIsolate()))'
         add_includes_for_type(this_array_or_sequence_type)
     else:
         this_cpp_type = cpp_type(this_array_or_sequence_type)
         expression_format = 'toNativeArray<{cpp_type}>({v8_value}, {index}, info.GetIsolate())'
     expression = expression_format.format(array_or_sequence_type=this_array_or_sequence_type, cpp_type=this_cpp_type, index=index, v8_value=v8_value)
     return expression
 
 
 def v8_value_to_local_cpp_value(idl_type, extended_attributes, v8_value, variable_name, index=None):
     """Returns an expression that converts a V8 value to a C++ value and stores it as a local value."""
@@ skipping 172 matching lines @@
 
 
 def cpp_value_to_v8_value(idl_type, cpp_value, isolate='info.GetIsolate()', creation_context='', extended_attributes=None):
     """Returns an expression that converts a C++ value to a V8 value."""
     # the isolate parameter is needed for callback interfaces
     idl_type, cpp_value = preprocess_idl_type_and_value(idl_type, cpp_value, extended_attributes)
     this_v8_conversion_type = v8_conversion_type(idl_type, extended_attributes)
     format_string = CPP_VALUE_TO_V8_VALUE[this_v8_conversion_type]
     statement = format_string.format(cpp_value=cpp_value, isolate=isolate, creation_context=creation_context)
     return statement