Directly create API functions with readonly prototypes rather than converting. Remove FunctionSetRe…

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 "conversions.h"
 #include "isolate-inl.h"
 #include "macro-assembler.h"
 
@@ skipping 1192 matching lines @@
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
                                         Handle<String> name,
                                         MaybeHandle<Code> code) {
   Handle<Context> context(isolate()->context()->native_context());
   Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name, code);
   ASSERT((info->strict_mode() == SLOPPY) &&
          (map.is_identical_to(isolate()->sloppy_function_map()) ||
           map.is_identical_to(
-              isolate()->sloppy_function_without_prototype_map())));
+              isolate()->sloppy_function_without_prototype_map()) ||
+          map.is_identical_to(
+              isolate()->sloppy_function_with_readonly_prototype_map())));
   return NewFunction(map, info, context);
 }
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<String> name) {
   return NewFunction(
       isolate()->sloppy_function_map(), name, MaybeHandle<Code>());
 }
 
 
 Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name,
                                                         Handle<Code> code) {
   return NewFunction(
       isolate()->sloppy_function_without_prototype_map(), name, code);
 }
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
                                         Handle<Code> code,
-                                        Handle<Object> prototype) {
-  Handle<JSFunction> result = NewFunction(
-      isolate()->sloppy_function_map(), name, code);
+                                        Handle<Object> prototype,
+                                        bool read_only_prototype) {
+  Handle<Map> map = read_only_prototype
+      ? isolate()->sloppy_function_with_readonly_prototype_map()
+      : isolate()->sloppy_function_map();
+  Handle<JSFunction> result = NewFunction(map, name, code);
   result->set_prototype_or_initial_map(*prototype);
   return result;
 }
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
                                         Handle<Code> code,
                                         Handle<Object> prototype,
                                         InstanceType type,
-                                        int instance_size) {
+                                        int instance_size,
+                                        bool read_only_prototype) {
   // Allocate the function
-  Handle<JSFunction> function = NewFunction(name, code, prototype);
+  Handle<JSFunction> function = NewFunction(
+      name, code, prototype, read_only_prototype);
 
   Handle<Map> initial_map = NewMap(
       type, instance_size, GetInitialFastElementsKind());
   if (prototype->IsTheHole() && !function->shared()->is_generator()) {
     prototype = NewFunctionPrototype(function);
   }
   initial_map->set_prototype(*prototype);
   function->set_initial_map(*initial_map);
   initial_map->set_constructor(*function);
 
@@ skipping 836 matching lines @@
       case OuterGlobalObject:
         type = JS_GLOBAL_PROXY_TYPE;
         instance_size += JSGlobalProxy::kSize;
         break;
       default:
         UNREACHABLE();
         type = JS_OBJECT_TYPE;  // Keep the compiler happy.
         break;
     }
 
-    result = NewFunction(empty_string(), code, prototype, type, instance_size);
+    result = NewFunction(empty_string(), code, prototype, type,
+                         instance_size, obj->read_only_prototype());
   }
 
   result->shared()->set_length(obj->length());
   Handle<Object> class_name(obj->class_name(), isolate());
   if (class_name->IsString()) {
     result->shared()->set_instance_class_name(*class_name);
     result->shared()->set_name(*class_name);
   }
   result->shared()->set_function_data(*obj);
   result->shared()->set_construct_stub(*construct_stub);
@@ skipping 207 matching lines @@
   return Handle<Object>::null();
 }
 
 
 Handle<Object> Factory::ToBoolean(bool value) {
   return value ? true_value() : false_value();
 }
 
 
 } }  // namespace v8::internal