Oilpan: move Touch related objects to the oilpan heap.

Source/bindings/scripts/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 230 matching lines @@
     '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):
-    """Returns C++ type corresponding to IDL type."""
+def cpp_type(idl_type, extended_attributes=None, used_as_argument=False, used_as_member=False):
+    """Returns C++ type corresponding to IDL type.
+
+    Args:
+        used_as_argument: bool, True if idl_type's raw/primitive C++ type
+        should be returned.
+        used_as_member: bool, if idl_type is the type of an array or sequence
+        (which maps to some vector representation in C++.)

[haraken, 2014/03/05 14:52:46]

Instead of |used_as_member|, shall we use |will_be_garbage_collected| ?

[sof, 2014/03/05 16:01:12]

I renamed it as will_be_in_heap_object; its the presence within some
heap-allocated object that is controlled/sought here.

+    """
     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'
 
     extended_attributes = extended_attributes or {}
@@ skipping 13 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:
-        return cpp_template_type('Vector', cpp_type(this_array_or_sequence_type))
+        will_be_garbage_collected = is_will_be_garbage_collected(this_array_or_sequence_type)
+        vector_type = 'WillBeHeapVector' if will_be_garbage_collected else 'Vector'
+        return cpp_template_type(vector_type, cpp_type(this_array_or_sequence_type, used_as_member=will_be_garbage_collected))
 
     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):
-            return cpp_template_type('RefPtrWillBeRawPtr', implemented_as_class)
+            ref_ptr_type = 'RefPtrWillBeMember' if used_as_member else 'RefPtrWillBeRawPtr'
+            return cpp_template_type(ref_ptr_type, 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} >'
     else:
@@ 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()))'
+        ref_ptr_type = 'Member' if is_will_be_garbage_collected(this_array_or_sequence_type) else 'Ref'
+        expression_format = '(to{ref_ptr_type}PtrNativeArray<{array_or_sequence_type}, V8{array_or_sequence_type}>({v8_value}, {index}, info.GetIsolate()))'

[haraken, 2014/03/05 14:52:46]

"MemberPtr" sounds strange. Shall we call it toMemberNativeArray ?

[sof, 2014/03/05 16:01:12]

Great catch; my typo (the underlying method is called toMemberNativeArray()
already.) Updated the binding results & double checked output.

         add_includes_for_type(this_array_or_sequence_type)
     else:
+        ref_ptr_type = None
         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)
+    expression = expression_format.format(array_or_sequence_type=this_array_or_sequence_type, cpp_type=this_cpp_type, index=index, ref_ptr_type=ref_ptr_type, 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."""
     this_cpp_type = cpp_type(idl_type, extended_attributes=extended_attributes, used_as_argument=True)
 
     idl_type = preprocess_idl_type(idl_type)
     if idl_type == 'DOMString':
         format_string = 'V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID({cpp_type}, {variable_name}, {cpp_value})'
@@ skipping 167 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