Optimized nodeType dom binding by removing HandleScope and the preparation of ordinary c function c…

src/api.cc

 // Copyright 2012 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 "src/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 907 matching lines @@
 }
 
 
 Local<AccessorSignature> AccessorSignature::New(
     Isolate* isolate,
     Handle<FunctionTemplate> receiver) {
   return Utils::AccessorSignatureToLocal(Utils::OpenHandle(*receiver));
 }
 
 
+void Accessor::setOptimizeLevel(AccessorOptimizeLevel jit) {
+  Utils::OpenHandle(this)->set_can_fast_call(jit != kOptimizeNone);
+}
+
+
 template<typename Operation>
 static Local<Operation> NewDescriptor(
     Isolate* isolate,
     const i::DeclaredAccessorDescriptorData& data,
     Data* previous_descriptor) {
   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
   i::Handle<i::DeclaredAccessorDescriptor> previous =
       i::Handle<i::DeclaredAccessorDescriptor>();
   if (previous_descriptor != NULL) {
     previous = Utils::OpenHandle(
@@ skipping 348 matching lines @@
 // TODO(dcarney): remove this with ObjectTemplate::SetAccessor
 static inline i::Handle<i::TemplateInfo> GetTemplateInfo(
     i::Isolate* isolate,
     ObjectTemplate* object_template) {
   EnsureConstructor(isolate, object_template);
   return Utils::OpenHandle(object_template);
 }
 
 
 template<typename Getter, typename Setter, typename Data, typename Template>
-static bool TemplateSetAccessor(
+static inline Local<Accessor> TemplateSetAccessorEx(
     Template* template_obj,
     v8::Local<Name> name,
     Getter getter,
     Setter setter,
     Data data,
     AccessControl settings,
     PropertyAttribute attribute,
     v8::Local<AccessorSignature> signature) {
   i::Isolate* isolate = Utils::OpenHandle(template_obj)->GetIsolate();
   ENTER_V8(isolate);
   i::HandleScope scope(isolate);
   i::Handle<i::AccessorInfo> obj = MakeAccessorInfo(
       name, getter, setter, data, settings, attribute, signature);
-  if (obj.is_null()) return false;
+  if (obj.is_null()) return Local<Accessor>();
+  obj->set_can_fast_call(false);
   i::Handle<i::TemplateInfo> info = GetTemplateInfo(isolate, template_obj);
   AddPropertyToTemplate(info, obj);
-  return true;
+  return Utils::ToLocal(scope.CloseAndEscape(obj));
+}
+
+template<typename Getter, typename Setter, typename Data, typename Template>
+static bool TemplateSetAccessor(
+    Template* template_obj,
+    v8::Local<Name> name,
+    Getter getter,
+    Setter setter,
+    Data data,
+    AccessControl settings,
+    PropertyAttribute attribute,
+    v8::Local<AccessorSignature> signature) {
+    return (!(TemplateSetAccessorEx(
+      template_obj, name, getter, setter,
+      data, settings, attribute, signature).IsEmpty()));
 }
 
 
 bool Template::SetDeclaredAccessor(
     Local<Name> name,
     Local<DeclaredAccessorDescriptor> descriptor,
     PropertyAttribute attribute,
     Local<AccessorSignature> signature,
     AccessControl settings) {
   void* null = NULL;
@@ skipping 30 matching lines @@
                                  AccessorGetterCallback getter,
                                  AccessorSetterCallback setter,
                                  v8::Handle<Value> data,
                                  AccessControl settings,
                                  PropertyAttribute attribute,
                                  v8::Handle<AccessorSignature> signature) {
   TemplateSetAccessor(
       this, name, getter, setter, data, settings, attribute, signature);
 }
 
+Local<Accessor> ObjectTemplate::SetAccessorEx(v8::Handle<String> name,
+                                 AccessorGetterCallback getter,
+                                 AccessorSetterCallback setter,
+                                 v8::Handle<Value> data,
+                                 AccessControl settings,
+                                 PropertyAttribute attribute,
+                                 v8::Handle<AccessorSignature> signature) {
+  return TemplateSetAccessorEx(
+      this, name, getter, setter, data, settings, attribute, signature);
+}
 
 void ObjectTemplate::SetAccessor(v8::Handle<Name> name,
                                  AccessorNameGetterCallback getter,
                                  AccessorNameSetterCallback setter,
                                  v8::Handle<Value> data,
                                  AccessControl settings,
                                  PropertyAttribute attribute,
                                  v8::Handle<AccessorSignature> signature) {
   TemplateSetAccessor(
       this, name, getter, setter, data, settings, attribute, signature);
@@ skipping 6364 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal