Callers of ElementsAccessor::AddElementsToFixedArray(), ElementsAccessor::HasElement() and Elements…

src/handles.cc

 // Copyright 2012 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 106 matching lines @@
 Address HandleScope::current_next_address(Isolate* isolate) {
   return reinterpret_cast<Address>(&isolate->handle_scope_data()->next);
 }
 
 
 Address HandleScope::current_limit_address(Isolate* isolate) {
   return reinterpret_cast<Address>(&isolate->handle_scope_data()->limit);
 }
 
 
-Handle<FixedArray> AddKeysFromJSArray(Handle<FixedArray> content,
-                                      Handle<JSArray> array) {
-  CALL_HEAP_FUNCTION(content->GetIsolate(),
-                     content->AddKeysFromJSArray(*array), FixedArray);
-}
-
-
-Handle<FixedArray> UnionOfKeys(Handle<FixedArray> first,
-                               Handle<FixedArray> second) {
-  CALL_HEAP_FUNCTION(first->GetIsolate(),
-                     first->UnionOfKeys(*second), FixedArray);
-}
-
-
 Handle<JSGlobalProxy> ReinitializeJSGlobalProxy(
     Handle<JSFunction> constructor,
     Handle<JSGlobalProxy> global) {
   CALL_HEAP_FUNCTION(
       constructor->GetIsolate(),
       constructor->GetHeap()->ReinitializeJSGlobalProxy(*constructor, *global),
       JSGlobalProxy);
 }
 
 
@@ skipping 354 matching lines @@
     if (p->IsJSProxy()) {
       Handle<JSProxy> proxy(JSProxy::cast(*p), isolate);
       Handle<Object> args[] = { proxy };
       Handle<Object> names = Execution::Call(isolate,
                                              isolate->proxy_enumerate(),
                                              object,
                                              ARRAY_SIZE(args),
                                              args,
                                              threw);
       if (*threw) return content;
-      content = AddKeysFromJSArray(content, Handle<JSArray>::cast(names));
+      content = FixedArray::AddKeysFromJSArray(content,
+                                               Handle<JSArray>::cast(names));
       break;
     }
 
     Handle<JSObject> current(JSObject::cast(*p), isolate);
 
     // Check access rights if required.
     if (current->IsAccessCheckNeeded() &&
         !isolate->MayNamedAccessWrapper(current,
                                         isolate->factory()->undefined_value(),
                                         v8::ACCESS_KEYS)) {
       isolate->ReportFailedAccessCheckWrapper(current, v8::ACCESS_KEYS);
       if (isolate->has_scheduled_exception()) {
         isolate->PromoteScheduledException();
         *threw = true;
       }
       break;
     }
 
     // Compute the element keys.
     Handle<FixedArray> element_keys =
         isolate->factory()->NewFixedArray(current->NumberOfEnumElements());
     current->GetEnumElementKeys(*element_keys);
-    content = UnionOfKeys(content, element_keys);
+    content = FixedArray::UnionOfKeys(content, element_keys);
     ASSERT(ContainsOnlyValidKeys(content));
 
     // Add the element keys from the interceptor.
     if (current->HasIndexedInterceptor()) {
       v8::Handle<v8::Array> result =
           GetKeysForIndexedInterceptor(object, current);
       if (!result.IsEmpty())
-        content = AddKeysFromJSArray(content, v8::Utils::OpenHandle(*result));
+        content = FixedArray::AddKeysFromJSArray(
+            content, v8::Utils::OpenHandle(*result));
       ASSERT(ContainsOnlyValidKeys(content));
     }
 
     // We can cache the computed property keys if access checks are
     // not needed and no interceptors are involved.
     //
     // We do not use the cache if the object has elements and
     // therefore it does not make sense to cache the property names
     // for arguments objects.  Arguments objects will always have
     // elements.
     // Wrapped strings have elements, but don't have an elements
     // array or dictionary.  So the fast inline test for whether to
     // use the cache says yes, so we should not create a cache.
     bool cache_enum_keys =
         ((current->map()->constructor() != *arguments_function) &&
          !current->IsJSValue() &&
          !current->IsAccessCheckNeeded() &&
          !current->HasNamedInterceptor() &&
          !current->HasIndexedInterceptor());
     // Compute the property keys and cache them if possible.
-    content =
-        UnionOfKeys(content, GetEnumPropertyKeys(current, cache_enum_keys));
+    content = FixedArray::UnionOfKeys(
+        content, GetEnumPropertyKeys(current, cache_enum_keys));
     ASSERT(ContainsOnlyValidKeys(content));
 
     // Add the property keys from the interceptor.
     if (current->HasNamedInterceptor()) {
       v8::Handle<v8::Array> result =
           GetKeysForNamedInterceptor(object, current);
       if (!result.IsEmpty())
-        content = AddKeysFromJSArray(content, v8::Utils::OpenHandle(*result));
+        content = FixedArray::AddKeysFromJSArray(
+            content, v8::Utils::OpenHandle(*result));
       ASSERT(ContainsOnlyValidKeys(content));
     }
 
     // If we only want local properties we bail out after the first
     // iteration.
     if (type == LOCAL_ONLY)
       break;
   }
   return content;
 }
@@ skipping 167 matching lines @@
                                    Handle<Code> code) {
   heap->EnsureWeakObjectToCodeTable();
   Handle<DependentCode> dep(heap->LookupWeakObjectToCodeDependency(*object));
   dep = DependentCode::Insert(dep, DependentCode::kWeaklyEmbeddedGroup, code);
   CALL_HEAP_FUNCTION_VOID(heap->isolate(),
                           heap->AddWeakObjectToCodeDependency(*object, *dep));
 }
 
 
 } }  // namespace v8::internal