Make classes for union types exported.

Source/bindings/scripts/v8_union.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import v8_utilities
 
 
 UNION_H_INCLUDES = frozenset([
     'bindings/core/v8/Dictionary.h',
     'bindings/core/v8/ExceptionState.h',
     'bindings/core/v8/V8Binding.h',
     'platform/heap/Handle.h',
 ])
 
 UNION_CPP_INCLUDES_BLACKLIST = frozenset([
     # This header defines static functions needed to implement event handler
     # attributes in interfaces that implement GlobalEventHandlers. They are not
     # needed or used by UnionTypes*.cpp, so including the header causes
     # compilation errors.
     # FIXME: We should solve this problem in a way that doesn't involve special-
     # casing a header like this.
     'core/dom/GlobalEventHandlers.h',
 ])
 
 
 cpp_includes = set()
 header_forward_decls = set()
 
 
-def union_context(union_types, interfaces_info):
+def union_context(union_types, interfaces_info, component):

[bashi, 2015/04/01 07:16:51]

nit: we generally put component-specific logic in code_generator_v8.py. For
consistency I slightly prefer to follow the current convention for now.

That said, I think that we eventually want to integrate such component-specific
logic into a specific place (e.g. ComponentInfo) so this is just a nit.

[tasak, 2015/04/02 05:31:36]

Done.

     cpp_includes.clear()
     header_forward_decls.clear()
+    header_includes = set()
+    header_includes.update(UNION_H_INCLUDES)
 
     # For container classes we strip nullable wrappers. For example,
     # both (A or B)? and (A? or B) will become AOrB. This should be OK
     # because container classes can handle null and it seems that
     # distinguishing (A or B)? and (A? or B) doesn't make sense.
     container_cpp_types = set()
     union_types_for_containers = set()
     nullable_cpp_types = set()
     for union_type in union_types:
         cpp_type = union_type.cpp_type
         if cpp_type not in container_cpp_types:
             union_types_for_containers.add(union_type)
             container_cpp_types.add(cpp_type)
         if union_type.includes_nullable_type:
             nullable_cpp_types.add(cpp_type)
 
     union_types_for_containers = sorted(union_types_for_containers,
                                         key=lambda union_type: union_type.cpp_type)
     nullable_cpp_types = sorted(nullable_cpp_types)
+    header_includes.add('%s/%sExport.h' % (component, component.capitalize()))

[bashi, 2015/04/01 07:16:51]

nit: how about adding ComonentInfo.include_path_for_export like
include_path_for_union_types?

[tasak, 2015/04/02 05:31:36]

Done.

 
     return {
         'containers': [container_context(union_type, interfaces_info)
                        for union_type in union_types_for_containers],
         'cpp_includes': sorted(cpp_includes - UNION_CPP_INCLUDES_BLACKLIST),
         'header_forward_decls': sorted(header_forward_decls),
-        'header_includes': sorted(UNION_H_INCLUDES),
+        'header_includes': sorted(header_includes),
         'nullable_cpp_types': nullable_cpp_types,
+        'exported': '%s_EXPORT ' % component.upper(),

[bashi, 2015/04/01 07:16:51]

nit: I'd prefer dropping the trailing space and adding spaces in templates.

[bashi, 2015/04/01 07:16:51]

nit: alphabetical order.

[tasak, 2015/04/02 05:31:36]

Moved 'exported' in the almost same way as ComponentInfo.

[tasak, 2015/04/02 05:31:36]

Temporarily I would like to use the trailing space.

     }
 
 
 def container_context(union_type, interfaces_info):
     members = []
 
     # These variables refer to member contexts if the given union type has
     # corresponding types. They are used for V8 -> impl conversion.
     array_buffer_type = None
     array_buffer_view_type = None
@@ skipping 75 matching lines @@
             creation_context='creationContext'),
         'enum_validation_expression': member.enum_validation_expression,
         'is_traceable': member.is_traceable,
         'rvalue_cpp_type': member.cpp_type_args(used_as_rvalue_type=True),
         'specific_type_enum': 'SpecificType' + member.name,
         'type_name': member.name,
         'v8_value_to_local_cpp_value': member.v8_value_to_local_cpp_value(
             {}, 'v8Value', 'cppValue', isolate='isolate',
             use_exception_state=True, restricted_float=True),
     }