Revert of Use v8::MicrotasksScope internally in V8RecursionScope.

third_party/WebKit/Source/bindings/core/v8/V8PerIsolateData.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 12 matching lines @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "bindings/core/v8/V8PerIsolateData.h"
 
 #include "bindings/core/v8/DOMDataStore.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8HiddenValue.h"
 #include "bindings/core/v8/V8ObjectConstructor.h"
+#include "bindings/core/v8/V8RecursionScope.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/frame/Deprecation.h"
 #include "core/inspector/MainThreadDebugger.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "public/platform/Platform.h"
 #include "wtf/LeakAnnotations.h"
 #include "wtf/MainThread.h"
 
 namespace blink {
 
 static V8PerIsolateData* mainThreadPerIsolateData = 0;
 
 static void beforeCallEnteredCallback(v8::Isolate* isolate)
 {
     RELEASE_ASSERT(!ScriptForbiddenScope::isScriptForbidden());
 }
 
 static void microtasksCompletedCallback(v8::Isolate* isolate)
 {
     V8PerIsolateData::from(isolate)->runEndOfScopeTasks();
 }
 
+#if ENABLE(ASSERT)
+static void assertV8RecursionScope(v8::Isolate* isolate)
+{
+    ASSERT(V8RecursionScope::properlyUsed(isolate));
+}
+
+static bool runningUnitTest()
+{
+    return Platform::current()->unitTestSupport();
+}
+#endif
+
 static void useCounterCallback(v8::Isolate* isolate, v8::Isolate::UseCounterFeature feature)
 {
     UseCounter::Feature blinkFeature;
     bool deprecated = false;
     switch (feature) {
     case v8::Isolate::kUseAsm:
         blinkFeature = UseCounter::UseAsm;
         break;
     case v8::Isolate::kBreakIterator:
         blinkFeature = UseCounter::BreakIterator;
@@ skipping 58 matching lines @@
         // does not know about. It's harmless.
         return;
     }
     if (deprecated)
         Deprecation::countDeprecation(currentExecutionContext(isolate), blinkFeature);
     else
         UseCounter::count(currentExecutionContext(isolate), blinkFeature);
 }
 
 V8PerIsolateData::V8PerIsolateData()
-    : m_isolateHolder(adoptPtr(new gin::IsolateHolder()))
+    : m_destructionPending(false)
+    , m_isolateHolder(adoptPtr(new gin::IsolateHolder()))
     , m_stringCache(adoptPtr(new StringCache(isolate())))
     , m_hiddenValue(V8HiddenValue::create())
     , m_constructorMode(ConstructorMode::CreateNewObject)
+    , m_recursionLevel(0)
     , m_isHandlingRecursionLevelError(false)
     , m_isReportingException(false)
+#if ENABLE(ASSERT)
+    , m_internalScriptRecursionLevel(0)
+#endif
+    , m_performingMicrotaskCheckpoint(false)
 {
     // FIXME: Remove once all v8::Isolate::GetCurrent() calls are gone.
     isolate()->Enter();
+#if ENABLE(ASSERT)
+    if (!runningUnitTest())
+        isolate()->AddCallCompletedCallback(&assertV8RecursionScope);
+#endif
     isolate()->AddBeforeCallEnteredCallback(&beforeCallEnteredCallback);
     isolate()->AddMicrotasksCompletedCallback(&microtasksCompletedCallback);
     if (isMainThread())
         mainThreadPerIsolateData = this;
     isolate()->SetUseCounterCallback(&useCounterCallback);
 }
 
 V8PerIsolateData::~V8PerIsolateData()
 {
 }
@@ skipping 24 matching lines @@
         m_liveRoot.set(isolate(), v8::Null(isolate()));
     return m_liveRoot.getUnsafe();
 }
 
 // willBeDestroyed() clear things that should be cleared before
 // ThreadState::detach() gets called.
 void V8PerIsolateData::willBeDestroyed(v8::Isolate* isolate)
 {
     V8PerIsolateData* data = from(isolate);
 
+    ASSERT(!data->m_destructionPending);
+    data->m_destructionPending = true;
+
     data->m_threadDebugger.clear();
     // Clear any data that may have handles into the heap,
     // prior to calling ThreadState::detach().
     data->clearEndOfScopeTasks();
 }
 
 // destroy() clear things that should be cleared after ThreadState::detach()
 // gets called but before the Isolate exits.
 void V8PerIsolateData::destroy(v8::Isolate* isolate)
 {
+#if ENABLE(ASSERT)
+    if (!runningUnitTest())
+        isolate->RemoveCallCompletedCallback(&assertV8RecursionScope);
+#endif
     isolate->RemoveBeforeCallEnteredCallback(&beforeCallEnteredCallback);
     isolate->RemoveMicrotasksCompletedCallback(&microtasksCompletedCallback);
     V8PerIsolateData* data = from(isolate);
 
     // Clear everything before exiting the Isolate.
     if (data->m_scriptRegexpScriptState)
         data->m_scriptRegexpScriptState->disposePerContextData();
     data->m_liveRoot.clear();
     data->m_hiddenValue.clear();
     data->m_stringCache->dispose();
@@ skipping 116 matching lines @@
     ASSERT(!m_threadDebugger);
     m_threadDebugger = std::move(threadDebugger);
 }
 
 ThreadDebugger* V8PerIsolateData::threadDebugger()
 {
     return m_threadDebugger.get();
 }
 
 } // namespace blink