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

src/api.cc

Index: src/api.cc
diff --git a/src/api.cc b/src/api.cc
index f28082344cc34f20f78be91f3619cff64530ea34..4887c1bc30b4cd721281455acd26989153108833 100644
--- a/src/api.cc
+++ b/src/api.cc
@@ -268,8 +268,8 @@ static bool InitializeHelper() {
 }
 
 
-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()) {
@@ -287,6 +287,10 @@ static inline bool EnsureInitialized(const char* location) {
   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,
@@ -303,8 +307,11 @@ v8::Handle<v8::Primitive> ImplementationUtilities::Undefined() {
 
 
 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()));
 }
 
 
@@ -511,12 +518,66 @@ int HandleScope::NumberOfHandles() {
   return i::HandleScope::NumberOfHandles();
 }
 
+// Define GetIsolateFromApiObject for various Api types. Need a few of them,
+// since they do not form inheritance hierarchy with a single HeapObject-backed
+// base class. First, declare the catch-all method:
+inline static i::Isolate* GetIsolateFromApiObject(Data* value) {
+  return i::Isolate::Current();
+}
+
+// Also declare overrides that know some types are backed by HeapObjects:
+#define MAKE_GET_ISOLATE_FROM_API_OBJECT(Type)                      \
+  inline static i::Isolate* GetIsolateFromApiObject(Type* value) {  \
+    i::HeapObject** p = reinterpret_cast<i::HeapObject**>(value);   \
+    ASSERT((*p)->IsHeapObject());                                   \
+    return (*p)->GetIsolate();                                      \
+  }
+
+MAKE_GET_ISOLATE_FROM_API_OBJECT(Context)
+MAKE_GET_ISOLATE_FROM_API_OBJECT(String)
+MAKE_GET_ISOLATE_FROM_API_OBJECT(Object)
+MAKE_GET_ISOLATE_FROM_API_OBJECT(Message)
+MAKE_GET_ISOLATE_FROM_API_OBJECT(StackTrace)
+MAKE_GET_ISOLATE_FROM_API_OBJECT(StackFrame)
+
+#undef MAKE_GET_ISOLATE_FROM_API_OBJECT
+
 
-i::Object** v8::HandleScope::CreateHandle(i::Object* value) {
-  return i::HandleScope::CreateHandle(value, i::Isolate::Current());
+template <class T>
+internal::Object** HandleScope::CreateHandle(T* value) {
+  internal::Object** p = reinterpret_cast<internal::Object**>(value);
+  return i::HandleScope::CreateHandle(*p, GetIsolateFromApiObject(value));
 }
 
 
+// We need to explicitly instantiate this method for particular types since
+// there is no callers for this instances in this file, so the instances are
+// not generated at all and linker complains.
+#define MAKE_CREATE_HANDLE(Type) \

[Vitaly Repeshko, 2010/12/06 18:18:45]

Ugh, I'm not a huge fan of explicit template instantiations. I think the
approach like in http://codereview.chromium.org/5581006 should be simpler and
less fragile. Could you please give it a try? (I verified it produces the right
assembly code even though it looks less "compile time".)

+  template internal::Object** HandleScope::CreateHandle<Type>(Type* value);
+
+MAKE_CREATE_HANDLE(Context)
+MAKE_CREATE_HANDLE(Value)
+MAKE_CREATE_HANDLE(Function)
+MAKE_CREATE_HANDLE(String)
+MAKE_CREATE_HANDLE(RegExp)
+MAKE_CREATE_HANDLE(Object)
+MAKE_CREATE_HANDLE(Array)
+MAKE_CREATE_HANDLE(External)
+MAKE_CREATE_HANDLE(FunctionTemplate)
+MAKE_CREATE_HANDLE(ObjectTemplate)
+MAKE_CREATE_HANDLE(Signature)
+MAKE_CREATE_HANDLE(TypeSwitch)
+MAKE_CREATE_HANDLE(Message)
+MAKE_CREATE_HANDLE(StackTrace)
+MAKE_CREATE_HANDLE(StackFrame)
+MAKE_CREATE_HANDLE(Number)
+MAKE_CREATE_HANDLE(Integer)
+MAKE_CREATE_HANDLE(Uint32)
+
+#undef MAKE_CREATE_HANDLE
+
+
 void Context::Enter() {
   if (IsDeadCheck("v8::Context::Enter()")) return;
   ENTER_V8;
@@ -3857,12 +3918,14 @@ Local<Number> v8::Number::New(double value) {
 
 
 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);
 }