Version 3.5.6.

src/liveobjectlist.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 18 matching lines @@
 
 #include <ctype.h>
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "checks.h"
 #include "global-handles.h"
 #include "heap.h"
 #include "inspector.h"
+#include "isolate.h"
 #include "list-inl.h"
 #include "liveobjectlist-inl.h"
 #include "string-stream.h"
-#include "top.h"
 #include "v8utils.h"
+#include "v8conversions.h"
 
 namespace v8 {
 namespace internal {
 
 
 typedef int (*RawComparer)(const void*, const void*);
 
 
 #ifdef CHECK_ALL_OBJECT_TYPES
 
@@ skipping 48 matching lines @@
   v(JSRegExp, "JSRegExp") \
   v(JSFunction, "JSFunction") \
   v(JSGlobalObject, "JSGlobal") \
   v(JSBuiltinsObject, "JSBuiltins") \
   v(GlobalObject, "Global") \
   v(JSGlobalProxy, "JSGlobalProxy") \
   v(JSObject, "JSObject") \
   \
   v(Context, "meta: Context") \
   v(ByteArray, "meta: ByteArray") \
-  v(PixelArray, "meta: PixelArray") \
+  v(ExternalPixelArray, "meta: PixelArray") \
   v(ExternalArray, "meta: ExternalArray") \
   v(FixedArray, "meta: FixedArray") \
   v(String, "String") \
   v(HeapNumber, "HeapNumber") \
   \
   v(Code, "meta: Code") \
   v(Map, "meta: Map") \
   v(Oddball, "Oddball") \
   v(Foreign, "meta: Foreign") \
   v(SharedFunctionInfo, "meta: SharedFunctionInfo") \
@@ skipping 81 matching lines @@
     case 'o':
       if (strcmp(key_str, "old-pointer") == 0) return OLD_POINTER_SPACE;
       if (strcmp(key_str, "old-data") == 0) return OLD_DATA_SPACE;
       break;
   }
   return kInvalidSpace;
 }
 
 
 static bool InSpace(AllocationSpace space, HeapObject *heap_obj) {
+  Heap* heap = ISOLATE->heap();
   if (space != LO_SPACE) {
-    return Heap::InSpace(heap_obj, space);
+    return heap->InSpace(heap_obj, space);
   }
 
   // This is an optimization to speed up the check for an object in the LO
   // space by exclusion because we know that all object pointers passed in
   // here are guaranteed to be in the heap.  Hence, it is safe to infer
   // using an exclusion test.
   // Note: calling Heap::InSpace(heap_obj, LO_SPACE) is too slow for our
   // filters.
   int first_space = static_cast<int>(FIRST_SPACE);
   int last_space = static_cast<int>(LO_SPACE);
   for (int sp = first_space; sp < last_space; sp++) {
-    if (Heap::InSpace(heap_obj, static_cast<AllocationSpace>(sp))) {
+    if (heap->InSpace(heap_obj, static_cast<AllocationSpace>(sp))) {
       return false;
     }
   }
-  SLOW_ASSERT(Heap::InSpace(heap_obj, LO_SPACE));
+  SLOW_ASSERT(heap->InSpace(heap_obj, LO_SPACE));
   return true;
 }
 
 
 static LiveObjectType FindTypeFor(String* type_str) {
   SmartPointer<char> s =
       type_str->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
 
 #define CHECK_OBJECT_TYPE(type_, name) { \
     const char* type_desc = GetObjectTypeDesc(kType##type_); \
@@ skipping 36 matching lines @@
       prop_() {
   if (filter_obj.is_null()) return;
 
   InitTypeFilter(filter_obj);
   InitSpaceFilter(filter_obj);
   InitPropertyFilter(filter_obj);
 }
 
 
 void LolFilter::InitTypeFilter(Handle<JSObject> filter_obj) {
-  Handle<String> type_sym = Factory::LookupAsciiSymbol("type");
+  Handle<String> type_sym = FACTORY->LookupAsciiSymbol("type");
   MaybeObject* maybe_result = filter_obj->GetProperty(*type_sym);
   Object* type_obj;
   if (maybe_result->ToObject(&type_obj)) {
     if (type_obj->IsString()) {
       String* type_str = String::cast(type_obj);
       type_ = FindTypeFor(type_str);
       if (type_ != kInvalidLiveObjType) {
         is_active_ = true;
       }
     }
   }
 }
 
 
 void LolFilter::InitSpaceFilter(Handle<JSObject> filter_obj) {
-  Handle<String> space_sym = Factory::LookupAsciiSymbol("space");
+  Handle<String> space_sym = FACTORY->LookupAsciiSymbol("space");
   MaybeObject* maybe_result = filter_obj->GetProperty(*space_sym);
   Object* space_obj;
   if (maybe_result->ToObject(&space_obj)) {
     if (space_obj->IsString()) {
       String* space_str = String::cast(space_obj);
       space_ = FindSpaceFor(space_str);
       if (space_ != kInvalidSpace) {
         is_active_ = true;
       }
     }
   }
 }
 
 
 void LolFilter::InitPropertyFilter(Handle<JSObject> filter_obj) {
-  Handle<String> prop_sym = Factory::LookupAsciiSymbol("prop");
+  Handle<String> prop_sym = FACTORY->LookupAsciiSymbol("prop");
   MaybeObject* maybe_result = filter_obj->GetProperty(*prop_sym);
   Object* prop_obj;
   if (maybe_result->ToObject(&prop_obj)) {
     if (prop_obj->IsString()) {
       prop_ = Handle<String>(String::cast(prop_obj));
       is_active_ = true;
     }
   }
 }
 
@@ skipping 233 matching lines @@
                          int index,
                          int obj_id,
                          Handle<HeapObject> target,
                          const char* desc_str,
                          Handle<String> id_sym,
                          Handle<String> desc_sym,
                          Handle<String> size_sym,
                          Handle<JSObject> detail,
                          Handle<String> desc,
                          Handle<Object> error) {
-  detail = Factory::NewJSObject(Top::object_function());
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  detail = factory->NewJSObject(isolate->object_function());
   if (detail->IsFailure()) {
     error = detail;
     return false;
   }
 
   int size = 0;
   char buffer[512];
   if (desc_str == NULL) {
     ASSERT(!target.is_null());
     HeapObject* obj = *target;
     GenerateObjectDesc(obj, buffer, sizeof(buffer));
     desc_str = buffer;
     size = obj->Size();
   }
-  desc = Factory::NewStringFromAscii(CStrVector(desc_str));
+  desc = factory->NewStringFromAscii(CStrVector(desc_str));
   if (desc->IsFailure()) {
     error = desc;
     return false;
   }
 
   { MaybeObject* maybe_result = detail->SetProperty(*id_sym,
                                                     Smi::FromInt(obj_id),
                                                     NONE,
                                                     kNonStrictMode);
     if (maybe_result->IsFailure()) return false;
@@ skipping 56 matching lines @@
   bool Write(Handle<FixedArray> elements_arr,
              int start,
              int dump_limit,
              LolFilter* filter,
              Handle<Object> error) {
     // The lols are listed in latest to earliest.  We want to dump from
     // earliest to latest.  So, compute the last element to start with.
     int index = 0;
     int count = 0;
 
+    Isolate* isolate = Isolate::Current();
+    Factory* factory = isolate->factory();
+
     // Prefetch some needed symbols.
-    Handle<String> id_sym = Factory::LookupAsciiSymbol("id");
-    Handle<String> desc_sym = Factory::LookupAsciiSymbol("desc");
-    Handle<String> size_sym = Factory::LookupAsciiSymbol("size");
+    Handle<String> id_sym = factory->LookupAsciiSymbol("id");
+    Handle<String> desc_sym = factory->LookupAsciiSymbol("desc");
+    Handle<String> size_sym = factory->LookupAsciiSymbol("size");
 
     // Fill the array with the lol object details.
     Handle<JSObject> detail;
     Handle<String> desc;
     Handle<HeapObject> target;
 
     LiveObjectList* first_lol = (older_ != NULL) ?
                                 older_->next_ : LiveObjectList::first_;
     LiveObjectList* last_lol = (newer_ != NULL) ? newer_->next_ : NULL;
 
@@ skipping 402 matching lines @@
   HeapObject* heap_obj = NULL;
   while ((heap_obj = iterator.next()) != NULL) {
     count++;
   }
   return count;
 }
 
 
 // Captures a current snapshot of all objects in the heap.
 MaybeObject* LiveObjectList::Capture() {
-  HandleScope scope;
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  HandleScope scope(isolate);
 
   // Count the number of objects in the heap.
   int total_count = CountHeapObjects();
   int count = total_count;
   int size = 0;
 
   LiveObjectList* last_lol = last();
   if (last_lol != NULL) {
     count -= last_lol->TotalObjCount();
   }
@@ skipping 29 matching lines @@
     }
     last_ = lol;
 
 #ifdef VERIFY_LOL
     if (FLAG_verify_lol) {
       Verify(true);
     }
 #endif
   }
 
-  Handle<String> id_sym = Factory::LookupAsciiSymbol("id");
-  Handle<String> count_sym = Factory::LookupAsciiSymbol("count");
-  Handle<String> size_sym = Factory::LookupAsciiSymbol("size");
+  Handle<String> id_sym = factory->LookupAsciiSymbol("id");
+  Handle<String> count_sym = factory->LookupAsciiSymbol("count");
+  Handle<String> size_sym = factory->LookupAsciiSymbol("size");
 
-  Handle<JSObject> result = Factory::NewJSObject(Top::object_function());
+  Handle<JSObject> result = factory->NewJSObject(isolate->object_function());
   if (result->IsFailure()) return Object::cast(*result);
 
   { MaybeObject* maybe_result = result->SetProperty(*id_sym,
                                                     Smi::FromInt(lol->id()),
                                                     NONE,
                                                     kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
   }
   { MaybeObject* maybe_result = result->SetProperty(*count_sym,
                                                     Smi::FromInt(total_count),
@@ skipping 95 matching lines @@
   LolFilter filter(filter_obj);
   LolDumpWriter writer(older_lol, newer_lol);
   return DumpPrivate(&writer, start_idx, dump_limit, &filter);
 }
 
 
 MaybeObject* LiveObjectList::DumpPrivate(DumpWriter* writer,
                                          int start,
                                          int dump_limit,
                                          LolFilter* filter) {
-  HandleScope scope;
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+
+  HandleScope scope(isolate);
 
   // Calculate the number of entries of the dump.
   int count = -1;
   int size = -1;
   writer->ComputeTotalCountAndSize(filter, &count, &size);
 
   // Adjust for where to start the dump.
   if ((start < 0) || (start >= count)) {
     return Failure::Exception();  // invalid start.
   }
 
   int remaining_count = count - start;
   if (dump_limit > remaining_count) {
     dump_limit = remaining_count;
   }
 
   // Allocate an array to hold the result.
-  Handle<FixedArray> elements_arr = Factory::NewFixedArray(dump_limit);
+  Handle<FixedArray> elements_arr = factory->NewFixedArray(dump_limit);
   if (elements_arr->IsFailure()) return Object::cast(*elements_arr);
 
   // Fill in the dump.
   Handle<Object> error;
   bool success = writer->Write(elements_arr,
                                start,
                                dump_limit,
                                filter,
                                error);
   if (!success) return Object::cast(*error);
 
   MaybeObject* maybe_result;
 
   // Allocate the result body.
-  Handle<JSObject> body = Factory::NewJSObject(Top::object_function());
+  Handle<JSObject> body = factory->NewJSObject(isolate->object_function());
   if (body->IsFailure()) return Object::cast(*body);
 
   // Set the updated body.count.
-  Handle<String> count_sym = Factory::LookupAsciiSymbol("count");
+  Handle<String> count_sym = factory->LookupAsciiSymbol("count");
   maybe_result = body->SetProperty(*count_sym,
                                    Smi::FromInt(count),
                                    NONE,
                                    kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   // Set the updated body.size if appropriate.
   if (size >= 0) {
-    Handle<String> size_sym = Factory::LookupAsciiSymbol("size");
+    Handle<String> size_sym = factory->LookupAsciiSymbol("size");
     maybe_result = body->SetProperty(*size_sym,
                                      Smi::FromInt(size),
                                      NONE,
                                      kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
   }
 
   // Set body.first_index.
-  Handle<String> first_sym = Factory::LookupAsciiSymbol("first_index");
+  Handle<String> first_sym = factory->LookupAsciiSymbol("first_index");
   maybe_result = body->SetProperty(*first_sym,
                                    Smi::FromInt(start),
                                    NONE,
                                    kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   // Allocate the JSArray of the elements.
-  Handle<JSObject> elements = Factory::NewJSObject(Top::array_function());
+  Handle<JSObject> elements = factory->NewJSObject(isolate->array_function());
   if (elements->IsFailure()) return Object::cast(*elements);
   Handle<JSArray>::cast(elements)->SetContent(*elements_arr);
 
   // Set body.elements.
-  Handle<String> elements_sym = Factory::LookupAsciiSymbol("elements");
+  Handle<String> elements_sym = factory->LookupAsciiSymbol("elements");
   maybe_result = body->SetProperty(*elements_sym,
                                    *elements,
                                    NONE,
                                    kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   return *body;
 }
 
 
@@ skipping 33 matching lines @@
 // the summary.
 MaybeObject* LiveObjectList::SummarizePrivate(SummaryWriter* writer,
                                               LolFilter* filter,
                                               bool is_tracking_roots) {
   HandleScope scope;
   MaybeObject* maybe_result;
 
   LiveObjectSummary summary(filter);
   writer->Write(&summary);
 
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+
   // The result body will look like this:
   // body: {
   //   count: <total_count>,
   //   size: <total_size>,
   //   found_root: <boolean>,       // optional.
   //   found_weak_root: <boolean>,  // optional.
   //   summary: [
   //     {
   //       desc: "<object type name>",
   //       count: <count>,
   //       size: size
   //     },
   //     ...
   //   ]
   // }
 
   // Prefetch some needed symbols.
-  Handle<String> desc_sym = Factory::LookupAsciiSymbol("desc");
-  Handle<String> count_sym = Factory::LookupAsciiSymbol("count");
-  Handle<String> size_sym = Factory::LookupAsciiSymbol("size");
-  Handle<String> summary_sym = Factory::LookupAsciiSymbol("summary");
+  Handle<String> desc_sym = factory->LookupAsciiSymbol("desc");
+  Handle<String> count_sym = factory->LookupAsciiSymbol("count");
+  Handle<String> size_sym = factory->LookupAsciiSymbol("size");
+  Handle<String> summary_sym = factory->LookupAsciiSymbol("summary");
 
   // Allocate the summary array.
   int entries_count = summary.GetNumberOfEntries();
   Handle<FixedArray> summary_arr =
-      Factory::NewFixedArray(entries_count);
+      factory->NewFixedArray(entries_count);
   if (summary_arr->IsFailure()) return Object::cast(*summary_arr);
 
   int idx = 0;
   for (int i = 0; i < LiveObjectSummary::kNumberOfEntries; i++) {
     // Allocate the summary record.
-    Handle<JSObject> detail = Factory::NewJSObject(Top::object_function());
+    Handle<JSObject> detail = factory->NewJSObject(isolate->object_function());
     if (detail->IsFailure()) return Object::cast(*detail);
 
     // Fill in the summary record.
     LiveObjectType type = static_cast<LiveObjectType>(i);
     int count = summary.Count(type);
     if (count) {
       const char* desc_cstr = GetObjectTypeDesc(type);
-      Handle<String> desc = Factory::LookupAsciiSymbol(desc_cstr);
+      Handle<String> desc = factory->LookupAsciiSymbol(desc_cstr);
       int size = summary.Size(type);
 
       maybe_result = detail->SetProperty(*desc_sym,
                                          *desc,
                                          NONE,
                                          kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
       maybe_result = detail->SetProperty(*count_sym,
                                          Smi::FromInt(count),
                                          NONE,
                                          kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
       maybe_result = detail->SetProperty(*size_sym,
                                          Smi::FromInt(size),
                                          NONE,
                                          kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
 
       summary_arr->set(idx++, *detail);
     }
   }
 
   // Wrap the summary fixed array in a JS array.
-  Handle<JSObject> summary_obj = Factory::NewJSObject(Top::array_function());
+  Handle<JSObject> summary_obj =
+    factory->NewJSObject(isolate->array_function());
   if (summary_obj->IsFailure()) return Object::cast(*summary_obj);
   Handle<JSArray>::cast(summary_obj)->SetContent(*summary_arr);
 
   // Create the body object.
-  Handle<JSObject> body = Factory::NewJSObject(Top::object_function());
+  Handle<JSObject> body = factory->NewJSObject(isolate->object_function());
   if (body->IsFailure()) return Object::cast(*body);
 
   // Fill out the body object.
   int total_count = summary.total_count();
   int total_size = summary.total_size();
   maybe_result = body->SetProperty(*count_sym,
                                    Smi::FromInt(total_count),
                                    NONE,
                                    kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   maybe_result = body->SetProperty(*size_sym,
                                    Smi::FromInt(total_size),
                                    NONE,
                                    kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   if (is_tracking_roots) {
     int found_root = summary.found_root();
     int found_weak_root = summary.found_weak_root();
-    Handle<String> root_sym = Factory::LookupAsciiSymbol("found_root");
+    Handle<String> root_sym = factory->LookupAsciiSymbol("found_root");
     Handle<String> weak_root_sym =
-        Factory::LookupAsciiSymbol("found_weak_root");
+        factory->LookupAsciiSymbol("found_weak_root");
     maybe_result = body->SetProperty(*root_sym,
                                      Smi::FromInt(found_root),
                                      NONE,
                                      kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
     maybe_result = body->SetProperty(*weak_root_sym,
                                      Smi::FromInt(found_weak_root),
                                      NONE,
                                      kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
   }
 
   maybe_result = body->SetProperty(*summary_sym,
                                    *summary_obj,
                                    NONE,
                                    kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   return *body;
 }
 
 
 // Returns an array listing the captured lols.
 // Note: only dumps the section starting at start_idx and only up to
 // dump_limit entries.
 MaybeObject* LiveObjectList::Info(int start_idx, int dump_limit) {
-  HandleScope scope;
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+
+  HandleScope scope(isolate);
   MaybeObject* maybe_result;
 
   int total_count = LiveObjectList::list_count();
   int dump_count = total_count;
 
   // Adjust for where to start the dump.
   if (total_count == 0) {
       start_idx = 0;  // Ensure this to get an empty list.
   } else if ((start_idx < 0) || (start_idx >= total_count)) {
     return Failure::Exception();  // invalid start.
   }
   dump_count -= start_idx;
 
   // Adjust for the dump limit.
   if (dump_count > dump_limit) {
     dump_count = dump_limit;
   }
 
   // Allocate an array to hold the result.
-  Handle<FixedArray> list = Factory::NewFixedArray(dump_count);
+  Handle<FixedArray> list = factory->NewFixedArray(dump_count);
   if (list->IsFailure()) return Object::cast(*list);
 
   // Prefetch some needed symbols.
-  Handle<String> id_sym = Factory::LookupAsciiSymbol("id");
-  Handle<String> count_sym = Factory::LookupAsciiSymbol("count");
-  Handle<String> size_sym = Factory::LookupAsciiSymbol("size");
+  Handle<String> id_sym = factory->LookupAsciiSymbol("id");
+  Handle<String> count_sym = factory->LookupAsciiSymbol("count");
+  Handle<String> size_sym = factory->LookupAsciiSymbol("size");
 
   // Fill the array with the lol details.
   int idx = 0;
   LiveObjectList* lol = first_;
   while ((lol != NULL) && (idx < start_idx)) {  // Skip tail entries.
     if (lol->id() != 0) {
       idx++;
     }
     lol = lol->next();
   }
   idx = 0;
   while ((lol != NULL) && (dump_limit != 0)) {
     if (lol->id() != 0) {
       int count;
       int size;
       count = lol->GetTotalObjCountAndSize(&size);
 
-      Handle<JSObject> detail = Factory::NewJSObject(Top::object_function());
+      Handle<JSObject> detail =
+          factory->NewJSObject(isolate->object_function());
       if (detail->IsFailure()) return Object::cast(*detail);
 
       maybe_result = detail->SetProperty(*id_sym,
                                          Smi::FromInt(lol->id()),
                                          NONE,
                                          kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
       maybe_result = detail->SetProperty(*count_sym,
                                          Smi::FromInt(count),
                                          NONE,
                                          kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
       maybe_result = detail->SetProperty(*size_sym,
                                          Smi::FromInt(size),
                                          NONE,
                                          kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
       list->set(idx++, *detail);
       dump_limit--;
     }
     lol = lol->next();
   }
 
   // Return the result as a JS array.
-  Handle<JSObject> lols = Factory::NewJSObject(Top::array_function());
+  Handle<JSObject> lols = factory->NewJSObject(isolate->array_function());
   Handle<JSArray>::cast(lols)->SetContent(*list);
 
-  Handle<JSObject> result = Factory::NewJSObject(Top::object_function());
+  Handle<JSObject> result = factory->NewJSObject(isolate->object_function());
   if (result->IsFailure()) return Object::cast(*result);
 
   maybe_result = result->SetProperty(*count_sym,
                                      Smi::FromInt(total_count),
                                      NONE,
                                      kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
-  Handle<String> first_sym = Factory::LookupAsciiSymbol("first_index");
+  Handle<String> first_sym = factory->LookupAsciiSymbol("first_index");
   maybe_result = result->SetProperty(*first_sym,
                                      Smi::FromInt(start_idx),
                                      NONE,
                                      kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
-  Handle<String> lists_sym = Factory::LookupAsciiSymbol("lists");
+  Handle<String> lists_sym = factory->LookupAsciiSymbol("lists");
   maybe_result = result->SetProperty(*lists_sym,
                                      *lols,
                                      NONE,
                                      kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   return *result;
 }
 
 
@@ skipping 10 matching lines @@
   last_ = NULL;
 }
 
 
 // Gets the object for the specified obj id.
 Object* LiveObjectList::GetObj(int obj_id) {
   Element* element = FindElementFor<int>(GetElementId, obj_id);
   if (element != NULL) {
     return Object::cast(element->obj_);
   }
-  return Heap::undefined_value();
+  return HEAP->undefined_value();
 }
 
 
 // Gets the obj id for the specified address if valid.
 int LiveObjectList::GetObjId(Object* obj) {
   // Make a heap object pointer from the address.
   HeapObject* hobj = HeapObject::cast(obj);
   Element* element = FindElementFor<HeapObject*>(GetElementObj, hobj);
   if (element != NULL) {
     return element->id_;
   }
   return 0;  // Invalid address.
 }
 
 
 // Gets the obj id for the specified address if valid.
 Object* LiveObjectList::GetObjId(Handle<String> address) {
   SmartPointer<char> addr_str =
       address->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
 
+  Isolate* isolate = Isolate::Current();
+
   // Extract the address value from the string.
-  int value = static_cast<int>(StringToInt(*address, 16));
+  int value =
+      static_cast<int>(StringToInt(isolate->unicode_cache(), *address, 16));
   Object* obj = reinterpret_cast<Object*>(value);
   return Smi::FromInt(GetObjId(obj));
 }
 
 
 // Helper class for copying HeapObjects.
 class LolVisitor: public ObjectVisitor {
  public:
   LolVisitor(HeapObject* target, Handle<HeapObject> handle_to_skip)
       : target_(target), handle_to_skip_(handle_to_skip), found_(false) {}
@@ skipping 99 matching lines @@
                                  LiveObjectSummary *summary,
                                  JSFunction* arguments_function,
                                  Handle<Object> error) {
   HandleScope scope;
 
   // Scratch handles.
   Handle<JSObject> detail;
   Handle<String> desc;
   Handle<HeapObject> retainer;
 
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+
   // Prefetch some needed symbols.
-  Handle<String> id_sym = Factory::LookupAsciiSymbol("id");
-  Handle<String> desc_sym = Factory::LookupAsciiSymbol("desc");
-  Handle<String> size_sym = Factory::LookupAsciiSymbol("size");
+  Handle<String> id_sym = factory->LookupAsciiSymbol("id");
+  Handle<String> desc_sym = factory->LookupAsciiSymbol("desc");
+  Handle<String> size_sym = factory->LookupAsciiSymbol("size");
 
   NoHandleAllocation ha;
   int count = 0;
   int index = 0;
   Handle<JSObject> last_obj;
 
   *total_count = 0;
 
   // Iterate roots.
   LolVisitor lol_visitor(*target, target);
-  Heap::IterateStrongRoots(&lol_visitor, VISIT_ALL);
+  isolate->heap()->IterateStrongRoots(&lol_visitor, VISIT_ALL);
   if (!AddRootRetainerIfFound(lol_visitor,
                               filter,
                               summary,
                               SetFoundRoot,
                               start,
                               dump_limit,
                               total_count,
                               retainers_arr,
                               &count,
                               &index,
                               "<root>",
                               id_sym,
                               desc_sym,
                               size_sym,
                               error)) {
     return -1;
   }
 
   lol_visitor.reset();
-  Heap::IterateWeakRoots(&lol_visitor, VISIT_ALL);
+  isolate->heap()->IterateWeakRoots(&lol_visitor, VISIT_ALL);
   if (!AddRootRetainerIfFound(lol_visitor,
                               filter,
                               summary,
                               SetFoundWeakRoot,
                               start,
                               dump_limit,
                               total_count,
                               retainers_arr,
                               &count,
                               &index,
@@ skipping 88 matching lines @@
   return count;
 }
 
 
 MaybeObject* LiveObjectList::GetObjRetainers(int obj_id,
                                              Handle<JSObject> instance_filter,
                                              bool verbose,
                                              int start,
                                              int dump_limit,
                                              Handle<JSObject> filter_obj) {
-  HandleScope scope;
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Heap* heap = isolate->heap();
+
+  HandleScope scope(isolate);
 
   // Get the target object.
   HeapObject* heap_obj = HeapObject::cast(GetObj(obj_id));
-  if (heap_obj == Heap::undefined_value()) {
+  if (heap_obj == heap->undefined_value()) {
     return heap_obj;
   }
 
   Handle<HeapObject> target = Handle<HeapObject>(heap_obj);
 
   // Get the constructor function for context extension and arguments array.
   JSObject* arguments_boilerplate =
-      Top::context()->global_context()->arguments_boilerplate();
+      isolate->context()->global_context()->arguments_boilerplate();
   JSFunction* arguments_function =
       JSFunction::cast(arguments_boilerplate->map()->constructor());
 
   Handle<JSFunction> args_function = Handle<JSFunction>(arguments_function);
   LolFilter filter(filter_obj);
 
   if (!verbose) {
     RetainersSummaryWriter writer(target, instance_filter, args_function);
     return SummarizePrivate(&writer, &filter, true);
 
   } else {
     RetainersDumpWriter writer(target, instance_filter, args_function);
     Object* body_obj;
     MaybeObject* maybe_result =
         DumpPrivate(&writer, start, dump_limit, &filter);
     if (!maybe_result->ToObject(&body_obj)) {
       return maybe_result;
     }
 
     // Set body.id.
     Handle<JSObject> body = Handle<JSObject>(JSObject::cast(body_obj));
-    Handle<String> id_sym = Factory::LookupAsciiSymbol("id");
+    Handle<String> id_sym = factory->LookupAsciiSymbol("id");
     maybe_result = body->SetProperty(*id_sym,
                                      Smi::FromInt(obj_id),
                                      NONE,
                                      kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
 
     return *body;
   }
 }
 
 
 Object* LiveObjectList::PrintObj(int obj_id) {
   Object* obj = GetObj(obj_id);
   if (!obj) {
-    return Heap::undefined_value();
+    return HEAP->undefined_value();
   }
 
   EmbeddedVector<char, 128> temp_filename;
   static int temp_count = 0;
   const char* path_prefix = ".";
 
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Heap* heap = isolate->heap();
+
   if (FLAG_lol_workdir) {
     path_prefix = FLAG_lol_workdir;
   }
   OS::SNPrintF(temp_filename, "%s/lol-print-%d", path_prefix, ++temp_count);
 
   FILE* f = OS::FOpen(temp_filename.start(), "w+");
 
   PrintF(f, "@%d ", LiveObjectList::GetObjId(obj));
 #ifdef OBJECT_PRINT
 #ifdef INSPECTOR
   Inspector::DumpObjectType(f, obj);
 #endif  // INSPECTOR
   PrintF(f, "\n");
   obj->Print(f);
 #else  // !OBJECT_PRINT
   obj->ShortPrint(f);
 #endif  // !OBJECT_PRINT
   PrintF(f, "\n");
   Flush(f);
   fclose(f);
 
   // Create a string from the temp_file.
   // Note: the mmapped resource will take care of closing the file.
   MemoryMappedExternalResource* resource =
       new MemoryMappedExternalResource(temp_filename.start(), true);
   if (resource->exists() && !resource->is_empty()) {
     ASSERT(resource->IsAscii());
     Handle<String> dump_string =
-        Factory::NewExternalStringFromAscii(resource);
-    ExternalStringTable::AddString(*dump_string);
+        factory->NewExternalStringFromAscii(resource);
+    heap->external_string_table()->AddString(*dump_string);
     return *dump_string;
   } else {
     delete resource;
   }
-  return Heap::undefined_value();
+  return HEAP->undefined_value();
 }
 
 
 class LolPathTracer: public PathTracer {
  public:
   LolPathTracer(FILE* out,
                 Object* search_target,
                 WhatToFind what_to_find)
       : PathTracer(search_target, what_to_find, VISIT_ONLY_STRONG), out_(out) {}
 
@@ skipping 67 matching lines @@
   static int temp_count = 0;
   const char* path_prefix = ".";
 
   if (FLAG_lol_workdir) {
     path_prefix = FLAG_lol_workdir;
   }
   OS::SNPrintF(temp_filename, "%s/lol-getpath-%d", path_prefix, ++temp_count);
 
   FILE* f = OS::FOpen(temp_filename.start(), "w+");
 
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Heap* heap = isolate->heap();
+
   // Save the previous verbosity.
   bool prev_verbosity = FLAG_use_verbose_printer;
   FLAG_use_verbose_printer = false;
 
   // Dump the paths.
   {
     // The tracer needs to be scoped because its usage asserts no allocation,
     // and we need to allocate the result string below.
     LolPathTracer tracer(f, obj2, LolPathTracer::FIND_FIRST);
 
     bool found = false;
     if (obj1 == NULL) {
       // Check for ObjectGroups that references this object.
       // TODO(mlam): refactor this to be more modular.
       {
-        List<ObjectGroup*>* groups = GlobalHandles::ObjectGroups();
+        List<ObjectGroup*>* groups = isolate->global_handles()->object_groups();
         for (int i = 0; i < groups->length(); i++) {
           ObjectGroup* group = groups->at(i);
           if (group == NULL) continue;
 
           bool found_group = false;
-          List<Object**>& objects = group->objects_;
-          for (int j = 0; j < objects.length(); j++) {
-            Object* object = *objects[j];
+          for (size_t j = 0; j < group->length_; j++) {
+            Object* object = *(group->objects_[j]);
             HeapObject* hobj = HeapObject::cast(object);
             if (obj2 == hobj) {
               found_group = true;
               break;
             }
           }
 
           if (found_group) {
             PrintF(f,
                    "obj %p is a member of object group %p {\n",
                    reinterpret_cast<void*>(obj2),
                    reinterpret_cast<void*>(group));
-            for (int j = 0; j < objects.length(); j++) {
-              Object* object = *objects[j];
+            for (size_t j = 0; j < group->length_; j++) {
+              Object* object = *(group->objects_[j]);
               if (!object->IsHeapObject()) continue;
 
               HeapObject* hobj = HeapObject::cast(object);
               int id = GetObjId(hobj);
               if (id != 0) {
                 PrintF(f, "  @%d:", id);
               } else {
                 PrintF(f, "  <no id>:");
               }
 
               char buffer[512];
               GenerateObjectDesc(hobj, buffer, sizeof(buffer));
               PrintF(f, " %s", buffer);
               if (hobj == obj2) {
                 PrintF(f, " <===");
               }
               PrintF(f, "\n");
             }
             PrintF(f, "}\n");
           }
         }
       }
 
       PrintF(f, "path from roots to obj %p\n", reinterpret_cast<void*>(obj2));
-      Heap::IterateRoots(&tracer, VISIT_ONLY_STRONG);
+      heap->IterateRoots(&tracer, VISIT_ONLY_STRONG);
       found = tracer.found();
 
       if (!found) {
         PrintF(f, "  No paths found. Checking symbol tables ...\n");
-        SymbolTable* symbol_table = Heap::raw_unchecked_symbol_table();
+        SymbolTable* symbol_table = HEAP->raw_unchecked_symbol_table();
         tracer.VisitPointers(reinterpret_cast<Object**>(&symbol_table),
                              reinterpret_cast<Object**>(&symbol_table)+1);
         found = tracer.found();
         if (!found) {
           symbol_table->IteratePrefix(&tracer);
           found = tracer.found();
         }
       }
 
       if (!found) {
         PrintF(f, "  No paths found. Checking weak roots ...\n");
         // Check weak refs next.
-        GlobalHandles::IterateWeakRoots(&tracer);
+        isolate->global_handles()->IterateWeakRoots(&tracer);
         found = tracer.found();
       }
 
     } else {
       PrintF(f, "path from obj %p to obj %p:\n",
              reinterpret_cast<void*>(obj1), reinterpret_cast<void*>(obj2));
       tracer.TracePathFrom(reinterpret_cast<Object**>(&obj1));
       found = tracer.found();
     }
 
     if (!found) {
       PrintF(f, "  No paths found\n\n");
     }
   }
 
   // Flush and clean up the dumped file.
   Flush(f);
   fclose(f);
 
   // Restore the previous verbosity.
   FLAG_use_verbose_printer = prev_verbosity;
 
   // Create a string from the temp_file.
   // Note: the mmapped resource will take care of closing the file.
   MemoryMappedExternalResource* resource =
       new MemoryMappedExternalResource(temp_filename.start(), true);
   if (resource->exists() && !resource->is_empty()) {
     ASSERT(resource->IsAscii());
     Handle<String> path_string =
-        Factory::NewExternalStringFromAscii(resource);
-    ExternalStringTable::AddString(*path_string);
+        factory->NewExternalStringFromAscii(resource);
+    heap->external_string_table()->AddString(*path_string);
     return *path_string;
   } else {
     delete resource;
   }
-  return Heap::undefined_value();
+  return heap->undefined_value();
 }
 
 
 Object* LiveObjectList::GetPath(int obj_id1,
                                 int obj_id2,
                                 Handle<JSObject> instance_filter) {
   HandleScope scope;
 
   // Get the target object.
   HeapObject* obj1 = NULL;
   if (obj_id1 != 0) {
     obj1 = HeapObject::cast(GetObj(obj_id1));
-    if (obj1 == Heap::undefined_value()) {
+    if (obj1 == HEAP->undefined_value()) {
       return obj1;
     }
   }
 
   HeapObject* obj2 = HeapObject::cast(GetObj(obj_id2));
-  if (obj2 == Heap::undefined_value()) {
+  if (obj2 == HEAP->undefined_value()) {
     return obj2;
   }
 
   return GetPathPrivate(obj1, obj2);
 }
 
 
 void LiveObjectList::DoProcessNonLive(HeapObject *obj) {
   // We should only be called if we have at least one lol to search.
   ASSERT(last() != NULL);
@@ skipping 333 matching lines @@
     lol = lol->prev_;
   }
 
   OS::Print("  DONE verifying.\n\n\n");
 }
 
 
 void LiveObjectList::VerifyNotInFromSpace() {
   OS::Print("VerifyNotInFromSpace() ...\n");
   LolIterator it(NULL, last());
+  Heap* heap = ISOLATE->heap();
   int i = 0;
   for (it.Init(); !it.Done(); it.Next()) {
     HeapObject* heap_obj = it.Obj();
-    if (Heap::InFromSpace(heap_obj)) {
+    if (heap->InFromSpace(heap_obj)) {
       OS::Print(" ERROR: VerifyNotInFromSpace: [%d] obj %p in From space %p\n",
-                i++, heap_obj, Heap::new_space()->FromSpaceLow());
+                i++, heap_obj, heap->new_space()->FromSpaceLow());
     }
   }
 }
 #endif  // VERIFY_LOL
 
 
 } }  // namespace v8::internal
 
 #endif  // LIVE_OBJECT_LIST