Canvas2D Performance: fix the bottleneck of hasInstance during JS binding -- overloading

Source/bindings/scripts/v8_interface.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 # coding=utf-8
 #
 # 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
@@ skipping 756 matching lines @@
     # • an interface type that V implements
     # (Unlike most of these tests, this can return multiple methods, since we
     #  test if it implements an interface. Thus we need a for loop, not a next.)
     # (We distinguish wrapper types from built-in interface types.)
     for idl_type, method in ((idl_type, method)
                              for idl_type, method in idl_types_methods
                              if idl_type.is_wrapper_type):
         test = 'V8{idl_type}::hasInstance({cpp_value}, info.GetIsolate())'.format(idl_type=idl_type.base_type, cpp_value=cpp_value)
         yield test, method
 
+    for argument in arguments:

[yunchao, 2014/09/30 09:17:29]

resolution_tests_methods has filtered a lot of arguments before overloads, or
returned early in this function if only one argument that is directly used for
overload resolution. So the arguments in the cases your listed  are not in the
'arguments' here. They will not be marked as 'type_checked_already'. 

[Jens Widell, 2014/09/30 09:38:22]

Ah, yes, that's true. Note though that this function can be called multiple
times with the same method in the |effective_overloads| list, and that it thus
can end up setting 'type_checked_already' to true for multiple arguments of that
one method.

In the case

  f(long a)
  f(SomeInterface b, optional SomeInterface c, optional SomeInterface d)
  f(SomeInterface e, long f)

for instance, resolution_tests_methods() will be called once for the
len(argv)==1 case, and will consider the first two, using their first arguments,
and mark |b| as type checked. Then it will be called again for the len(argv)==2
case, and will then consider the last two, using their second arguments, and
mark |c| as type checked. (It will also be called once for the len(argv)==3
case, but then it stops early, having only one viable candidate.)

So both of the second method's arguments would be marked as type checked, but
when it's actually called, at most one of the arguments will actually have been
type checked. None of them will have been type checked if it's called with three
arguments.

+        if argument['idl_type_object'].is_wrapper_type:
+            argument['type_checked_already'] = True
+
+
     # 8. Otherwise: if V is any kind of object except for a native Date object,
     # a native RegExp object, and there is an entry in S that has one of the
     # following types at position i of its type list,
     # • an array type
     # • a sequence type
     # ...
     # • a dictionary
     #
     # FIXME:
     # We don't strictly follow the algorithm here. The algorithm says "remove
@@ skipping 367 matching lines @@
         deleter = next(
             method
             for method in interface.operations
             if ('deleter' in method.specials and
                 len(method.arguments) == 1 and
                 str(method.arguments[0].idl_type) == 'DOMString'))
     except StopIteration:
         return None
 
     return property_deleter(deleter)