scripts.systemnative.DartiumBackend Class Reference

Inheritance diagram for scripts.systemnative.DartiumBackend:

Public Member Functions
def	__init__ (self, interface, cpp_library_emitter, options, loggerParent)
def	ImplementsMergedMembers (self)
def	CustomJSMembers (self)
def	GenerateCallback (self, info)
def	ImplementationTemplate (self)
def	RootClassName (self)
def	DeriveNativeEntry (self, name, kind, count)
def	DeriveNativeName (self, name, suffix="")
def	DeriveQualifiedBlinkName (self, interface_name, name)
def	NativeSpec (self)
def	StartInterface (self, members_emitter)
def	GenerateCustomFactory (self, constructor_info)
def	IsConstructorArgumentOptional (self, argument)
def	MakeFactoryCall (self, factory, method, arguments, constructor_info)
def	EmitStaticFactoryOverload (self, constructor_info, name, arguments)
def	HasSupportCheck (self)
def	GetSupportCheck (self)
def	FinishInterface (self)
def	EmitAttribute (self, attribute, html_name, read_only)
def	AddIndexer (self, element_type, nullable)
def	AmendIndexer (self, element_type)
def	EmitOperation (self, info, html_name, dart_js_interop=False)
def	SecondaryContext (self, interface)
Public Member Functions inherited from scripts.htmldartgenerator.HtmlDartGenerator
def	__init__ (self, interface, options, dart_use_blink, logger)
def	EmitSupportCheck (self)
def	EmitEventGetter (self, events_class_name)
def	AddMembers (self, interface, declare_only=False, dart_js_interop=False)
def	AddSecondaryMembers (self, interface)
def	OmitOperationOverrides (self)
def	AddConstant (self, constant)
def	AddAttribute (self, attribute, declare_only=False)
def	AddOperation (self, info, declare_only=False, dart_js_interop=False)
def	AdditionalImplementedInterfaces (self)
def	Mixins (self)
def	AddConstructors (self, constructors, factory_name, factory_constructor_name, constructor_emitter)
def	EmitHelpers (self, base_class, members_emitter)
def	DeclareAttribute (self, attribute, attr_name, read_only)
def	DeclareOperation (self, operation, return_type_name, method_name)
def	EmitListMixin (self, element_name, nullable)
def	SecureOutputType (self, type_name, is_dart_type=False, can_narrow_type=False, nullable=False)
def	SecureBaseName (self, type_name)
def	is_DOM_type (self, type_name)

Detailed Description

Generates Dart implementation for one DOM IDL interface.

Definition at line 88 of file systemnative.py.

Constructor & Destructor Documentation

__init__()

def scripts.systemnative.DartiumBackend.__init__	(		self,
			interface,
			cpp_library_emitter,
			options,
			loggerParent
	)

Reimplemented from scripts.htmldartgenerator.HtmlDartGenerator.

Definition at line 91 of file systemnative.py.

    def __init__(self, interface, cpp_library_emitter, options, loggerParent):
        super(DartiumBackend, self).__init__(interface, options, True,
                                             loggerParent)
 
        self._interface = interface
        self._cpp_library_emitter = cpp_library_emitter
        self._database = options.database
        self._template_loader = options.templates
        self._type_registry = options.type_registry
        self._interface_type_info = self._type_registry.TypeInfo(
            self._interface.id)
        self._metadata = options.metadata
        # These get initialized by StartInterface
        self._cpp_header_emitter = None
        self._cpp_impl_emitter = None
        self._members_emitter = None
        self._cpp_declarations_emitter = None
        self._cpp_impl_includes = None
        self._cpp_definitions_emitter = None
        self._cpp_resolver_emitter = None
        self._dart_js_interop = options.dart_js_interop
        _logger.setLevel(loggerParent.level)
 

Member Function Documentation

AddIndexer()

def scripts.systemnative.DartiumBackend.AddIndexer	(		self,
			element_type,
			nullable
	)

Adds all the methods required to complete implementation of List.

Definition at line 704 of file systemnative.py.

    def AddIndexer(self, element_type, nullable):
        """Adds all the methods required to complete implementation of List."""
        # We would like to simply inherit the implementation of everything except
        # length, [], and maybe []=.  It is possible to extend from a base
        # array implementation class only when there is no other implementation
        # inheritance.  There might be no implementation inheritance other than
        # DOMBaseWrapper for many classes, but there might be some where the
        # array-ness is introduced by a non-root interface:
        #
        #   interface Y extends X, List<T> ...
        #
        # In the non-root case we have to choose between:
        #
        #   class YImpl extends XImpl { add List<T> methods; }
        #
        # and
        #
        #   class YImpl extends ListBase<T> { copies of transitive XImpl methods; }
        #
        dart_element_type = self._DartType(element_type)
        if self._HasNativeIndexGetter():
            self._EmitNativeIndexGetter(dart_element_type)
        elif self._HasExplicitIndexedGetter():
            self._EmitExplicitIndexedGetter(dart_element_type)
        else:
            is_custom = any((op.id == 'item' and _IsCustom(op))
                            for op in self._interface.operations)
 
            output_conversion = self._OutputConversion(element_type, 'item')
            conversion_name = ''
            if output_conversion:
                conversion_name = output_conversion.function_name
 
            # First emit a toplevel function to do the native call
            # Calls to this are emitted elsewhere,
            dart_native_name, resolver_string = \
                self.DeriveNativeEntry("item", 'Method', 1)
 
            # Emit the method which calls the toplevel function, along with
            # the [] operator.
            dart_qualified_name = \
                self.DeriveQualifiedBlinkName(self._interface.id,
                                              dart_native_name)
 
            type_info = self._TypeInfo(element_type)
            blinkNativeIndexed = """
  $TYPE operator[](int index) {
    if (index < 0 || index >= length)
      throw new IndexError.withLength(index, length, indexable: this);
    return _nativeIndexedGetter(index);
  }
 
  $TYPE _nativeIndexedGetter(int index) => $(CONVERSION_NAME)($(DART_NATIVE_NAME)(this, index));
"""
            blinkNativeIndexedGetter = \
                ' $(DART_NATIVE_NAME)(this, index);\n'
            self._members_emitter.Emit(
                blinkNativeIndexed,
                DART_NATIVE_NAME=dart_qualified_name,
                TYPE=self.SecureOutputType(element_type),
                INTERFACE=self._interface.id,
                CONVERSION_NAME=conversion_name)
 
        if self._HasNativeIndexSetter():
            self._EmitNativeIndexSetter(dart_element_type)
        else:
            self._members_emitter.Emit(
                '\n'
                '  void operator[]=(int index, $TYPE value) {\n'
                '    throw new UnsupportedError("Cannot assign element of immutable List.");\n'
                '  }\n',
                TYPE=dart_element_type)
 
        self.EmitListMixin(dart_element_type, nullable)
 

AmendIndexer()

def scripts.systemnative.DartiumBackend.AmendIndexer	(		self,
			element_type
	)

Definition at line 779 of file systemnative.py.

    def AmendIndexer(self, element_type):
        # If interface is marked as having native indexed
        # getter or setter, we must emit overrides as it's not
        # guaranteed that the corresponding methods in C++ would be
        # virtual.  For example, as of time of writing, even though
        # Uint8ClampedArray inherits from Uint8Array, ::set method
        # is not virtual and accessing it through Uint8Array pointer
        # would lead to wrong semantics (modulo vs. clamping.)
        dart_element_type = self._DartType(element_type)
 
        if self._HasNativeIndexGetter():
            self._EmitNativeIndexGetter(dart_element_type)
        if self._HasNativeIndexSetter():
            self._EmitNativeIndexSetter(dart_element_type)
 

CustomJSMembers()

def scripts.systemnative.DartiumBackend.CustomJSMembers

(

self

)

Definition at line 120 of file systemnative.py.

    def CustomJSMembers(self):
        return {}
 

DeriveNativeEntry()

def scripts.systemnative.DartiumBackend.DeriveNativeEntry	(		self,
			name,
			kind,
			count
	)

Definition at line 158 of file systemnative.py.

    def DeriveNativeEntry(self, name, kind, count):
        interface_id = self._interface.id
        database = self._database
        tag = ""
        if kind == 'Getter':
            tag = "%s_Getter" % name
            blink_entry = tag
        elif kind == 'Setter':
            tag = "%s_Setter" % name
            blink_entry = tag
        elif kind == 'Constructor':
            tag = "constructorCallback"
            blink_entry = tag
        elif kind == 'Method':
            tag = "%s_Callback" % name
            blink_entry = tag
 
        interface_id = TypeIdToBlinkName(interface_id, database)
 
        def mkPublic(s):
            if s.startswith("_") or s.startswith("$"):
                return "$" + s
            return s
 
        if count is not None:
            arity = str(count)
            dart_name = mkPublic("_".join([tag, arity]))
        else:
            dart_name = mkPublic(tag)
        resolver_string = "_".join([interface_id, tag])
 
        return (dart_name, resolver_string)
 

DeriveNativeName()

