removed some unnecessary stuff from d8's initialization

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 471 matching lines @@
 
 
 void Shell::AddHistogramSample(void* histogram, int sample) {
   Counter* counter = reinterpret_cast<Counter*>(histogram);
   counter->AddSample(sample);
 }
 
 void Shell::InstallUtilityScript() {
   Locker lock;
   HandleScope scope;
+  utility_context_->SetSecurityToken(Undefined());
+  evaluation_context_->SetSecurityToken(Undefined());
   Context::Scope utility_scope(utility_context_);

[Yang, 2011/06/22 00:44:08]

I just went with your suggestion to not set the security token when using d8 for
test suites. that means that the security tokens are set when the utility script
is installed to make sure that the debug object is properly exposed.

+
+#ifdef ENABLE_DEBUGGER_SUPPORT
+  // Install the debugger object in the utility scope
+  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(js_debug));
+  debug->debug_context()->set_security_token(HEAP->undefined_value());
+#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>::GetRawScriptSource(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());
   Handle<String> name = String::New(shell_source_name.start(),
       shell_source_name.length());
   Handle<Script> script = Script::Compile(source, name);
   script->Run();
 
   // Mark the d8 shell script as native to avoid it showing up as normal source
   // in the debugger.
   i::Handle<i::Object> compiled_script = Utils::OpenHandle(*script);
   i::Handle<i::Script> script_object = compiled_script->IsJSFunction()
      ? i::Handle<i::Script>(i::Script::cast(
          i::JSFunction::cast(*compiled_script)->shared()->script()))
      : i::Handle<i::Script>(i::Script::cast(
          i::SharedFunctionInfo::cast(*compiled_script)->script()));
   script_object->set_type(i::Smi::FromInt(i::Script::TYPE_NATIVE));
 }
 
