Refresh dart:dom libraries from WebKit

client/dom/scripts/dartgenerator.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 generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
@@ skipping 24 matching lines @@
     # Map to extra precision - int is a bignum in Dart.
     'long': 'int',
     'long long': 'int',
     'object': 'Object',
     # Map to extra precision - int is a bignum in Dart.
     'short': 'int',
     'string': 'String',
     'void': 'void',
     'Array': 'List',
     'sequence': 'List',
-    # TODO(vsm): We need to support other types. We could weaken to
-    # Object, or inject SSV into the appropriate types.
-    'SerializedScriptValue': 'String',
+    # TODO(sra): Come up with some meaningful name so that where this appears in
+    # the documentation, the user is made aware that only a limited subset of
+    # serializable types are actually permitted.
+    'SerializedScriptValue': 'Dynamic',
     # TODO(vsm): Automatically recognize types defined in src.
     'TimeoutHandler': 'TimeoutHandler',
     'RequestAnimationFrameCallback': 'RequestAnimationFrameCallback',
 
     # TODO(sra): Flags is really a dictionary: {create:bool, exclusive:bool}
     # http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#the-flags-interface
     'WebKitFlags': 'Object',
     }
 
 _dart_to_idl_type_conversions = dict((v,k) for k, v in
@@ skipping 30 matching lines @@
 #
 _interface_factories = {
     'Float32Array': '_TypedArrayFactoryProvider',
     'Float64Array': '_TypedArrayFactoryProvider',
     'Int8Array': '_TypedArrayFactoryProvider',
     'Int16Array': '_TypedArrayFactoryProvider',
     'Int32Array': '_TypedArrayFactoryProvider',
     'Uint8Array': '_TypedArrayFactoryProvider',
     'Uint16Array': '_TypedArrayFactoryProvider',
     'Uint32Array': '_TypedArrayFactoryProvider',
+    'Uint8ClampedArray': '_TypedArrayFactoryProvider',
 }
 
 #
 # Custom methods that must be implemented by hand.
 #
 _custom_methods = set([
     ('DOMWindow', 'setInterval'),
     ('DOMWindow', 'setTimeout'),
     ('WorkerContext', 'setInterval'),
     ('WorkerContext', 'setTimeout'),
@@ skipping 635 matching lines @@
   return None
 
 def MaybeTypedArrayElementType(interface):
   """Returns the typed array element type, or None in interface is not a
   TypedArray.
   """
   # Typed arrays implement ArrayBufferView and List<T>.
   for parent in interface.parents:
     if  parent.type.id == 'ArrayBufferView':
       return MaybeListElementType(interface)
+    if  parent.type.id == 'Uint8Array':
+      return 'int'
   return None
 
 
 def AttributeOutputOrder(a, b):
   """Canonical output ordering for attributes."""
     # Getters before setters:
   if a.id < b.id: return -1
   if a.id > b.id: return 1
   if a.is_fc_setter < b.is_fc_setter: return -1
   if a.is_fc_setter > b.is_fc_setter: return 1
@@ skipping 1240 matching lines @@
     # TODO(sra): Use separate mixins for mutable implementations of List<T>.
     # TODO(sra): Use separate mixins for typed array implementations of List<T>.
     template_file = 'immutable_list_mixin.darttemplate'
     template = self._system._templates.Load(template_file)
     self._members_emitter.Emit(template, E=element_type)
 
 
   def AddTypedArrayConstructors(self, element_type):
     self._members_emitter.Emit(
         '\n'
-        '  factory $CTOR(int length) =>  _construct(length);\n'
+        '  factory $CTOR(int length) =>  _construct_$CTOR(length);\n'
         '\n'
-        '  factory $CTOR.fromList(List<$TYPE> list) => _construct(list);\n'
+        '  factory $CTOR.fromList(List<$TYPE> list) => _construct_$CTOR(list);\n'
         '\n'
-        '  factory $CTOR.fromBuffer(ArrayBuffer buffer) => _construct(buffer);\n'
+        '  factory $CTOR.fromBuffer(ArrayBuffer buffer) => _construct_$CTOR(buffer);\n'
         '\n'
-        '  static _construct(arg) native \'return new $CTOR(arg);\';\n',
+        '  static _construct_$CTOR(arg) native \'return new $CTOR(arg);\';\n',
         CTOR=self._interface.id,
         TYPE=element_type)
 
 
   def AddOperation(self, info):
     """
     Arguments:
       info: An OperationInfo object.
     """
     # TODO(vsm): Handle overloads.
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($PARAMS) native;\n',
         TYPE=self._NarrowOutputType(info.type_name),
         NAME=info.name,
         PARAMS=info.ParametersImplementationDeclaration(
             lambda type_name: self._NarrowInputType(type_name)))