Made Isolate a mandatory parameter for everything Handle-related.

src/factory.cc

 // Copyright 2012 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 735 matching lines @@
   Handle<String> error_string = NewStringFromUtf8(CStrVector(buffer), TENURED);
   return error_string;
 }
 
 
 Handle<Object> Factory::NewError(const char* maker,
                                  const char* type,
                                  Handle<JSArray> args) {
   Handle<String> make_str = LookupUtf8Symbol(maker);
   Handle<Object> fun_obj(
-      isolate()->js_builtins_object()->GetPropertyNoExceptionThrown(*make_str));
+      isolate()->js_builtins_object()->GetPropertyNoExceptionThrown(*make_str),
+      isolate());
   // If the builtins haven't been properly configured yet this error
   // constructor may not have been defined.  Bail out.
   if (!fun_obj->IsJSFunction()) {
     return EmergencyNewError(type, args);
   }
   Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
   Handle<Object> type_obj = LookupUtf8Symbol(type);
   Handle<Object> argv[] = { type_obj, args };
 
   // Invoke the JavaScript factory method. If an exception is thrown while
@@ skipping 501 matching lines @@
       NewFunction(Factory::empty_symbol(),
                   type,
                   instance_size,
                   code,
                   true);
 
   // Set length.
   result->shared()->set_length(obj->length());
 
   // Set class name.
-  Handle<Object> class_name = Handle<Object>(obj->class_name());
+  Handle<Object> class_name = Handle<Object>(obj->class_name(), isolate());
   if (class_name->IsString()) {
     result->shared()->set_instance_class_name(*class_name);
     result->shared()->set_name(*class_name);
   }
 
   Handle<Map> map = Handle<Map>(result->initial_map());
 
   // Mark as undetectable if needed.
   if (obj->undetectable()) {
     map->set_is_undetectable();
@@ skipping 25 matching lines @@
   result->shared()->set_function_data(*obj);
   result->shared()->set_construct_stub(*construct_stub);
   result->shared()->DontAdaptArguments();
 
   // Recursively copy parent templates' accessors, 'data' may be modified.
   int max_number_of_additional_properties = 0;
   FunctionTemplateInfo* info = *obj;
   while (true) {
     Object* props = info->property_accessors();
     if (!props->IsUndefined()) {
-      Handle<Object> props_handle(props);
+      Handle<Object> props_handle(props, isolate());
       NeanderArray props_array(props_handle);
       max_number_of_additional_properties += props_array.length();
     }
     Object* parent = info->parent_template();
     if (parent->IsUndefined()) break;
     info = FunctionTemplateInfo::cast(parent);
   }
 
   Map::EnsureDescriptorSlack(map, max_number_of_additional_properties);
 
   while (true) {
-    Handle<Object> props = Handle<Object>(obj->property_accessors());
+    Handle<Object> props = Handle<Object>(obj->property_accessors(),
+                                          isolate());
     if (!props->IsUndefined()) {
       Map::AppendCallbackDescriptors(map, props);
     }
-    Handle<Object> parent = Handle<Object>(obj->parent_template());
+    Handle<Object> parent = Handle<Object>(obj->parent_template(), isolate());
     if (parent->IsUndefined()) break;
     obj = Handle<FunctionTemplateInfo>::cast(parent);
   }
 
   ASSERT(result->shared()->IsApiFunction());
   return result;
 }
 
 
 Handle<MapCache> Factory::NewMapCache(int at_least_space_for) {
@@ skipping 99 matching lines @@
 Handle<Object> Factory::GlobalConstantFor(Handle<String> name) {
   Heap* h = isolate()->heap();
   if (name->Equals(h->undefined_symbol())) return undefined_value();
   if (name->Equals(h->nan_symbol())) return nan_value();
   if (name->Equals(h->infinity_symbol())) return infinity_value();
   return Handle<Object>::null();
 }
 
 
 Handle<Object> Factory::ToBoolean(bool value) {
-  return Handle<Object>(value
-                        ? isolate()->heap()->true_value()
-                        : isolate()->heap()->false_value());
+  Heap* heap = isolate()->heap();
+  Object* obj = value ? heap->true_value() : heap->false_value();
+  return Handle<Object>(obj, isolate());

[Michael Starzinger, 2013/02/25 10:50:58]

This can be simplified to "return value ? true_value() : false_value();"

[Sven Panne, 2013/02/25 14:44:43]

Done.

 }
 
 
 } }  // namespace v8::internal