Pass the invoked JavaScript method name as an argument to the fallback callback

webkit/glue/cpp_bound_class.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file contains definitions for CppBoundClass
 
 // Here's the control flow of a JS method getting forwarded to a class.
 // - Something calls our NPObject with a function like "Invoke".
 // - CppNPObject's static invoke() function forwards it to its attached
 //   CppBoundClass's Invoke() method.
@@ skipping 136 matching lines @@
   for (BoundObjectList::iterator i = bound_objects_.begin(); 
       i != bound_objects_.end(); ++i) {
 #if USE(V8)
     _NPN_UnregisterObject(*i);
 #endif
     NPN_ReleaseObject(*i);
   }
 }
 
 bool CppBoundClass::HasMethod(NPIdentifier ident) {
-  return (methods_.find(ident) != methods_.end());
+  return (methods_.find(ident) != methods_.end() || fallback_callback_.get());

[Evan Martin, 2008/10/07 18:26:42]

I spoke with Feng.  This is the only line we have a problem with.  I'm sure we
used to have this and had to remove it for some reason, but neither Feng nor I
can remember why.  Do you really need this, or were you just trying to make it
match the the HasMethod() docs?

 }
 
 bool CppBoundClass::HasProperty(NPIdentifier ident) {
   return (properties_.find(ident) != properties_.end());
 }
 
 bool CppBoundClass::Invoke(NPIdentifier ident, 
                               const NPVariant* args,
                               size_t arg_count, 
                               NPVariant* result) {
   MethodList::const_iterator method = methods_.find(ident);
   Callback* callback;
+  bool inject_method_name = false;
   if (method == methods_.end()) {
     if (fallback_callback_.get()) {
       callback = fallback_callback_.get();
+      inject_method_name = true;
     } else {
       VOID_TO_NPVARIANT(*result);
       return false;
     }
   } else {
     callback = (*method).second;
   }
 
   // Build a CppArgumentList argument vector from the NPVariants coming in.
-  CppArgumentList cpp_args(arg_count);
-  for (size_t i = 0; i < arg_count; i++)
-    cpp_args[i].Set(args[i]);
+  size_t arg_offset = (inject_method_name ? 1 : 0);
+  CppArgumentList cpp_args(arg_count + arg_offset);
+  for (size_t i = arg_offset; i < arg_count + arg_offset; i++)
+    cpp_args[i].Set(args[i - arg_offset]);
+
+  // If the fallback is being called pass the JavaScript method name as the
+  // first argument.
+  if (inject_method_name) {
+    NPUTF8* name = NPN_UTF8FromIdentifier(ident);
+    cpp_args[0].Set(name);
+    free(name);
+  }
 
   CppVariant cpp_result;
   callback->Run(cpp_args, &cpp_result);
 
   cpp_result.CopyToNPVariant(result);
   return true;
 }
 
 bool CppBoundClass::GetProperty(NPIdentifier ident, NPVariant* result) {
   PropertyList::const_iterator prop = properties_.find(ident);
@@ skipping 51 matching lines @@
   NPObject* np_obj = NPN_CreateObject(0, &CppNPObject::np_class_);
   CppNPObject* obj = reinterpret_cast<CppNPObject*>(np_obj);
   obj->bound_class = this;
 
   // BindToWindowObject will (indirectly) retain the np_object. We save it
   // so we can release it when we're destroyed.
   frame->BindToWindowObject(classname, np_obj);
   bound_objects_.push_back(np_obj);
 }