Change OOMs to raise custom exception rather than breakpoint on Windows.

third_party/WebKit/Source/bindings/core/v8/V8Initializer.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 77 matching lines @@
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 static void reportFatalErrorInMainThread(const char* location, const char* message)
 {
     int memoryUsageMB = Platform::current()->actualMemoryUsageMB();
     printf("V8 error: %s (%s).  Current memory usage: %d MB\n", message, location, memoryUsageMB);
     CRASH();
 }
-
+/*

[haraken, 2016/07/11 23:06:35]

Should this code be commented out?

[Will Harris, 2016/07/11 23:11:20]

yeah I can't call this until the API exists in V8 and that is in another CL that
will have to be committed before this one (I haven't uploaded it yet).

+static void reportOOMErrorInMainThread(const char* location, bool isJsHeap)
+{
+    int memoryUsageMB = Platform::current()->actualMemoryUsageMB();
+    printf("V8 %s OOM: (%s).  Current memory usage: %d MB\n", isJsHeap ? "javascript" : "process", location, memoryUsageMB);
+    OOM_CRASH();
+}
+*/
 static String extractMessageForConsole(v8::Isolate* isolate, v8::Local<v8::Value> data)
 {
     if (V8DOMWrapper::isWrapper(isolate, data)) {
         v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(data);
         const WrapperTypeInfo* type = toWrapperTypeInfo(obj);
         if (V8DOMException::wrapperTypeInfo.isSubclass(type)) {
             DOMException* exception = V8DOMException::toImpl(obj);
             if (exception && !exception->messageForConsole().isEmpty())
                 return exception->toStringForConsole();
         }
@@ skipping 240 matching lines @@
     WTF::ArrayBufferContents::initialize(adjustAmountOfExternalAllocatedMemory);
 
     DEFINE_STATIC_LOCAL(ArrayBufferAllocator, arrayBufferAllocator, ());
     auto v8ExtrasMode = RuntimeEnabledFeatures::experimentalV8ExtrasEnabled() ? gin::IsolateHolder::kStableAndExperimentalV8Extras : gin::IsolateHolder::kStableV8Extras;
     gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode, v8ExtrasMode, &arrayBufferAllocator);
 
     v8::Isolate* isolate = V8PerIsolateData::initialize();
 
     initializeV8Common(isolate);
 
+//    isolate->SetOOMErrorHandler(reportOOMErrorInMainThread);
     isolate->SetFatalErrorHandler(reportFatalErrorInMainThread);
     isolate->AddMessageListener(messageHandlerInMainThread);
     isolate->SetFailedAccessCheckCallbackFunction(failedAccessCheckCallbackInMainThread);
     isolate->SetAllowCodeGenerationFromStringsCallback(codeGenerationCheckCallbackInMainThread);
 
     if (RuntimeEnabledFeatures::v8IdleTasksEnabled()) {
         WebScheduler* scheduler = Platform::current()->currentThread()->scheduler();
         V8PerIsolateData::enableIdleTasks(isolate, wrapUnique(new V8IdleTaskRunner(scheduler)));
     }
 
@@ skipping 76 matching lines @@
 
     isolate->AddMessageListener(messageHandlerInWorker);
     isolate->SetFatalErrorHandler(reportFatalErrorInWorker);
 
     uint32_t here;
     isolate->SetStackLimit(reinterpret_cast<uintptr_t>(&here - kWorkerMaxStackSize / sizeof(uint32_t*)));
     isolate->SetPromiseRejectCallback(promiseRejectHandlerInWorker);
 }
 
 } // namespace blink