Support named query generation

Source/bindings/scripts/CodeGeneratorV8.pm

 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006 Apple Computer, Inc.
 # Copyright (C) 2007, 2008, 2009, 2012 Google Inc.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 # Copyright (C) 2012 Ericsson AB. All rights reserved.
@@ skipping 3175 matching lines @@
 
     my $indexedDeleterFunction = GetIndexedDeleterFunction($interface);
     my $hasCustomIndexedDeleter = $indexedDeleterFunction ? $indexedDeleterFunction->extendedAttributes->{"Custom"} : 0;
     if ($indexedDeleterFunction && !$hasCustomIndexedDeleter) {
         GenerateImplementationIndexedPropertyDeleter($interface, $indexedDeleterFunction);
     }
 
     my $indexedEnumeratorFunction = $indexedGetterFunction;
     $indexedEnumeratorFunction = 0 if $indexedGetterFunction && $indexedGetterFunction->extendedAttributes->{"NotEnumerable"};
 
-    # FIXME: Support generated named query bindings.
     my $indexedQueryFunction = 0;
     # If there is an enumerator, there MUST be a query method to properly communicate property attributes.
     my $hasQuery = $indexedQueryFunction || $indexedEnumeratorFunction;
 
     my $setOn = "Instance";
 
     # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on Window
     # instead of deleters or enumerators. In addition, the getter should be set on prototype template, to
     # get implementation straight out of the Window prototype regardless of what prototype is actually set
     # on the object.
@@ skipping 137 matching lines @@
     }
     my $hasDeleter = $namedDeleterFunction;
 
     my $namedEnumeratorFunction = $namedGetterFunction;
     $namedEnumeratorFunction = 0 if $namedGetterFunction && $namedGetterFunction->extendedAttributes->{"NotEnumerable"};
     my $hasCustomNamedEnumerator = 1 if $namedGetterFunction && $namedGetterFunction->extendedAttributes->{"CustomEnumerateProperty"};
     if ($namedEnumeratorFunction && !$hasCustomNamedEnumerator) {
         GenerateImplementationNamedPropertyEnumerator($interface);
     }
 
-    # FIXME: Support generated named query bindings.
-    my $namedQueryFunction = 0;
     # If there is an enumerator, there MUST be a query method to properly communicate property attributes.
-    my $hasQuery = $namedQueryFunction || $namedEnumeratorFunction;
+    my $hasQuery = $namedEnumeratorFunction;
+    my $hasCustomNamedQuery = $hasCustomNamedEnumerator;
+    if ($hasQuery && !$hasCustomNamedQuery) {
+        GenerateImplementationNamedPropertyQuery($interface);
+    }
 
     my $subCode = "";
     if ($namedGetterFunction || $namedSetterFunction || $namedDeleterFunction || $namedEnumeratorFunction || $hasQuery) {
         my $setOn = "Instance";
 
         # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on Window
         # instead of deleters or enumerators. In addition, the getter should be set on prototype template, to
         # get implementation straight out of the Window prototype regardless of what prototype is actually set
         # on the object.
         if ($interfaceName eq "Window") {
@@ skipping 268 matching lines @@
     }
     v8::Handle<v8::Array> v8names = v8::Array::New(names.size());
     for (size_t i = 0; i < names.size(); ++i)
         v8names->Set(v8Integer(i, info.GetIsolate()), v8String(names[i], info.GetIsolate()));
     v8SetReturnValue(info, v8names);
 }
 
 END
 }
 
+sub GenerateImplementationNamedPropertyQuery
+{
+    my $interface = shift;
+    my $implClassName = GetImplName($interface);
+    my $v8ClassName = GetV8ClassName($interface);
+
+    $implementation{nameSpaceWebCore}->add(<<END);
+void ${v8ClassName}::namedPropertyQuery(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info)
+{
+    ${implClassName}* collection = toNative(info.Holder());
+    AtomicString propertyName = toWebCoreAtomicString(name);
+    ExceptionCode ec = 0;
+    int returnValue = 0;
+    bool result = collection->namedPropertyQuery(propertyName, returnValue, ec);
+    if (ec) {
+        setDOMException(ec, info.GetIsolate());
+        return;
+    }
+    if (!result)
+        return;
+    v8SetReturnValueInt(info, 0);

[haraken, 2013/06/17 07:41:02]

0 => returnValue.

However, I might want to remove 'returnValue' from the namedPropertyQuery()
parameters and hard-code 'v8::None' here for the following reasons:

- Per the comment in v8.h, we should use v8::None instead of 0.
- However, we might not want to write v8::None in core/ (since whether we should
expose v8:: to core/ is controvertial).
- At this point, we cannot imagine any case where we want to return other than
0.

[kojih, 2013/06/17 07:52:57]

OK.

+}
+
+END
+}
+
 sub GenerateImplementationLegacyCall
 {
     my $interface = shift;
     my $code = "";
 
     my $v8ClassName = GetV8ClassName($interface);
 
     if ($interface->extendedAttributes->{"CustomLegacyCall"}) {
         $code .= "    desc->InstanceTemplate()->SetCallAsFunctionHandler(${v8ClassName}::legacyCallCustom);\n";
     }
@@ skipping 2222 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;