Use correct LookupIterator in CallSite::GetMethodName.

src/messages.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/execution.h"
 #include "src/heap/spaces-inl.h"
 #include "src/messages.h"
@@ skipping 157 matching lines @@
   if (script_obj->IsScript()) {
     Handle<Script> script = Handle<Script>::cast(script_obj);
     Object* source_url = script->source_url();
     if (source_url->IsString()) return Handle<Object>(source_url, isolate);
     return Handle<Object>(script->name(), isolate);
   }
   return isolate->factory()->null_value();
 }
 
 
-bool CheckMethodName(Handle<JSObject> obj, Handle<Name> name,
+bool CheckMethodName(Isolate* isolate, Handle<JSObject> obj, Handle<Name> name,
                      Handle<JSFunction> fun,
                      LookupIterator::Configuration config) {
-  LookupIterator iter(obj, name, config);
+  LookupIterator iter =
+      LookupIterator::PropertyOrElement(isolate, obj, name, config);
   if (iter.state() == LookupIterator::DATA) {
     return iter.GetDataValue().is_identical_to(fun);
   } else if (iter.state() == LookupIterator::ACCESSOR) {
     Handle<Object> accessors = iter.GetAccessors();
     if (accessors->IsAccessorPair()) {
       Handle<AccessorPair> pair = Handle<AccessorPair>::cast(accessors);
       return pair->getter() == *fun || pair->setter() == *fun;
     }
   }
   return false;
 }
 
 
 Handle<Object> CallSite::GetMethodName(Isolate* isolate) {
   MaybeHandle<JSReceiver> maybe = Object::ToObject(isolate, receiver_);
   Handle<JSReceiver> receiver;
   if (!maybe.ToHandle(&receiver) || !receiver->IsJSObject()) {
     return isolate->factory()->null_value();
   }
 
   Handle<JSObject> obj = Handle<JSObject>::cast(receiver);
   Handle<Object> function_name(fun_->shared()->name(), isolate);
   if (function_name->IsName()) {
     Handle<Name> name = Handle<Name>::cast(function_name);
-    if (CheckMethodName(obj, name, fun_,
+    if (CheckMethodName(isolate, obj, name, fun_,
                         LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR))
       return name;
   }
 
   HandleScope outer_scope(isolate);
   Handle<Object> result;
   for (PrototypeIterator iter(isolate, obj,
                               PrototypeIterator::START_AT_RECEIVER);
        !iter.IsAtEnd(); iter.Advance()) {
     Handle<Object> current = PrototypeIterator::GetCurrent(iter);
     if (!current->IsJSObject()) break;
     Handle<JSObject> current_obj = Handle<JSObject>::cast(current);
     if (current_obj->IsAccessCheckNeeded()) break;
     Handle<FixedArray> keys = JSObject::GetEnumPropertyKeys(current_obj, false);
     for (int i = 0; i < keys->length(); i++) {
       HandleScope inner_scope(isolate);
       if (!keys->get(i)->IsName()) continue;
       Handle<Name> name_key(Name::cast(keys->get(i)), isolate);
-      if (!CheckMethodName(current_obj, name_key, fun_,
+      if (!CheckMethodName(isolate, current_obj, name_key, fun_,
                            LookupIterator::OWN_SKIP_INTERCEPTOR))
         continue;
       // Return null in case of duplicates to avoid confusion.
       if (!result.is_null()) return isolate->factory()->null_value();
       result = inner_scope.CloseAndEscape(name_key);
     }
   }
 
   if (!result.is_null()) return outer_scope.CloseAndEscape(result);
   return isolate->factory()->null_value();
@@ skipping 137 matching lines @@
       }
     } else {
       builder.AppendCharacter(*c);
     }
   }
 
   return builder.Finish();
 }
 }  // namespace internal
 }  // namespace v8