Allow three runtime call attempts before throwing an out of...

src/handles.cc

 // Copyright 2006-2008 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 21 matching lines @@
 #include "bootstrapper.h"
 #include "compiler.h"
 #include "debug.h"
 #include "execution.h"
 #include "global-handles.h"
 #include "natives.h"
 #include "runtime.h"
 
 namespace v8 { namespace internal {
 
-#define CALL_GC(RESULT)                                             \
-  {                                                                 \
-    Failure* __failure__ = Failure::cast(RESULT);                   \
-    if (!Heap::CollectGarbage(__failure__->requested(),             \
-                              __failure__->allocation_space())) {   \
-       /* TODO(1181417): Fix this. */                               \
-       V8::FatalProcessOutOfMemory("Handles");                      \
-    }                                                               \
-  }
-
 
 Handle<FixedArray> AddKeysFromJSArray(Handle<FixedArray> content,
                                       Handle<JSArray> array) {
   CALL_HEAP_FUNCTION(content->AddKeysFromJSArray(*array), FixedArray);
 }
 
 
 Handle<FixedArray> UnionOfKeys(Handle<FixedArray> first,
                                Handle<FixedArray> second) {
   CALL_HEAP_FUNCTION(first->UnionOfKeys(*second), FixedArray);
@@ skipping 214 matching lines @@
   // Create a new weak global handle and use it to cache the wrapper
   // for future use. The cache will automatically be cleared by the
   // garbage collector when it is not used anymore.
   Handle<Object> handle = GlobalHandles::Create(*result);
   GlobalHandles::MakeWeak(handle.location(), NULL, &ClearWrapperCache);
   script->wrapper()->set_proxy(reinterpret_cast<Address>(handle.location()));
   return result;
 }
 
 
-#undef CALL_HEAP_FUNCTION
-#undef CALL_GC
-
-
 // Compute the property keys from the interceptor.
 v8::Handle<v8::Array> GetKeysForNamedInterceptor(Handle<JSObject> receiver,
                                                  Handle<JSObject> object) {
   Handle<InterceptorInfo> interceptor(object->GetNamedInterceptor());
   Handle<Object> data(interceptor->data());
   v8::AccessorInfo info(
     v8::Utils::ToLocal(receiver),
     v8::Utils::ToLocal(data),
     v8::Utils::ToLocal(object));
   v8::Handle<v8::Array> result;
@@ skipping 240 matching lines @@
                Handle<Context> compile_context,
                Handle<Context> function_context) {
   Handle<FixedArray> arr = Factory::NewFixedArray(3);
   arr->set(0, Smi::FromInt(index));
   arr->set(1, *compile_context);  // Compile in this context
   arr->set(2, *function_context);  // Set function context to this
   fun->shared()->set_lazy_load_data(*arr);
 }
 
 } }  // namespace v8::internal