Revert "Handlify Runtime::InitializeIntrinsicFunctionNames."

src/factory.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "factory.h"
 
 #include "isolate-inl.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 1300 matching lines @@
   Handle<Map> map = NewMap(JS_MODULE_TYPE, JSModule::kSize);
   // Allocate the object based on the map.
   Handle<JSModule> module =
       Handle<JSModule>::cast(NewJSObjectFromMap(map, TENURED));
   module->set_context(*context);
   module->set_scope_info(*scope_info);
   return module;
 }
 
 
+// TODO(mstarzinger): Temporary wrapper until handlified.
+static Handle<NameDictionary> NameDictionaryAdd(Handle<NameDictionary> dict,
+                                                Handle<Name> name,
+                                                Handle<Object> value,
+                                                PropertyDetails details) {
+  CALL_HEAP_FUNCTION(dict->GetIsolate(),
+                     dict->Add(*name, *value, details),
+                     NameDictionary);
+}
+
+
 static Handle<GlobalObject> NewGlobalObjectFromMap(Isolate* isolate,
                                                    Handle<Map> map) {
   CALL_HEAP_FUNCTION(isolate,
                      isolate->heap()->Allocate(*map, OLD_POINTER_SPACE),
                      GlobalObject);
 }
 
 
 Handle<GlobalObject> Factory::NewGlobalObject(Handle<JSFunction> constructor) {
   ASSERT(constructor->has_initial_map());
@@ skipping 22 matching lines @@
   // The global object might be created from an object template with accessors.
   // Fill these accessors into the dictionary.
   Handle<DescriptorArray> descs(map->instance_descriptors());
   for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
     PropertyDetails details = descs->GetDetails(i);
     ASSERT(details.type() == CALLBACKS);  // Only accessors are expected.
     PropertyDetails d = PropertyDetails(details.attributes(), CALLBACKS, i + 1);
     Handle<Name> name(descs->GetKey(i));
     Handle<Object> value(descs->GetCallbacksObject(i), isolate());
     Handle<PropertyCell> cell = NewPropertyCell(value);
-    NameDictionary::Add(dictionary, name, cell, d);
+    NameDictionaryAdd(dictionary, name, cell, d);
   }
 
   // Allocate the global object and initialize it with the backing store.
   Handle<GlobalObject> global = NewGlobalObjectFromMap(isolate(), map);
   isolate()->heap()->InitializeJSObjectFromMap(*global, *dictionary, *map);
 
   // Create a new map for the global object.
   Handle<Map> new_map = Map::CopyDropDescriptors(map);
   new_map->set_dictionary_map(true);
 
@@ skipping 594 matching lines @@
   if (String::Equals(name, infinity_string())) return infinity_value();
   return Handle<Object>::null();
 }
 
 
 Handle<Object> Factory::ToBoolean(bool value) {
   return value ? true_value() : false_value();
 }
 
 } }  // namespace v8::internal