WIP: Entry realm stack in Blink

third_party/WebKit/Source/bindings/core/v8/V8ScriptRunner.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 525 matching lines @@
   {
     if (ScriptForbiddenScope::isScriptForbidden()) {
       throwScriptForbiddenException(isolate);
       return v8::MaybeLocal<v8::Value>();
     }
     v8::MicrotasksScope microtasksScope(isolate,
                                         v8::MicrotasksScope::kRunMicrotasks);
     probe::ExecuteScript probe(context);
     ThreadDebugger::willExecuteScript(isolate,
                                       script->GetUnboundScript()->GetId());
+    V8PerIsolateData::EntryRealmScope entryRealmScope(
+        V8PerIsolateData::from(isolate), isolate->GetCurrentContext());
     result = script->Run(isolate->GetCurrentContext());
     ThreadDebugger::didExecuteScript(isolate);
   }
 
   CHECK(!isolate->IsDead());
   return result;
 }
 
 v8::MaybeLocal<v8::Value> V8ScriptRunner::compileAndRunInternalScript(
     v8::Local<v8::String> source,
     v8::Isolate* isolate,
     const String& fileName,
     const TextPosition& scriptStartPosition) {
   v8::Local<v8::Script> script;
   if (!V8ScriptRunner::compileScript(
            source, fileName, String(), scriptStartPosition, isolate, nullptr,
            nullptr, nullptr, SharableCrossOrigin, V8CacheOptionsDefault)
            .ToLocal(&script))
     return v8::MaybeLocal<v8::Value>();
 
   TRACE_EVENT0("v8", "v8.run");
   v8::MicrotasksScope microtasksScope(isolate,
                                       v8::MicrotasksScope::kDoNotRunMicrotasks);
+  V8PerIsolateData::EntryRealmScope entryRealmScope(
+      V8PerIsolateData::from(isolate), isolate->GetCurrentContext());
   v8::MaybeLocal<v8::Value> result = script->Run(isolate->GetCurrentContext());
   CHECK(!isolate->IsDead());
   return result;
 }
 
 v8::MaybeLocal<v8::Value> V8ScriptRunner::runCompiledInternalScript(
     v8::Isolate* isolate,
     v8::Local<v8::Script> script) {
   TRACE_EVENT0("v8", "v8.run");
   v8::MicrotasksScope microtasksScope(isolate,
                                       v8::MicrotasksScope::kDoNotRunMicrotasks);
+  V8PerIsolateData::EntryRealmScope entryRealmScope(
+      V8PerIsolateData::from(isolate), isolate->GetCurrentContext());
   v8::MaybeLocal<v8::Value> result = script->Run(isolate->GetCurrentContext());
   CHECK(!isolate->IsDead());
   return result;
 }
 
 v8::MaybeLocal<v8::Value> V8ScriptRunner::callAsConstructor(
     v8::Isolate* isolate,
     v8::Local<v8::Object> constructor,
     ExecutionContext* context,
     int argc,
@@ skipping 16 matching lines @@
   // invocation, change this to use v8::Object instead of
   // v8::Function. All callers use functions because
   // CustomElementRegistry#define's IDL signature is Function.
   CHECK(constructor->IsFunction());
   v8::Local<v8::Function> function = constructor.As<v8::Function>();
 
   v8::MicrotasksScope microtasksScope(isolate,
                                       v8::MicrotasksScope::kRunMicrotasks);
   probe::CallFunction probe(context, function, depth);
   ThreadDebugger::willExecuteScript(isolate, function->ScriptId());
+  V8PerIsolateData::EntryRealmScope entryRealmScope(
+      V8PerIsolateData::from(isolate), isolate->GetCurrentContext());
   v8::MaybeLocal<v8::Value> result =
       constructor->CallAsConstructor(isolate->GetCurrentContext(), argc, argv);
   CHECK(!isolate->IsDead());
   ThreadDebugger::didExecuteScript(isolate);
   return result;
 }
 
 v8::MaybeLocal<v8::Value> V8ScriptRunner::callFunction(
     v8::Local<v8::Function> function,
     ExecutionContext* context,
@@ skipping 19 matching lines @@
   }
 
   DCHECK(!frame || BindingSecurity::shouldAllowAccessToFrame(
                        toLocalDOMWindow(function->CreationContext()), frame,
                        BindingSecurity::ErrorReportOption::DoNotReport));
   CHECK(!ThreadState::current()->isWrapperTracingForbidden());
   v8::MicrotasksScope microtasksScope(isolate,
                                       v8::MicrotasksScope::kRunMicrotasks);
   probe::CallFunction probe(context, function, depth);
   ThreadDebugger::willExecuteScript(isolate, function->ScriptId());
+  V8PerIsolateData::EntryRealmScope entryRealmScope(
+      V8PerIsolateData::from(isolate), isolate->GetCurrentContext());
   v8::MaybeLocal<v8::Value> result =
       function->Call(isolate->GetCurrentContext(), receiver, argc, args);
   CHECK(!isolate->IsDead());
   ThreadDebugger::didExecuteScript(isolate);
 
   return result;
 }
 
 v8::MaybeLocal<v8::Value> V8ScriptRunner::callInternalFunction(
     v8::Local<v8::Function> function,
     v8::Local<v8::Value> receiver,
     int argc,
     v8::Local<v8::Value> args[],
     v8::Isolate* isolate) {
   TRACE_EVENT0("v8", "v8.callFunction");
   CHECK(!ThreadState::current()->isWrapperTracingForbidden());
   v8::MicrotasksScope microtasksScope(isolate,
                                       v8::MicrotasksScope::kDoNotRunMicrotasks);
+  V8PerIsolateData::EntryRealmScope entryRealmScope(
+      V8PerIsolateData::from(isolate), isolate->GetCurrentContext());
   v8::MaybeLocal<v8::Value> result =
       function->Call(isolate->GetCurrentContext(), receiver, argc, args);
   CHECK(!isolate->IsDead());
   return result;
 }
 
 v8::MaybeLocal<v8::Value> V8ScriptRunner::evaluateModule(
     v8::Local<v8::Module> module,
     v8::Local<v8::Context> context,
     v8::Isolate* isolate) {
   TRACE_EVENT0("v8", "v8.evaluateModule");
   v8::MicrotasksScope microtasksScope(isolate,
                                       v8::MicrotasksScope::kRunMicrotasks);
+  V8PerIsolateData::EntryRealmScope entryRealmScope(
+      V8PerIsolateData::from(isolate), context);
   return module->Evaluate(context);
 }
 
 uint32_t V8ScriptRunner::tagForParserCache(
     CachedMetadataHandler* cacheHandler) {
   return cacheTag(CacheTagParser, cacheHandler);
 }
 
 uint32_t V8ScriptRunner::tagForCodeCache(CachedMetadataHandler* cacheHandler) {
   return cacheTag(CacheTagCode, cacheHandler);
@@ skipping 28 matching lines @@
           v8AtomicString(isolate, "((e) => { throw e; })"), origin)
           .ToLocalChecked();
   v8::Local<v8::Function> thrower = runCompiledInternalScript(isolate, script)
                                         .ToLocalChecked()
                                         .As<v8::Function>();
   v8::Local<v8::Value> args[] = {exception};
   callInternalFunction(thrower, thrower, WTF_ARRAY_LENGTH(args), args, isolate);
 }
 
 }  // namespace blink