def scripts.systemnative.DartiumBackend.DeriveNativeName	(		self,
			name,
			suffix = ""
	)

Definition at line 191 of file systemnative.py.

    def DeriveNativeName(self, name, suffix=""):
        fields = ['$' + name]
        if suffix != "":
            fields.append(suffix)
        return "_".join(fields)
 

DeriveQualifiedBlinkName()

def scripts.systemnative.DartiumBackend.DeriveQualifiedBlinkName	(		self,
			interface_name,
			name
	)

Definition at line 197 of file systemnative.py.

    def DeriveQualifiedBlinkName(self, interface_name, name):
        blinkClass = DeriveQualifiedName("_blink",
                                         DeriveBlinkClassName(interface_name))
        blinkInstance = DeriveQualifiedName(blinkClass, "instance")
        return DeriveQualifiedName(blinkInstance, name + "_")
 

EmitAttribute()

def scripts.systemnative.DartiumBackend.EmitAttribute	(		self,
			attribute,
			html_name,
			read_only
	)

Definition at line 550 of file systemnative.py.

    def EmitAttribute(self, attribute, html_name, read_only):
        self._AddGetter(attribute, html_name, read_only)
        if not read_only:
            self._AddSetter(attribute, html_name)
 

EmitOperation()

def scripts.systemnative.DartiumBackend.EmitOperation	(		self,
			info,
			html_name,
			dart_js_interop = False
	)

Arguments:
info: An OperationInfo object.

Definition at line 845 of file systemnative.py.

    def EmitOperation(self, info, html_name, dart_js_interop=False):
        """
    Arguments:
      info: An OperationInfo object.
    """
        if self._renamer.isPrivate(self._interface, info.operations[0].id):
            # Any private operations with Maps parameters changed to any type.
            # The public method that delegates to this private operation has already
            # converted from Map to native (JsObject) e.g., Element.animate.
            self._ChangePrivateOpMapArgToAny(info.operations)
 
        return_type = self.SecureOutputType(info.type_name, False,
                                            False if dart_js_interop else True)
 
        formals = info.ParametersAsDeclaration(self._DartType)
 
        parameters = info.ParametersAsListOfVariables(
            None, self._type_registry if self._dart_use_blink else None,
            dart_js_interop, self)
 
        operation = info.operations[0]
 
        output_conversion = self._OutputConversion(operation.type.id,
                                                   operation.id)
 
        dictionary_returned = False
        # Return type for dictionary is any (untyped).
        if operation.type.id == 'Dictionary':
            return_type = ''
            dictionary_returned = True
 
        dart_declaration = '%s%s %s(%s)' % ('static ' if info.IsStatic() else
                                            '', return_type, html_name, formals)
 
        is_custom = _IsCustom(operation)
        has_optional_arguments = any(
            IsOptional(argument) for argument in operation.arguments)
        needs_dispatcher = not is_custom and (len(info.operations) > 1 or
                                              has_optional_arguments)
 
        # Operation uses blink?
        wrap_unwrap_list = []
        return_wrap_jso = False
        # return type wrapped?
        if self._dart_use_blink:
            # Wrap the type to store the JsObject if Type is:
            #
            #      it's a dynamic/any type
            #    - type is Object
            #
            # JsObject maybe stored in the Dart class.
            return_wrap_jso = wrap_return_type_blink(
                return_type, info.type_name, self._type_registry)
            return_type_info = self._type_registry.TypeInfo(info.type_name)
        # wrap_jso the returned object
        wrap_unwrap_list.append(return_wrap_jso)
        wrap_unwrap_list.append(self._dart_use_blink)
 
        if info.callback_args:
            self._AddFutureifiedOperation(info, html_name)
        elif not needs_dispatcher:
            # Bind directly to native implementation
            argument_count = (0 if info.IsStatic() else 1) + len(
                info.param_infos)
            native_suffix = 'Callback'
            auto_scope_setup = self._GenerateAutoSetupScope(
                info.name, native_suffix)
            native_entry = \
                self.DeriveNativeEntry(operation.id, 'Method', len(info.param_infos))
            cpp_callback_name = self._GenerateNativeBinding(
                info.name,
                argument_count,
                dart_declaration,
                info.IsStatic(),
                return_type,
                parameters,
                native_suffix,
                is_custom,
                auto_scope_setup,
                native_entry=native_entry,
                wrap_unwrap_list=wrap_unwrap_list,
                dictionary_return=dictionary_returned,
                output_conversion=output_conversion)
            if not is_custom:
                self._GenerateOperationNativeCallback(
                    operation, operation.arguments, cpp_callback_name,
                    auto_scope_setup)
        else:
            self._GenerateDispatcher(info, info.operations, dart_declaration,
                                     html_name)
 

EmitStaticFactoryOverload()

def scripts.systemnative.DartiumBackend.EmitStaticFactoryOverload	(		self,
			constructor_info,
			name,
			arguments
	)

Definition at line 339 of file systemnative.py.

    def EmitStaticFactoryOverload(self, constructor_info, name, arguments):
        constructor_callback_cpp_name = name + 'constructorCallback'
        self._EmitConstructorInfrastructure(
            constructor_info,
            name,
            'constructorCallback',
            name,
            arguments,
            emit_to_native=True,
            is_custom=False)
 
        ext_attrs = self._interface.ext_attrs
 
        create_function = 'create'
        if 'NamedConstructor' in ext_attrs:
            create_function = 'createForJSConstructor'
        function_expression = '%s::%s' % (
            self._interface_type_info.native_type(), create_function)
 

FinishInterface()

def scripts.systemnative.DartiumBackend.FinishInterface

(

self

)

Definition at line 370 of file systemnative.py.

    def FinishInterface(self):
        interface = self._interface
        if interface.parents:
            supertype = '%sClassId' % interface.parents[0].type.id
        else:
            supertype = '-1'
 
        self._GenerateCPPHeader()
 
        self._cpp_impl_emitter.Emit(
            self._template_loader.Load('cpp_implementation.template'),
            INTERFACE=self._interface.id,
            SUPER_INTERFACE=supertype,
            INCLUDES=self._GenerateCPPIncludes(self._cpp_impl_includes),
            CALLBACKS=self._cpp_definitions_emitter.Fragments(),
            RESOLVER=self._cpp_resolver_emitter.Fragments(),
            WEBCORE_CLASS_NAME=self._interface_type_info.native_type(),
            WEBCORE_CLASS_NAME_ESCAPED=self._interface_type_info.native_type().
            replace('<', '_').replace('>', '_'),
            DART_IMPLEMENTATION_CLASS=self._interface_type_info.
            implementation_name(),
            DART_IMPLEMENTATION_LIBRARY_ID='Dart%sLibraryId' %
            self._renamer.GetLibraryId(self._interface))
 

GenerateCallback()

def scripts.systemnative.DartiumBackend.GenerateCallback	(		self,
			info
	)

Definition at line 137 of file systemnative.py.

    def GenerateCallback(self, info):
        return None
 

GenerateCustomFactory()

def scripts.systemnative.DartiumBackend.GenerateCustomFactory	(		self,
			constructor_info
	)

Definition at line 297 of file systemnative.py.

    def GenerateCustomFactory(self, constructor_info):
        if 'CustomConstructor' not in self._interface.ext_attrs:
            return False
 
        annotations = self._metadata.GetFormattedMetadata(
            self._library_name, self._interface, self._interface.id, '  ')
 
        self._members_emitter.Emit(
            '\n  $(ANNOTATIONS)factory $CTOR($PARAMS) => _create($FACTORY_PARAMS);\n',
            ANNOTATIONS=annotations,
            CTOR=constructor_info._ConstructorFullName(self._DartType),
            PARAMS=constructor_info.ParametersAsDeclaration(self._DartType),
            FACTORY_PARAMS= \
                constructor_info.ParametersAsArgumentList())
 
        # MutationObserver has custom _create.  TODO(terry): Consider table but this is only one.
        if self._interface.id != 'MutationObserver':
            constructor_callback_cpp_name = 'constructorCallback'
            self._EmitConstructorInfrastructure(
                constructor_info,
                "",
                constructor_callback_cpp_name,
                '_create',
                is_custom=True)
 
            self._cpp_declarations_emitter.Emit(
                '\n'
                'void $CPP_CALLBACK(Dart_NativeArguments);\n',
                CPP_CALLBACK=constructor_callback_cpp_name)
 
        return True
 

GetSupportCheck()

def scripts.systemnative.DartiumBackend.GetSupportCheck

(

self

)

Definition at line 362 of file systemnative.py.

    def GetSupportCheck(self):
        # Assume that everything is supported on Dartium.
        value = js_support_checks.get(self._interface.doc_js_name)
        if type(value) == tuple:
            return (value[0], 'true')
        else:
            return 'true'
 

HasSupportCheck()

def scripts.systemnative.DartiumBackend.HasSupportCheck

(

self

)

Definition at line 358 of file systemnative.py.

    def HasSupportCheck(self):
        # Need to omit a support check if it is conditional in JS.
        return self._interface.doc_js_name in js_support_checks
 

ImplementationTemplate()

def scripts.systemnative.DartiumBackend.ImplementationTemplate

(

self

)

Definition at line 140 of file systemnative.py.

    def ImplementationTemplate(self):
        template = None
        interface_name = self._interface.doc_js_name
        if interface_name == self._interface.id or not self._database.HasInterface(
                interface_name):
            template_file = 'impl_%s.darttemplate' % interface_name
            template = self._template_loader.TryLoad(template_file)
        if not template:
            template = self._template_loader.Load(
                'dart_implementation.darttemplate')
        return template
 

ImplementsMergedMembers()

def scripts.systemnative.DartiumBackend.ImplementsMergedMembers

(

self

)

Definition at line 114 of file systemnative.py.

    def ImplementsMergedMembers(self):
        # We could not add merged functions to implementation class because
        # underlying c++ object doesn't implement them. Merged functions are
        # generated on merged interface implementation instead.
        return False
 

IsConstructorArgumentOptional()

def scripts.systemnative.DartiumBackend.IsConstructorArgumentOptional	(		self,
			argument
	)

Definition at line 329 of file systemnative.py.

    def IsConstructorArgumentOptional(self, argument):
        return IsOptional(argument)
 

MakeFactoryCall()

def scripts.systemnative.DartiumBackend.MakeFactoryCall	(		self,
			factory,
			method,
			arguments,
			constructor_info
	)

Definition at line 332 of file systemnative.py.

    def MakeFactoryCall(self, factory, method, arguments, constructor_info):
        return emitter.Format(
            '$FACTORY.$METHOD($ARGUMENTS)',
            FACTORY=factory,
            METHOD=method,
            ARGUMENTS=arguments)
 

NativeSpec()

def scripts.systemnative.DartiumBackend.NativeSpec

(

self

)

Definition at line 203 of file systemnative.py.

    def NativeSpec(self):
        return ''
 

RootClassName()

def scripts.systemnative.DartiumBackend.RootClassName

(

self

)

Definition at line 152 of file systemnative.py.

    def RootClassName(self):
        return 'DartHtmlDomObject'
 

SecondaryContext()

def scripts.systemnative.DartiumBackend.SecondaryContext	(		self,
			interface
	)

Definition at line 995 of file systemnative.py.

    def SecondaryContext(self, interface):
        pass
 

StartInterface()

def scripts.systemnative.DartiumBackend.StartInterface	(		self,
			members_emitter
	)

Definition at line 206 of file systemnative.py.

    def StartInterface(self, members_emitter):
        # Create emitters for c++ implementation.
        if not IsPureInterface(self._interface.id, self._database) and \
            not IsCustomType(self._interface.id):
            self._cpp_header_emitter = self._cpp_library_emitter.CreateHeaderEmitter(
                self._interface.id,
                self._renamer.GetLibraryName(self._interface))
            self._cpp_impl_emitter = \
              self._cpp_library_emitter.CreateSourceEmitter(self._interface.id)
        else:
            self._cpp_header_emitter = emitter.Emitter()
            self._cpp_impl_emitter = emitter.Emitter()
 
        self._interface_type_info = self._TypeInfo(self._interface.id)
        self._members_emitter = members_emitter
 
        self._cpp_declarations_emitter = emitter.Emitter()
 
        # This is a hack to work around a strange C++ compile error that we weren't
        # able to track down the true cause of.
        if self._interface.id == 'Timing':
            self._cpp_impl_includes.add('"core/animation/TimedItem.h"')
 
        self._cpp_definitions_emitter = emitter.Emitter()
        self._cpp_resolver_emitter = emitter.Emitter()
 
        # We need to revisit our treatment of typed arrays, right now
        # it is full of hacks.
        if self._interface.ext_attrs.get('ConstructorTemplate') == 'TypedArray':
            self._cpp_resolver_emitter.Emit(
                '    if (name == "$(INTERFACE_NAME)_constructor_Callback")\n'
                '        return Dart$(INTERFACE_NAME)Internal::constructorCallback;\n',
                INTERFACE_NAME=self._interface.id)
 
            self._cpp_impl_includes.add('"DartArrayBufferViewCustom.h"')
            self._cpp_definitions_emitter.Emit(
                '\n'
                'static void constructorCallback(Dart_NativeArguments args)\n'
                '{\n'
                '    WebCore::DartArrayBufferViewInternal::constructWebGLArray<Dart$(INTERFACE_NAME)>(args);\n'
                '}\n',
                INTERFACE_NAME=self._interface.id)
 

---

The documentation for this class was generated from the following file:

• third_party/dart-lang/sdk/tools/dom/scripts/systemnative.py