Minor LookupIterator cleanups

src/lookup.cc

 // Copyright 2014 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/bootstrapper.h"
 #include "src/deoptimizer.h"
 #include "src/lookup.h"
 #include "src/lookup-inl.h"
@@ skipping 17 matching lines @@
     JSReceiver* maybe_holder = NextHolder(map);
     if (maybe_holder == NULL) break;
     holder = maybe_holder;
     map = holder->map();
     state_ = LookupInHolder(map);
   }
 
   // Either was found in the receiver, or the receiver has no prototype.
   if (holder == NULL) return;
 
-  maybe_holder_ = handle(holder);
-  holder_map_ = handle(map);
+  maybe_holder_ = handle(holder, isolate_);
+  holder_map_ = handle(map, isolate_);
 }
 
 
 Handle<JSReceiver> LookupIterator::GetRoot() const {
   Handle<Object> receiver = GetReceiver();
   if (receiver->IsJSReceiver()) return Handle<JSReceiver>::cast(receiver);
   Handle<Object> root =
       handle(receiver->GetRootMap(isolate_)->prototype(), isolate_);
   CHECK(!root->IsNull());
   return Handle<JSReceiver>::cast(root);
 }
 
 
 Handle<Map> LookupIterator::GetReceiverMap() const {
   Handle<Object> receiver = GetReceiver();
   if (receiver->IsNumber()) return isolate_->factory()->heap_number_map();
-  return handle(Handle<HeapObject>::cast(receiver)->map());
+  return handle(Handle<HeapObject>::cast(receiver)->map(), isolate_);
 }
 
 
 Handle<JSObject> LookupIterator::GetStoreTarget() const {
   Handle<JSObject> receiver = Handle<JSObject>::cast(GetReceiver());
 
   if (receiver->IsJSGlobalProxy()) {
     PrototypeIterator iter(isolate(), receiver);
     if (iter.IsAtEnd()) return receiver;
     return Handle<JSGlobalObject>::cast(PrototypeIterator::GetCurrent(iter));
@@ skipping 110 matching lines @@
   // handled via a trap. Adding properties to primitive values is not
   // observable.
   Handle<JSObject> receiver = GetStoreTarget();
 
   if (!name().is_identical_to(isolate()->factory()->hidden_string()) &&
       !receiver->map()->is_extensible()) {
     return;
   }
 
   transition_map_ = Map::TransitionToDataProperty(
-      handle(receiver->map()), name_, value, attributes, store_mode);
+      handle(receiver->map(), isolate_), name_, value, attributes, store_mode);
   state_ = TRANSITION;
 }
 
 
 void LookupIterator::ApplyTransitionToDataProperty() {
   DCHECK_EQ(TRANSITION, state_);
 
   Handle<JSObject> receiver = GetStoreTarget();
   maybe_holder_ = receiver;
   holder_map_ = transition_map_;
   JSObject::MigrateToMap(receiver, holder_map_);
   ReloadPropertyInformation();
 }
 
 
 void LookupIterator::TransitionToAccessorProperty(
     AccessorComponent component, Handle<Object> accessor,
     PropertyAttributes attributes) {
   DCHECK(!accessor->IsNull());
   // Can only be called when the receiver is a JSObject. JSProxy has to be
   // handled via a trap. Adding properties to primitive values is not
   // observable.
   Handle<JSObject> receiver = GetStoreTarget();
   maybe_holder_ = receiver;
-  holder_map_ = Map::TransitionToAccessorProperty(
-      handle(receiver->map()), name_, component, accessor, attributes);
+  holder_map_ =
+      Map::TransitionToAccessorProperty(handle(receiver->map(), isolate_),
+                                        name_, component, accessor, attributes);
   JSObject::MigrateToMap(receiver, holder_map_);
 
   ReloadPropertyInformation();
 
   if (!holder_map_->is_dictionary_map()) return;
 
   // We have to deoptimize since accesses to data properties may have been
   // inlined without a corresponding map-check.
   if (holder_map_->IsGlobalObjectMap()) {
     Deoptimizer::DeoptimizeGlobalObject(*receiver);
@@ skipping 12 matching lines @@
       pair = AccessorPair::Copy(pair);
       pair->set(component, *accessor);
     }
   } else {
     pair = isolate()->factory()->NewAccessorPair();
     pair->set(component, *accessor);
   }
   JSObject::SetNormalizedProperty(receiver, name_, pair, details);
 
   JSObject::ReoptimizeIfPrototype(receiver);
-  holder_map_ = handle(receiver->map());
+  holder_map_ = handle(receiver->map(), isolate_);
   ReloadPropertyInformation();
 }
 
 
 bool LookupIterator::HolderIsReceiverOrHiddenPrototype() const {
   DCHECK(has_property_ || state_ == INTERCEPTOR || state_ == JSPROXY);
   // Optimization that only works if configuration_ is not mutable.
   if (!check_derived()) return true;
   DisallowHeapAllocation no_gc;
   Handle<Object> receiver = GetReceiver();
@@ skipping 119 matching lines @@
     DCHECK_EQ(v8::internal::CONSTANT, property_details_.type());
   }
 }
 
 
 void LookupIterator::InternalizeName() {
   if (name_->IsUniqueName()) return;
   name_ = factory()->InternalizeString(Handle<String>::cast(name_));
 }
 } }  // namespace v8::internal