+
 #ifdef COMPRESS_STARTUP_DATA_BZ2
 class BZip2Decompressor : public v8::StartupDataDecompressor {
  public:
   virtual ~BZip2Decompressor() { }
 
  protected:
   virtual int DecompressData(char* raw_data,
                              int* raw_data_size,
                              const char* compressed_data,
                              int compressed_data_size) {
@@ skipping 51 matching lines @@
   global_template->Set(String::New("lol_is_enabled"), Boolean::New(false));
 #endif
 
   Handle<ObjectTemplate> os_templ = ObjectTemplate::New();
   AddOSMethods(os_templ);
   global_template->Set(String::New("os"), os_templ);
 
   return global_template;
 }
 
-void Shell::Initialize() {
+
+void Shell::Initialize(bool test_shell) {

[Yang, 2011/06/22 00:44:08]

Instead of renaming the argument to "interactive", i chose the opposite:
whenever we use d8 for test suites, the utility context is skipped. See below

 #ifdef COMPRESS_STARTUP_DATA_BZ2
   BZip2Decompressor startup_data_decompressor;
   int bz2_result = startup_data_decompressor.Decompress();
   if (bz2_result != BZ_OK) {
     fprintf(stderr, "bzip error code: %d\n", bz2_result);
     exit(1);
   }
 #endif
 
   Shell::counter_map_ = new CounterMap();
   // Set up counters
   if (i::StrLength(i::FLAG_map_counters) != 0)
     MapCounters(i::FLAG_map_counters);
   if (i::FLAG_dump_counters) {
     V8::SetCounterFunction(LookupCounter);
     V8::SetCreateHistogramFunction(CreateHistogram);
     V8::SetAddHistogramSampleFunction(AddHistogramSample);
   }
 
-  // Initialize the global objects
+  if (test_shell) return;
+
+  Locker lock;
   HandleScope scope;
   Handle<ObjectTemplate> global_template = CreateGlobalTemplate();
-
   utility_context_ = Context::New(NULL, global_template);
-  utility_context_->SetSecurityToken(Undefined());
-  Context::Scope utility_scope(utility_context_);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
-  // Install the debugger object in the utility scope
-  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(js_debug));
+  // Start the debugger agent if requested.
+  if (i::FLAG_debugger_agent) {
+    v8::Debug::EnableAgent("d8 shell", i::FLAG_debugger_port, true);
+  }
+
+  // Start the in-process debugger if requested.
+  if (i::FLAG_debugger && !i::FLAG_debugger_agent) {
+    v8::Debug::SetDebugEventListener(HandleDebugEvent);
+  }
 #endif
 }
 
 
 void Shell::RenewEvaluationContext() {
   // Initialize the global objects
   HandleScope scope;
   Handle<ObjectTemplate> global_template = CreateGlobalTemplate();
 
   // (Re-)create the evaluation context
   if (!evaluation_context_.IsEmpty()) {
     evaluation_context_.Dispose();
   }
   evaluation_context_ = Context::New(NULL, global_template);
-  evaluation_context_->SetSecurityToken(Undefined());
+  Context::Scope utility_scope(evaluation_context_);
 
-  Context::Scope utility_scope(utility_context_);
   i::JSArguments js_args = i::FLAG_js_arguments;
   i::Handle<i::FixedArray> arguments_array =
       FACTORY->NewFixedArray(js_args.argc());
   for (int j = 0; j < js_args.argc(); j++) {
     i::Handle<i::String> arg =
         FACTORY->NewStringFromUtf8(i::CStrVector(js_args[j]));
     arguments_array->set(j, *arg);
   }
   i::Handle<i::JSArray> arguments_jsarray =
       FACTORY->NewJSArrayWithElements(arguments_array);
   evaluation_context_->Global()->Set(String::New("arguments"),
                                      Utils::ToLocal(arguments_jsarray));
-
-#ifdef ENABLE_DEBUGGER_SUPPORT
-  i::Debug* debug = i::Isolate::Current()->debug();
-  debug->Load();
-
-  // Set the security token of the debug context to allow access.
-  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, true);
-  }
-
-  // Start the in-process debugger if requested.
-  if (i::FLAG_debugger && !i::FLAG_debugger_agent) {
-    v8::Debug::SetDebugEventListener(HandleDebugEvent);
-  }
-#endif
 }
 
 
 void Shell::OnExit() {
   if (i::FLAG_dump_counters) {
     ::printf("+----------------------------------------+-------------+\n");
     ::printf("| Name                                   | Value       |\n");
     ::printf("+----------------------------------------+-------------+\n");
     for (CounterMap::Iterator i(counter_map_); i.More(); i.Next()) {
       Counter* counter = i.CurrentValue();
@@ skipping 65 matching lines @@
   return result;
 }
 
 
 void Shell::RunShell() {
   LineEditor* editor = LineEditor::Get();
   printf("V8 version %s [console: %s]\n", V8::GetVersion(), editor->name());
   if (i::FLAG_debugger) {
     printf("JavaScript debugger enabled\n");
   }
+
   editor->Open();
   while (true) {
     Locker locker;
     HandleScope handle_scope;
     Context::Scope context_scope(evaluation_context_);
     i::SmartPointer<char> input = editor->Prompt(Shell::kPrompt);
     if (input.is_empty())
       break;
     editor->AddHistory(*input);
     Handle<String> name = String::New("(d8)");
@@ skipping 27 matching lines @@
     // For each newline-separated line.
     char* next_line = ReadLine(ptr);
 
     if (*ptr == '#') {
       // Skip comment lines.
       ptr = next_line;
       continue;
     }
 
     Persistent<Context> thread_context = Context::New(NULL, global_template);
-    thread_context->SetSecurityToken(Undefined());
     Context::Scope context_scope(thread_context);
 
     while ((ptr != NULL) && (*ptr != '\0')) {
       char* filename = ptr;
       ptr = ReadWord(ptr);
 
       // Skip empty strings.
       if (strlen(filename) == 0) {
         break;
       }
@@ skipping 101 matching lines @@
   return 0;
 }
 
 
 int Shell::Main(int argc, char* argv[]) {
   // Figure out if we're requested to stress the optimization
   // infrastructure by running tests multiple times and forcing
   // optimization in the last run.
   bool FLAG_stress_opt = false;
   bool FLAG_stress_deopt = false;
-  bool run_shell = (argc == 1);
+  bool FLAG_interactive_shell = false;
+  bool FLAG_test_shell = false;
 
   for (int i = 0; i < argc; i++) {
     if (strcmp(argv[i], "--stress-opt") == 0) {
       FLAG_stress_opt = true;
       argv[i] = NULL;
     } else if (strcmp(argv[i], "--stress-deopt") == 0) {
       FLAG_stress_deopt = true;
       argv[i] = NULL;
     } else if (strcmp(argv[i], "--noalways-opt") == 0) {
       // No support for stressing if we can't use --always-opt.
       FLAG_stress_opt = false;
       FLAG_stress_deopt = false;
     } else if (strcmp(argv[i], "--shell") == 0) {
-      run_shell = true;
+      FLAG_interactive_shell = true;
+      argv[i] = NULL;
+    } else if (strcmp(argv[i], "--test") == 0) {
+      FLAG_test_shell = true;
       argv[i] = NULL;
     }
   }
 
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
 
-  Initialize();
+  FLAG_interactive_shell = !FLAG_test_shell &&

[Yang, 2011/06/22 00:44:08]

Basically states: if using shell for test suites, do not use interactive shell.

+      (FLAG_interactive_shell || (argc == 1));
+
+  Initialize(FLAG_test_shell);
 
   int result = 0;
   if (FLAG_stress_opt || FLAG_stress_deopt) {
     v8::Testing::SetStressRunType(
         FLAG_stress_opt ? v8::Testing::kStressTypeOpt
             : v8::Testing::kStressTypeDeopt);
     int stress_runs = v8::Testing::GetStressRuns();
     for (int i = 0; i < stress_runs && result == 0; i++) {
       printf("============ Stress %d/%d ============\n", i + 1, stress_runs);
       v8::Testing::PrepareStressRun(i);
       result = RunMain(argc, argv);
     }
     printf("======== Full Deoptimization =======\n");
     v8::Testing::DeoptimizeAll();
   } else {
     result = RunMain(argc, argv);
   }
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   if (i::FLAG_remote_debugger) {
+    InstallUtilityScript();

[Yang, 2011/06/22 00:44:08]

The remote debugger requires stuff from d8.js, therefore it has to be installed.

     RunRemoteDebugger(i::FLAG_debugger_port);
     return 0;
   }
 #endif
 
-  if (run_shell) {
+  if (FLAG_interactive_shell) {
     InstallUtilityScript();
     RunShell();
   }
 
   v8::V8::Dispose();
 
   return result;
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif