* Generate contexts involving extensions using partial snapshots.

src/bootstrapper.cc

 // Copyright 2006-2008 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 301 matching lines @@
   // processing callbacks which may create new environments.
   Genesis* previous_;
   static Genesis* current_;
 
   Handle<Context> global_context() { return global_context_; }
 
   void CreateRoots(v8::Handle<v8::ObjectTemplate> global_template,
                    Handle<Object> global_object);
   void InstallNativeFunctions();
   bool InstallNatives();
-  bool InstallExtensions(v8::ExtensionConfiguration* extensions);
-  bool InstallExtension(const char* name);
-  bool InstallExtension(v8::RegisteredExtension* current);
-  bool InstallSpecialObjects();
+  static bool InstallExtensions(Handle<Context> global_context,
+                                v8::ExtensionConfiguration* extensions);
+  static bool InstallExtension(const char* name);
+  static bool InstallExtension(v8::RegisteredExtension* current);
+  static void InstallSpecialObjects(Handle<Context> global_context);
   bool ConfigureApiObject(Handle<JSObject> object,
                           Handle<ObjectTemplateInfo> object_template);
   bool ConfigureGlobalObjects(v8::Handle<v8::ObjectTemplate> global_template);
 
   // Migrates all properties from the 'from' object to the 'to'
   // object and overrides the prototype in 'to' with the one from
   // 'from'.
   void TransferObject(Handle<JSObject> from, Handle<JSObject> to);
   void TransferNamedProperties(Handle<JSObject> from, Handle<JSObject> to);
   void TransferIndexedProperties(Handle<JSObject> from, Handle<JSObject> to);
 
   Handle<DescriptorArray> ComputeFunctionInstanceDescriptor(
       bool make_prototype_read_only,
       bool make_prototype_enumerable = false);
   void MakeFunctionInstancePrototypeWritable();
 
   void AddSpecialFunction(Handle<JSObject> prototype,
                           const char* name,
                           Handle<Code> code);
 
   void BuildSpecialFunctionTable();
 
   static bool CompileBuiltin(int index);
   static bool CompileNative(Vector<const char> name, Handle<String> source);
   static bool CompileScriptCached(Vector<const char> name,
                                   Handle<String> source,
                                   SourceCodeCache* cache,
                                   v8::Extension* extension,
+                                  Handle<Context> top_context,
                                   bool use_runtime_context);
 
   Handle<Context> result_;
+  friend class Bootstrapper;
 };
 
 Genesis* Genesis::current_ = NULL;
 
 
 void Bootstrapper::Iterate(ObjectVisitor* v) {
   extensions_cache.Iterate(v);
   v->Synchronize("Extensions");
   PendingFixups::Iterate(v);
   v->Synchronize("PendingFixups");
 }
 
 
 // While setting up the environment, we collect code positions that
 // need to be patched before we can run any code in the environment.
 void Bootstrapper::AddFixup(Code* code, MacroAssembler* masm) {
   PendingFixups::Add(code, masm);
 }
 
 
 bool Bootstrapper::IsActive() {
-  return Genesis::current() != NULL;
+  return active_ != 0 || Genesis::current() != NULL;

[Mads Ager (chromium), 2010/02/05 08:57:09]

Can we get rid of the Genesis::current() check and make sure to use
BootStrapperActive always when bootstrapping?

 }
 
 
 Handle<Context> Bootstrapper::CreateEnvironment(
     Handle<Object> global_object,
     v8::Handle<v8::ObjectTemplate> global_template,
     v8::ExtensionConfiguration* extensions) {
+  HandleScope scope;
   Genesis genesis(global_object, global_template, extensions);
+  if (!genesis.result().is_null()) {
+    if (!InstallExtensions(genesis.result(), extensions)) {
+      return Handle<Context>();
+    }
+  }
   return genesis.result();
 }
 
 
 static void SetObjectPrototype(Handle<JSObject> object, Handle<Object> proto) {
   // object.__proto__ = proto;
   Handle<Map> old_to_map = Handle<Map>(object->map());
   Handle<Map> new_to_map = Factory::CopyMapDropTransitions(old_to_map);
   new_to_map->set_prototype(*proto);
   object->set_map(*new_to_map);
@@ skipping 496 matching lines @@
   Handle<String> source_code = Bootstrapper::NativesSourceLookup(index);
   return CompileNative(name, source_code);
 }
 
 
 bool Genesis::CompileNative(Vector<const char> name, Handle<String> source) {
   HandleScope scope;
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Debugger::set_compiling_natives(true);
 #endif
-  bool result =
-      CompileScriptCached(name, source, NULL, NULL, true);
+  bool result = CompileScriptCached(name,
+                                    source,
+                                    NULL,
+                                    NULL,
+                                    Handle<Context>(Top::context()),
+                                    true);
   ASSERT(Top::has_pending_exception() != result);
   if (!result) Top::clear_pending_exception();
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Debugger::set_compiling_natives(false);
 #endif
   return result;
 }
 
 
 bool Genesis::CompileScriptCached(Vector<const char> name,
                                   Handle<String> source,
                                   SourceCodeCache* cache,
                                   v8::Extension* extension,
+                                  Handle<Context> top_context,
                                   bool use_runtime_context) {
   HandleScope scope;
   Handle<JSFunction> boilerplate;
 
   // If we can't find the function in the cache, we compile a new
   // function and insert it into the cache.
   if (cache == NULL || !cache->Lookup(name, &boilerplate)) {
     ASSERT(source->IsAsciiRepresentation());
     Handle<String> script_name = Factory::NewStringFromUtf8(name);
     boilerplate = Compiler::Compile(
         source,
         script_name,
         0,
         0,
         extension,
         NULL,
         use_runtime_context ? NATIVES_CODE : NOT_NATIVES_CODE);
     if (boilerplate.is_null()) return false;
     if (cache != NULL) cache->Add(name, boilerplate);
   }
 
   // Setup the function context. Conceptually, we should clone the
   // function before overwriting the context but since we're in a
   // single-threaded environment it is not strictly necessary.
-  ASSERT(Top::context()->IsGlobalContext());
+  ASSERT(top_context->IsGlobalContext());
   Handle<Context> context =
       Handle<Context>(use_runtime_context
-                      ? Top::context()->runtime_context()
-                      : Top::context());
+                      ? Handle<Context>(top_context->runtime_context())
+                      : top_context);
   Handle<JSFunction> fun =
       Factory::NewFunctionFromBoilerplate(boilerplate, context);
 
   // Call function using either the runtime object or the global
   // object as the receiver. Provide no parameters.
   Handle<Object> receiver =
       Handle<Object>(use_runtime_context
-                     ? Top::context()->builtins()
-                     : Top::context()->global());
+                     ? top_context->builtins()
+                     : top_context->global());
   bool has_pending_exception;
   Handle<Object> result =
       Execution::Call(fun, receiver, 0, NULL, &has_pending_exception);
   if (has_pending_exception) return false;
   return PendingFixups::Process(
-      Handle<JSBuiltinsObject>(Top::context()->builtins()));
+      Handle<JSBuiltinsObject>(top_context->builtins()));
 }
 
 
 #define INSTALL_NATIVE(Type, name, var)                                  \
   Handle<String> var##_name = Factory::LookupAsciiSymbol(name);          \
   global_context()->set_##var(Type::cast(global_context()->              \
                                            builtins()->                  \
                                              GetProperty(*var##_name)));
 
 void Genesis::InstallNativeFunctions() {
@@ skipping 231 matching lines @@
   }
 
 #ifdef DEBUG
   builtins->Verify();
 #endif
 
   return true;
 }
 
 
-bool Genesis::InstallSpecialObjects() {
+int Bootstrapper::active_ = 0;
+
+
+bool Bootstrapper::InstallExtensions(Handle<Context> global_context,
+                                     v8::ExtensionConfiguration* extensions) {
+  BootstrapperActive active;
+  SaveContext saved_context;
+  Top::set_context(*global_context);
+  if (!Genesis::InstallExtensions(global_context, extensions)) return false;
+  Genesis::InstallSpecialObjects(global_context);
+  return true;
+}
+
+
+void Genesis::InstallSpecialObjects(Handle<Context> global_context) {
   HandleScope scope;
   Handle<JSGlobalObject> js_global(
-      JSGlobalObject::cast(global_context()->global()));
+      JSGlobalObject::cast(global_context->global()));
   // Expose the natives in global if a name for it is specified.
   if (FLAG_expose_natives_as != NULL && strlen(FLAG_expose_natives_as) != 0) {
     Handle<String> natives_string =
         Factory::LookupAsciiSymbol(FLAG_expose_natives_as);
     SetProperty(js_global, natives_string,
                 Handle<JSObject>(js_global->builtins()), DONT_ENUM);
   }
 
   Handle<Object> Error = GetProperty(js_global, "Error");
   if (Error->IsJSObject()) {
     Handle<String> name = Factory::LookupAsciiSymbol("stackTraceLimit");
     SetProperty(Handle<JSObject>::cast(Error),
                 name,
                 Handle<Smi>(Smi::FromInt(FLAG_stack_trace_limit)),
                 NONE);
   }
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Expose the debug global object in global if a name for it is specified.
   if (FLAG_expose_debug_as != NULL && strlen(FLAG_expose_debug_as) != 0) {
     // If loading fails we just bail out without installing the
     // debugger but without tanking the whole context.
     if (!Debug::Load())

[Mads Ager (chromium), 2010/02/05 08:57:09]

Either make this a one-liner or use braces around the body.

-      return true;
+      return;
     // Set the security token for the debugger context to the same as
     // the shell global context to allow calling between these (otherwise
     // exposing debug global object doesn't make much sense).
     Debug::debug_context()->set_security_token(
-        global_context()->security_token());
+        global_context->security_token());
 
     Handle<String> debug_string =
         Factory::LookupAsciiSymbol(FLAG_expose_debug_as);
     SetProperty(js_global, debug_string,
         Handle<Object>(Debug::debug_context()->global_proxy()), DONT_ENUM);
   }
 #endif
-
-  return true;
 }
 
 
-bool Genesis::InstallExtensions(v8::ExtensionConfiguration* extensions) {
+bool Genesis::InstallExtensions(Handle<Context> global_context,
+                                v8::ExtensionConfiguration* extensions) {
   // Clear coloring of extension list
   v8::RegisteredExtension* current = v8::RegisteredExtension::first_extension();
   while (current != NULL) {
     current->set_state(v8::UNVISITED);
     current = current->next();
   }
-  // Install auto extensions.  Coordinate with AutoExtensionsExist below.
+  // Install auto extensions.
   current = v8::RegisteredExtension::first_extension();
   while (current != NULL) {
     if (current->extension()->auto_enable())
       InstallExtension(current);
     current = current->next();
   }
 
   if (FLAG_expose_gc) InstallExtension("v8/gc");
 
   if (extensions == NULL) return true;
@@ skipping 43 matching lines @@
   current->set_state(v8::VISITED);
   v8::Extension* extension = current->extension();
   // Install the extension's dependencies
   for (int i = 0; i < extension->dependency_count(); i++) {
     if (!InstallExtension(extension->dependencies()[i])) return false;
   }
   Vector<const char> source = CStrVector(extension->source());
   Handle<String> source_code = Factory::NewStringFromAscii(source);
   bool result = CompileScriptCached(CStrVector(extension->name()),
                                     source_code,
-                                    &extensions_cache, extension,
+                                    &extensions_cache,
+                                    extension,
+                                    Handle<Context>(Top::context()),
                                     false);
   ASSERT(Top::has_pending_exception() != result);
   if (!result) {
     Top::clear_pending_exception();
   }
   current->set_state(v8::INSTALLED);
   return result;
 }
 
 
@@ skipping 223 matching lines @@
   previous_ = current_;
   current_  = this;
   result_ = Handle<Context>::null();
 
   // If V8 isn't running and cannot be initialized, just return.
   if (!V8::IsRunning() && !V8::Initialize(NULL)) return;
 
   // Before creating the roots we must save the context and restore it
   // on all function exits.
   HandleScope scope;
-  SaveContext context;
+  SaveContext saved_context;
 
   CreateRoots(global_template, global_object);
 
   if (!InstallNatives()) return;
 
   MakeFunctionInstancePrototypeWritable();
   BuildSpecialFunctionTable();
 
   if (!ConfigureGlobalObjects(global_template)) return;
 
-  if (!InstallExtensions(extensions)) return;
-
-  if (!InstallSpecialObjects()) return;
-
   result_ = global_context_;
 }
 
 
 // Support for thread preemption.
 
 // Reserve space for statics needing saving and restoring.
 int Bootstrapper::ArchiveSpacePerThread() {
   return Genesis::ArchiveSpacePerThread();
 }
@@ skipping 10 matching lines @@
   return Genesis::RestoreState(from);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   ASSERT(Genesis::current() == NULL);
 }
 
 
-// Are there extensions that should be installed even if no extension was
-// specified?
-bool Bootstrapper::AutoExtensionsExist() {
-  // Find auto extensions.
-  v8::RegisteredExtension* current = v8::RegisteredExtension::first_extension();
-  while (current != NULL) {
-    if (current->extension()->auto_enable()) return true;
-    current = current->next();
-  }
-  return FLAG_expose_gc;
-}
-
-
 // Reserve space for statics needing saving and restoring.
 int Genesis::ArchiveSpacePerThread() {
   return sizeof(current_);
 }
 
 
 // Archive statics that are thread local.
 char* Genesis::ArchiveState(char* to) {
   *reinterpret_cast<Genesis**>(to) = current_;
   current_ = NULL;
   return to + sizeof(current_);
 }
 
 
 // Restore statics that are thread local.
 char* Genesis::RestoreState(char* from) {
   current_ = *reinterpret_cast<Genesis**>(from);
   return from + sizeof(current_);
 }
 
 } }  // namespace v8::internal