Remove Failure::OutOfMemory propagation and V8::IgnoreOutOfMemoryException.

test/cctest/test-api.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 19314 matching lines @@
     Local<Value> v = CompileRun("22");
     CHECK(v->IsNumber());
     CHECK_EQ(22, static_cast<int>(v->NumberValue()));
   }
   isolate->Dispose();
 }
 
 class InitDefaultIsolateThread : public v8::internal::Thread {
  public:
   enum TestCase {
-    IgnoreOOM,
     SetResourceConstraints,
     SetFatalHandler,
     SetCounterFunction,
     SetCreateHistogramFunction,
     SetAddHistogramSampleFunction
   };
 
   explicit InitDefaultIsolateThread(TestCase testCase)
       : Thread("InitDefaultIsolateThread"),
         testCase_(testCase),
         result_(false) { }
 
   void Run() {
     v8::Isolate* isolate = v8::Isolate::New();
     isolate->Enter();
     switch (testCase_) {
-    case IgnoreOOM:
-      v8::V8::IgnoreOutOfMemoryException();
-      break;
+      case SetResourceConstraints: {
+        static const int K = 1024;
+        v8::ResourceConstraints constraints;
+        constraints.set_max_young_space_size(256 * K);
+        constraints.set_max_old_space_size(4 * K * K);
+        v8::SetResourceConstraints(CcTest::isolate(), &constraints);
+        break;
+      }
 
-    case SetResourceConstraints: {
-      static const int K = 1024;
-      v8::ResourceConstraints constraints;
-      constraints.set_max_young_space_size(256 * K);
-      constraints.set_max_old_space_size(4 * K * K);
-      v8::SetResourceConstraints(CcTest::isolate(), &constraints);
-      break;
-    }
+      case SetFatalHandler:
+        v8::V8::SetFatalErrorHandler(NULL);
+        break;
 
-    case SetFatalHandler:
-      v8::V8::SetFatalErrorHandler(NULL);
-      break;
+      case SetCounterFunction:
+        v8::V8::SetCounterFunction(NULL);
+        break;
 
-    case SetCounterFunction:
-      v8::V8::SetCounterFunction(NULL);
-      break;
+      case SetCreateHistogramFunction:
+        v8::V8::SetCreateHistogramFunction(NULL);
+        break;
 
-    case SetCreateHistogramFunction:
-      v8::V8::SetCreateHistogramFunction(NULL);
-      break;
-
-    case SetAddHistogramSampleFunction:
-      v8::V8::SetAddHistogramSampleFunction(NULL);
-      break;
+      case SetAddHistogramSampleFunction:
+        v8::V8::SetAddHistogramSampleFunction(NULL);
+        break;
     }
     isolate->Exit();
     isolate->Dispose();
     result_ = true;
   }
 
   bool result() { return result_; }
 
  private:
   TestCase testCase_;
   bool result_;
 };
 
 
 static void InitializeTestHelper(InitDefaultIsolateThread::TestCase testCase) {
   InitDefaultIsolateThread thread(testCase);
   thread.Start();
   thread.Join();
   CHECK_EQ(thread.result(), true);
 }
 
 
 TEST(InitializeDefaultIsolateOnSecondaryThread1) {
-  InitializeTestHelper(InitDefaultIsolateThread::IgnoreOOM);
+  InitializeTestHelper(InitDefaultIsolateThread::SetResourceConstraints);
 }
 
 
 TEST(InitializeDefaultIsolateOnSecondaryThread2) {
-  InitializeTestHelper(InitDefaultIsolateThread::SetResourceConstraints);
+  InitializeTestHelper(InitDefaultIsolateThread::SetFatalHandler);
 }
 
 
 TEST(InitializeDefaultIsolateOnSecondaryThread3) {
-  InitializeTestHelper(InitDefaultIsolateThread::SetFatalHandler);
+  InitializeTestHelper(InitDefaultIsolateThread::SetCounterFunction);
 }
 
 
 TEST(InitializeDefaultIsolateOnSecondaryThread4) {
-  InitializeTestHelper(InitDefaultIsolateThread::SetCounterFunction);
+  InitializeTestHelper(InitDefaultIsolateThread::SetCreateHistogramFunction);
 }
 
 
 TEST(InitializeDefaultIsolateOnSecondaryThread5) {
-  InitializeTestHelper(InitDefaultIsolateThread::SetCreateHistogramFunction);
-}
-
-
-TEST(InitializeDefaultIsolateOnSecondaryThread6) {
   InitializeTestHelper(InitDefaultIsolateThread::SetAddHistogramSampleFunction);
 }
 
 
 TEST(StringCheckMultipleContexts) {
   const char* code =
       "(function() { return \"a\".charAt(0); })()";
 
   {
     // Run the code twice in the first context to initialize the call IC.
@@ skipping 2898 matching lines @@
              "f.call(friend);");
   CHECK_EQ(2, named_access_count);
 
   // Test access using Object.setPrototypeOf reflective method.
   named_access_count = 0;
   CompileRun("Object.setPrototypeOf(friend, {});");
   CHECK_EQ(1, named_access_count);
   CompileRun("Object.getPrototypeOf(friend);");
   CHECK_EQ(2, named_access_count);
 }