Use correct trap for lookup in prototype proxy.

src/objects.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2011 matching lines @@
       LookupCallbackSetterInPrototypes(name, &accessor_result);
       if (accessor_result.IsFound()) {
         if (accessor_result.type() == CALLBACKS) {
           return SetPropertyWithCallback(accessor_result.GetCallbackObject(),
                                          name,
                                          value,
                                          accessor_result.holder(),
                                          strict_mode);
         } else if (accessor_result.type() == HANDLER) {
           // There is a proxy in the prototype chain. Invoke its
-          // getOwnPropertyDescriptor trap.
+          // getPropertyDescriptor trap.
           bool found = false;
           // SetPropertyWithHandlerIfDefiningSetter can cause GC,
           // make sure to use the handlified references after calling
           // the function.
           Handle<JSObject> self(this);
           Handle<String> hname(name);
           Handle<Object> hvalue(value);
           MaybeObject* result =
               accessor_result.proxy()->SetPropertyWithHandlerIfDefiningSetter(
                   name, value, attributes, strict_mode, &found);
@@ skipping 398 matching lines @@
     PropertyAttributes attributes,
     StrictModeFlag strict_mode,
     bool* found) {
   *found = true;  // except where defined otherwise...
   Isolate* isolate = GetHeap()->isolate();
   Handle<JSProxy> proxy(this);
   Handle<String> name(name_raw);
   Handle<Object> value(value_raw);
   Handle<Object> args[] = { name };
   Handle<Object> result = proxy->CallTrap(
-      "getOwnPropertyDescriptor", Handle<Object>(), ARRAY_SIZE(args), args);
+      "getPropertyDescriptor", Handle<Object>(), ARRAY_SIZE(args), args);
   if (isolate->has_pending_exception()) return Failure::Exception();
 
   if (!result->IsUndefined()) {
     // The proxy handler cares about this property.
     // Check whether it is virtualized as an accessor.
     // Emulate [[GetProperty]] semantics for proxies.
     bool has_pending_exception;
     Object** argv[] = { result.location() };
     Handle<Object> desc =
         Execution::Call(isolate->to_complete_property_descriptor(), result,
@@ skipping 9718 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single break point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal