Support V8EnabledAtRuntime in constructors.

lib/dom/scripts/systemnative.py

 #!/usr/bin/python
 # Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 """This module provides shared functionality for the systems to generate
 native binding from the IDL database."""
 
 import emitter
 import os
 import systembase
 from generator import *
 from systemhtml import DomToHtmlEvent, DomToHtmlEvents, HtmlSystemShared
 from systemhtml import HtmlElementConstructorInfos
 from systemhtml import EmitHtmlElementFactoryConstructors
 
+def toWebKitName(name):

[podivilov, 2012/06/26 12:33:01]

please move this helper to the end of the file and rename to _ToWebKitName.

[Anton Muhin, 2012/06/26 12:37:25]

Done.

+  name = name[0].lower() + name[1:]
+  name = re.sub(r'^(hTML|uRL|jS|xML|xSLT)', lambda s: s.group(1).lower(),
+                name)
+  return re.sub(r'^(create|exclusive)', lambda s: 'is' + s.group(1).capitalize(),
+                name)
+
 class NativeImplementationSystem(systembase.System):
 
   def __init__(self, templates, database, emitters, output_dir):
     super(NativeImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
 
     self._dom_impl_files = []
     self._cpp_header_files = []
     self._cpp_impl_files = []
     self._html_system = HtmlSystemShared(database)
@@ skipping 221 matching lines @@
     self._cpp_resolver_emitter.Emit(
         '    if (name == "$(INTERFACE_NAME)_constructor_Callback")\n'
         '        return Dart$(INTERFACE_NAME)Internal::constructorCallback;\n',
         INTERFACE_NAME=self._interface.id)
 
 
     constructor_info = AnalyzeConstructor(self._interface)
     if constructor_info:
       self._EmitFactoryProvider(self._interface.id, constructor_info)
 
-    if 'CustomConstructor' in self._interface.ext_attrs:
+    ext_attrs = self._interface.ext_attrs
+
+    if 'CustomConstructor' in ext_attrs:
       # We have a custom implementation for it.
       self._cpp_declarations_emitter.Emit(
           '\n'
           'void constructorCallback(Dart_NativeArguments);\n')
       return
 
-    raises_dom_exceptions = 'ConstructorRaisesException' in self._interface.ext_attrs
+    raises_dom_exceptions = 'ConstructorRaisesException' in ext_attrs
     raises_exceptions = raises_dom_exceptions or len(constructor_info.idl_args) > 0
     arguments = []
     parameter_definitions_emitter = emitter.Emitter()
     create_function = 'create'
-    if 'NamedConstructor' in self._interface.ext_attrs:
+    if 'NamedConstructor' in ext_attrs:
       raises_exceptions = True
+      self._cpp_impl_includes.add('"DOMWindow.h"')
       parameter_definitions_emitter.Emit(
             '        DOMWindow* domWindow = DartUtilities::domWindowForCurrentIsolate();\n'
             '        if (!domWindow) {\n'
             '            exception = Dart_NewString("Failed to fetch domWindow");\n'
             '            goto fail;\n'
             '        }\n'
             '        Document* document = domWindow->document();\n')
-      self._cpp_impl_includes.add('"DOMWindow.h"')
       arguments.append('document')
       create_function = 'createForJSConstructor'
-    if 'CallWith' in self._interface.ext_attrs:
-      call_with = self._interface.ext_attrs['CallWith']
+    if 'CallWith' in ext_attrs:
+      call_with = ext_attrs['CallWith']
       if call_with == 'ScriptExecutionContext':
         raises_exceptions = True
         parameter_definitions_emitter.Emit(
             '        ScriptExecutionContext* context = DartUtilities::scriptExecutionContext();\n'
             '        if (!context) {\n'
             '            exception = Dart_NewString("Failed to create an object");\n'
             '            goto fail;\n'
             '        }\n')
         arguments.append('context')
       else:
         raise Exception('Unsupported CallWith=%s attribute' % call_with)
 
     # Process constructor arguments.
     for (i, argument) in enumerate(constructor_info.idl_args):
       argument_expression = self._GenerateToNative(
           parameter_definitions_emitter, argument, i)
       arguments.append(argument_expression)
 
     function_expression = '%s::%s' % (self._interface_type_info.native_type(), create_function)
     invocation = self._GenerateWebCoreInvocation(function_expression, arguments,
-        self._interface.id, self._interface.ext_attrs, raises_dom_exceptions)
+        self._interface.id, ext_attrs, raises_dom_exceptions)
 
     runtime_check = None
     database = self._system._database
-    if 'synthesizedV8EnabledPerContext' in self._interface.ext_attrs:
+    assert (not (
+      'synthesizedV8EnabledPerContext' in ext_attrs and
+      'synthesizedV8EnabledAtRuntime' in ext_attrs))
+    if 'synthesizedV8EnabledPerContext' in ext_attrs:
       raises_exceptions = True
       self._cpp_impl_includes.add('"ContextFeatures.h"')
       runtime_check = emitter.Format(
           '        if (!ContextFeatures::$(FEATURE)Enabled(DartUtilities::domWindowForCurrentIsolate()->document())) {\n'
           '            exception = Dart_NewString("Feature $FEATURE is not enabled");\n'
           '            goto fail;\n'
           '        }',
-          FEATURE=self._interface.ext_attrs['synthesizedV8EnabledPerContext'])
+          FEATURE=ext_attrs['synthesizedV8EnabledPerContext'])
+
+    if 'synthesizedV8EnabledAtRuntime' in ext_attrs:
+      raises_exceptions = True
+      self._cpp_impl_includes.add('"RuntimeEnabledFeatures.h"')
+      runtime_check = emitter.Format(
+          '        if (!RuntimeEnabledFeatures::$(FEATURE)Enabled()) {\n'
+          '            exception = Dart_NewString("Feature $FEATURE is not enabled");\n'
+          '            goto fail;\n'
+          '        }',
+          FEATURE=toWebKitName(ext_attrs['synthesizedV8EnabledAtRuntime']))
 
     self._GenerateNativeCallback(callback_name='constructorCallback',
         parameter_definitions=parameter_definitions_emitter.Fragments(),
         needs_receiver=False, invocation=invocation,
         raises_exceptions=raises_exceptions,
         runtime_check=runtime_check)
 
   def _EmitHtmlElementFactoryConstructors(self, infos, html_interface_name):
     EmitHtmlElementFactoryConstructors(
         self._system._EmitterForFactoryProviderBody(
@@ skipping 277 matching lines @@
           webcore_function_name = 'getNonEmptyURLAttribute'
         else:
           webcore_function_name = 'getURLAttribute'
       arguments.append(self._GenerateWebCoreReflectionAttributeName(attr))
     else:
       if attr.id == 'operator':
         webcore_function_name = '_operator'
       elif attr.id == 'target' and attr.type.id == 'SVGAnimatedString':
         webcore_function_name = 'svgTarget'
       else:
-        webcore_function_name = re.sub(r'^(HTML|URL|JS|XML|XSLT|\w)',
-                                       lambda s: s.group(1).lower(),
-                                       attr.id)
-        webcore_function_name = re.sub(r'^(create|exclusive)',
-                                       lambda s: 'is' + s.group(1).capitalize(),
-                                       webcore_function_name)
+        webcore_function_name = toWebKitName(attr.id)
       if attr.type.id.startswith('SVGAnimated'):
         webcore_function_name += 'Animated'
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     invocation = self._GenerateWebCoreInvocation(function_expression,
         arguments, attr.type.id, attr.ext_attrs, attr.get_raises)
     self._GenerateNativeCallback(cpp_callback_name, parameter_definitions_emitter.Fragments(),
         True, invocation, raises_exceptions=raises_exceptions)
 
   def _AddSetter(self, attr, html_name):
@@ skipping 442 matching lines @@
       continue
     parent_interface = database.GetInterface(parent.type.id)
     if callback(parent_interface):
       return parent_interface
     parent_interface = _FindParent(parent_interface, database, callback)
     if parent_interface:
       return parent_interface
 
 def _IsArgumentOptionalInWebCore(argument):
   return IsOptional(argument) and not 'Callback' in argument.ext_attrs