[Isolates] Cleanup of codepaths slowing down Dromaeo in browser.

src/api.cc

 // Copyright 2010 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 250 matching lines @@
 
 // --- S t a t i c s ---
 
 
 static bool InitializeHelper() {
   if (i::Snapshot::Initialize()) return true;
   return i::V8::Initialize(NULL);
 }
 
 
-static inline bool EnsureInitialized(const char* location) {
-  i::Isolate* isolate = i::Isolate::UncheckedCurrent();
+static inline bool EnsureInitializedForIsolate(i::Isolate* isolate,
+                                               const char* location) {
   if (isolate != NULL) {
     if (isolate->IsDefaultIsolate()) {
       if (i::V8::IsRunning()) {
         return true;
       }
       if (IsDeadCheck(location)) {
         return false;
       }
     } else {
       if (isolate->IsInitialized()) {
         return true;
       }
     }
   }
   return ApiCheck(InitializeHelper(), location, "Error initializing V8");
 }
 
+static inline bool EnsureInitialized(const char* location) {
+  i::Isolate* isolate = i::Isolate::UncheckedCurrent();
+  return EnsureInitializedForIsolate(isolate, location);
+}
 
 #ifdef DEBUG
 void ImplementationUtilities::ZapHandleRange(i::Object** begin,
                                              i::Object** end) {
   i::HandleScope::ZapRange(begin, end);
 }
 #endif
 
 
 v8::Handle<v8::Primitive> ImplementationUtilities::Undefined() {
   if (!EnsureInitialized("v8::Undefined()")) return v8::Handle<v8::Primitive>();
   return v8::Handle<Primitive>(ToApi<Primitive>(FACTORY->undefined_value()));
 }
 
 
 v8::Handle<v8::Primitive> ImplementationUtilities::Null() {
-  if (!EnsureInitialized("v8::Null()")) return v8::Handle<v8::Primitive>();
-  return v8::Handle<Primitive>(ToApi<Primitive>(FACTORY->null_value()));
+  i::Isolate* isolate = i::Isolate::UncheckedCurrent();
+  if (!EnsureInitializedForIsolate(isolate, "v8::Null()"))
+      return v8::Handle<v8::Primitive>();
+  return v8::Handle<Primitive>(
+      ToApi<Primitive>(isolate->factory()->null_value()));
 }
 
 
 v8::Handle<v8::Boolean> ImplementationUtilities::True() {
   if (!EnsureInitialized("v8::True()")) return v8::Handle<v8::Boolean>();
   return v8::Handle<v8::Boolean>(ToApi<Boolean>(FACTORY->true_value()));
 }
 
 
 v8::Handle<v8::Boolean> ImplementationUtilities::False() {
@@ skipping 187 matching lines @@
 #endif
 }
 
 
 int HandleScope::NumberOfHandles() {
   EnsureInitialized("HandleScope::NumberOfHandles");
   return i::HandleScope::NumberOfHandles();
 }
 
 
-i::Object** v8::HandleScope::CreateHandle(i::Object* value) {
+i::Object** HandleScope::CreateHandle(i::Object* value) {
   return i::HandleScope::CreateHandle(value, i::Isolate::Current());
 }
 
 
+i::Object** HandleScope::CreateHandle(i::HeapObject* value) {
+  ASSERT(value->IsHeapObject());
+  return reinterpret_cast<i::Object**>(
+      i::HandleScope::CreateHandle(value, value->GetIsolate()));
+}
+
+
 void Context::Enter() {
   if (IsDeadCheck("v8::Context::Enter()")) return;
   ENTER_V8;
   i::Handle<i::Context> env = Utils::OpenHandle(this);
   // TODO(isolates): Context should have a pointer to isolate.
   i::Isolate* isolate = i::Isolate::Current();
   isolate->handle_scope_implementer()->EnterContext(env);
 
   isolate->handle_scope_implementer()->SaveContext(isolate->context());
   isolate->set_context(*env);
@@ skipping 3320 matching lines @@
     // Introduce only canonical NaN value into the VM, to avoid signaling NaNs.
     value = i::OS::nan_value();
   }
   ENTER_V8;
   i::Handle<i::Object> result = FACTORY->NewNumber(value);
   return Utils::NumberToLocal(result);
 }
 
 
 Local<Integer> v8::Integer::New(int32_t value) {
-  EnsureInitialized("v8::Integer::New()");
+  i::Isolate* isolate = i::Isolate::UncheckedCurrent();
+  EnsureInitializedForIsolate(isolate, "v8::Integer::New()");
   if (i::Smi::IsValid(value)) {
-    return Utils::IntegerToLocal(i::Handle<i::Object>(i::Smi::FromInt(value)));
+    return Utils::IntegerToLocal(i::Handle<i::Object>(i::Smi::FromInt(value),
+                                                      isolate));
   }
   ENTER_V8;
-  i::Handle<i::Object> result = FACTORY->NewNumber(value);
+  i::Handle<i::Object> result = isolate->factory()->NewNumber(value);
   return Utils::IntegerToLocal(result);
 }
 
 
 Local<Integer> Integer::NewFromUnsigned(uint32_t value) {
   bool fits_into_int32_t = (value & (1 << 31)) == 0;
   if (fits_into_int32_t) {
     return Integer::New(static_cast<int32_t>(value));
   }
   ENTER_V8;
@@ skipping 1131 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal