Revert "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 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 IgnoreOOM:
+      v8::V8::IgnoreOutOfMemoryException();
+      break;
 
-      case SetFatalHandler:
-        v8::V8::SetFatalErrorHandler(NULL);
-        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 SetCounterFunction:
-        v8::V8::SetCounterFunction(NULL);
-        break;
+    case SetFatalHandler:
+      v8::V8::SetFatalErrorHandler(NULL);
+      break;
 
-      case SetCreateHistogramFunction:
-        v8::V8::SetCreateHistogramFunction(NULL);
-        break;
+    case SetCounterFunction:
+      v8::V8::SetCounterFunction(NULL);
+      break;
 
-      case SetAddHistogramSampleFunction:
-        v8::V8::SetAddHistogramSampleFunction(NULL);
-        break;
+    case SetCreateHistogramFunction:
+      v8::V8::SetCreateHistogramFunction(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);
+}
+
+
+TEST(InitializeDefaultIsolateOnSecondaryThread2) {
   InitializeTestHelper(InitDefaultIsolateThread::SetResourceConstraints);
 }
 
 
-TEST(InitializeDefaultIsolateOnSecondaryThread2) {
+TEST(InitializeDefaultIsolateOnSecondaryThread3) {
   InitializeTestHelper(InitDefaultIsolateThread::SetFatalHandler);
 }
 
 
-TEST(InitializeDefaultIsolateOnSecondaryThread3) {
+TEST(InitializeDefaultIsolateOnSecondaryThread4) {
   InitializeTestHelper(InitDefaultIsolateThread::SetCounterFunction);
 }
 
 
-TEST(InitializeDefaultIsolateOnSecondaryThread4) {
+TEST(InitializeDefaultIsolateOnSecondaryThread5) {
   InitializeTestHelper(InitDefaultIsolateThread::SetCreateHistogramFunction);
 }
 
 
-TEST(InitializeDefaultIsolateOnSecondaryThread5) {
+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 2879 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);
 }