Removing unneeded TLS fetch from v8::Null and friends

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 297 matching lines @@
 
 
 #ifdef DEBUG
 void ImplementationUtilities::ZapHandleRange(i::Object** begin,
                                              i::Object** end) {
   i::HandleScope::ZapRange(begin, end);
 }
 #endif
 
 
-v8::Handle<v8::Primitive> ImplementationUtilities::Undefined() {

[Vitaly Repeshko, 2011/03/25 13:48:04]

Yes, inlining these is the right thing to do. IIRC ImplementationUtilities were
required to avoid exposing private stuff from some classes. Nothing private is
used here.

-  i::Isolate* isolate = i::Isolate::Current();
-  if (!EnsureInitializedForIsolate(isolate, "v8::Undefined()")) {
-    return v8::Handle<v8::Primitive>();
-  }
-  return v8::Handle<Primitive>(ToApi<Primitive>(
-      isolate->factory()->undefined_value()));
-}
-
-
-v8::Handle<v8::Primitive> ImplementationUtilities::Null() {
-  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() {
-  i::Isolate* isolate = i::Isolate::Current();
-  if (!EnsureInitializedForIsolate(isolate, "v8::True()")) {
-    return v8::Handle<v8::Boolean>();
-  }
-  return v8::Handle<v8::Boolean>(ToApi<Boolean>(
-      isolate->factory()->true_value()));
-}
-
-
-v8::Handle<v8::Boolean> ImplementationUtilities::False() {
-  i::Isolate* isolate = i::Isolate::Current();
-  if (!EnsureInitializedForIsolate(isolate, "v8::False()")) {
-    return v8::Handle<v8::Boolean>();
-  }
-  return v8::Handle<v8::Boolean>(ToApi<Boolean>(
-      isolate->factory()->false_value()));
-}
-
 void V8::SetFlagsFromString(const char* str, int length) {
   i::FlagList::SetFlagsFromString(str, length);
 }
 
 
 void V8::SetFlagsFromCommandLine(int* argc, char** argv, bool remove_flags) {
   i::FlagList::SetFlagsFromCommandLine(argc, argv, remove_flags);
 }
 
 
@@ skipping 39 matching lines @@
                      const char** deps)
     : name_(name),
       source_(source),
       dep_count_(dep_count),
       deps_(deps),
       auto_enable_(false) { }
 
 
 v8::Handle<Primitive> Undefined() {
   i::Isolate* isolate = i::Isolate::Current();
   LOG_API(isolate,  "Undefined");

[Vitaly Repeshko, 2011/03/25 13:48:04]

This logging is useless.

-  return ImplementationUtilities::Undefined();
+  if (!EnsureInitializedForIsolate(isolate, "v8::Undefined()")) {
+    return v8::Handle<v8::Primitive>();
+  }
+  return v8::Handle<Primitive>(ToApi<Primitive>(
+      isolate->factory()->undefined_value()));
 }
 
 
 v8::Handle<Primitive> Null() {
   i::Isolate* isolate = i::Isolate::Current();
   LOG_API(isolate, "Null");
-  return ImplementationUtilities::Null();
+  if (!EnsureInitializedForIsolate(isolate, "v8::Null()"))

[Vitaly Repeshko, 2011/03/25 13:48:04]

Let's make all if-s consistent by using {} when they don't fit in one line.

+      return v8::Handle<v8::Primitive>();
+  return v8::Handle<Primitive>(
+      ToApi<Primitive>(isolate->factory()->null_value()));
 }
 
 
 v8::Handle<Boolean> True() {
   i::Isolate* isolate = i::Isolate::Current();
   LOG_API(isolate, "True");
-  return ImplementationUtilities::True();
+  if (!EnsureInitializedForIsolate(isolate, "v8::True()"))
+      return v8::Handle<Boolean>();
+  return v8::Handle<Boolean>(
+      ToApi<Boolean>(isolate->factory()->true_value()));
 }
 
 
 v8::Handle<Boolean> False() {
   i::Isolate* isolate = i::Isolate::Current();
   LOG_API(isolate, "False");
-  return ImplementationUtilities::False();
+  if (!EnsureInitializedForIsolate(isolate, "v8::False()"))
+      return v8::Handle<Boolean>();
+  return v8::Handle<Boolean>(
+      ToApi<Boolean>(isolate->factory()->false_value()));
 }
 
 
 ResourceConstraints::ResourceConstraints()
   : max_young_space_size_(0),
     max_old_space_size_(0),
     max_executable_size_(0),
     stack_limit_(NULL) { }
 
 
@@ skipping 4825 matching lines @@
     case i::HeapGraphEdge::kProperty:
     case i::HeapGraphEdge::kShortcut:
       return Handle<String>(ToApi<String>(isolate->factory()->LookupAsciiSymbol(
           edge->name())));
     case i::HeapGraphEdge::kElement:
     case i::HeapGraphEdge::kHidden:
       return Handle<Number>(ToApi<Number>(isolate->factory()->NewNumberFromInt(
           edge->index())));
     default: UNREACHABLE();
   }
-  return ImplementationUtilities::Undefined();
+  return v8::Undefined();
 }
 
 
 const HeapGraphNode* HeapGraphEdge::GetFromNode() const {
   i::Isolate* isolate = i::Isolate::Current();
   IsDeadCheck(isolate, "v8::HeapGraphEdge::GetFromNode");
   const i::HeapEntry* from = ToInternal(this)->From();
   return reinterpret_cast<const HeapGraphNode*>(from);
 }
 
@@ skipping 428 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