[Isolates] Rebase and get d8 to compile....

src/d8.cc

 // Copyright 2009 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 428 matching lines @@
         i::Factory::NewStringFromUtf8(i::CStrVector(js_args[j]));
     arguments_array->set(j, *arg);
   }
   i::Handle<i::JSArray> arguments_jsarray =
       i::Factory::NewJSArrayWithElements(arguments_array);
   global_template->Set(String::New("arguments"),
                        Utils::ToLocal(arguments_jsarray));
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Install the debugger object in the utility scope
-  i::Debug::Load();
-  i::Handle<i::JSObject> debug
-      = i::Handle<i::JSObject>(i::Debug::debug_context()->global());
+  i::Debug* debug = i::Isolate::Current()->debug();
+  debug->Load();
+  i::Handle<i::JSObject> js_debug
+      = i::Handle<i::JSObject>(debug->debug_context()->global());
   utility_context_->Global()->Set(String::New("$debug"),
-                                  Utils::ToLocal(debug));
+                                  Utils::ToLocal(js_debug));
 #endif
 
   // Run the d8 shell utility script in the utility context
   int source_index = i::NativesCollection<i::D8>::GetIndex("d8");
   i::Vector<const char> shell_source
       = i::NativesCollection<i::D8>::GetScriptSource(source_index);
   i::Vector<const char> shell_source_name
       = i::NativesCollection<i::D8>::GetScriptName(source_index);
   Handle<String> source = String::New(shell_source.start(),
                                       shell_source.length());
@@ skipping 11 matching lines @@
       : i::Handle<i::Script>(i::Script::cast(
           i::SharedFunctionInfo::cast(*compiled_script)->script()));
   script_object->set_type(i::Smi::FromInt(i::Script::TYPE_NATIVE));
 
   // Create the evaluation context
   evaluation_context_ = Context::New(NULL, global_template);
   evaluation_context_->SetSecurityToken(Undefined());
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Set the security token of the debug context to allow access.
-  i::Debug::debug_context()->set_security_token(i::Heap::undefined_value());
+  debug->debug_context()->set_security_token(HEAP->undefined_value());
 
   // Start the debugger agent if requested.
   if (i::FLAG_debugger_agent) {
     v8::Debug::EnableAgent("d8 shell", i::FLAG_debugger_port);
   }
 
   // Start the in-process debugger if requested.
   if (i::FLAG_debugger && !i::FLAG_debugger_agent) {
     v8::Debug::SetDebugEventListener(HandleDebugEvent);
   }
@@ skipping 95 matching lines @@
     Handle<String> name = String::New("(d8)");
     ExecuteString(String::New(*input), name, true, true);
   }
   editor->Close();
   printf("\n");
 }
 
 
 class ShellThread : public i::Thread {
  public:
-  ShellThread(int no, i::Vector<const char> files)
-    : no_(no), files_(files) { }
+  ShellThread(i::Isolate* isolate, int no, i::Vector<const char> files)
+    : i::Thread(isolate), no_(no), files_(files) { }
   virtual void Run();
  private:
   int no_;
   i::Vector<const char> files_;
 };
 
 
 void ShellThread::Run() {
   // Prepare the context for this thread.
   Locker locker;
@@ skipping 110 matching lines @@
         if (!ExecuteString(source, file_name, false, true)) {
           OnExit();
           return 1;
         }
         i++;
       } else if (strcmp(str, "-p") == 0 && i + 1 < argc) {
         int size = 0;
         const char* files = ReadChars(argv[++i], &size);
         if (files == NULL) return 1;
         ShellThread* thread =
-            new ShellThread(threads.length(),
+            new ShellThread(i::Isolate::Current(),
+                            threads.length(),
                             i::Vector<const char>(files, size));
         thread->Start();
         threads.Add(thread);
       } else {
         // Use all other arguments as names of files to load and run.
         HandleScope handle_scope;
         Handle<String> file_name = v8::String::New(str);
         Handle<String> source = ReadFile(str);
         if (source.IsEmpty()) {
           printf("Error reading '%s'\n", str);
@@ skipping 30 matching lines @@
   return 0;
 }
 
 
 }  // namespace v8
 
 
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }