WIP: Entry realm stack in Blink

third_party/WebKit/Source/bindings/core/v8/V8PerIsolateData.h

 /*
  * 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 72 matching lines @@
     }
     ~UseCounterDisabledScope() {
       m_perIsolateData->m_useCounterDisabled = m_originalUseCounterDisabled;
     }
 
    private:
     V8PerIsolateData* m_perIsolateData;
     const bool m_originalUseCounterDisabled;
   };
 
+  class EntryRealmScope {
+    STACK_ALLOCATED();
+
+   public:
+    explicit EntryRealmScope(V8PerIsolateData* perIsolateData,
+                             v8::Local<v8::Context> entryContext)
+        : m_perIsolateData(perIsolateData),
+          m_previousEntryContext(m_perIsolateData->m_entryContext) {
+      m_perIsolateData->m_entryContext = entryContext;
+    }
+    ~EntryRealmScope() {
+      m_perIsolateData->m_entryContext = m_previousEntryContext;
+    }
+
+   private:
+    V8PerIsolateData* m_perIsolateData;
+    v8::Local<v8::Context> m_previousEntryContext;
+  };
+
   // Use this class to abstract away types of members that are pointers to core/
   // objects, which are simply owned and released by V8PerIsolateData (see
   // m_threadDebugger for an example).
   class CORE_EXPORT Data {
    public:
     virtual ~Data() = default;
   };
 
   static v8::Isolate* initialize(WebTaskRunner*);
 
@@ skipping 22 matching lines @@
   }
   void setIsHandlingRecursionLevelError(bool value) {
     m_isHandlingRecursionLevelError = value;
   }
 
   bool isReportingException() const { return m_isReportingException; }
   void setReportingException(bool value) { m_isReportingException = value; }
 
   bool isUseCounterDisabled() const { return m_useCounterDisabled; }
 
+  v8::Local<v8::Context> entryContext() {
+    DCHECK(!m_entryContext.IsEmpty());
+    if (m_entryContext.IsEmpty())
+      return isolate()->GetEnteredContext();
+    return m_entryContext;
+  }
+
   V8HiddenValue* hiddenValue() { return m_hiddenValue.get(); }
   V8PrivateProperty* privateProperty() { return m_privateProperty.get(); }
 
   // Accessors to the cache of interface templates.
   v8::Local<v8::FunctionTemplate> findInterfaceTemplate(const DOMWrapperWorld&,
                                                         const void* key);
   void setInterfaceTemplate(const DOMWrapperWorld&,
                             const void* key,
                             v8::Local<v8::FunctionTemplate>);
 
@@ skipping 98 matching lines @@
   std::unique_ptr<V8PrivateProperty> m_privateProperty;
   ScopedPersistent<v8::Value> m_liveRoot;
   RefPtr<ScriptState> m_scriptRegexpScriptState;
 
   bool m_constructorMode;
   friend class ConstructorMode;
 
   bool m_useCounterDisabled;
   friend class UseCounterDisabledScope;
 
+  v8::Local<v8::Context> m_entryContext;
+  friend class EntryRealmScope;
+
   bool m_isHandlingRecursionLevelError;
   bool m_isReportingException;
 
   Vector<std::unique_ptr<EndOfScopeTask>> m_endOfScopeTasks;
   std::unique_ptr<Data> m_threadDebugger;
 
   Persistent<ActiveScriptWrappableSet> m_activeScriptWrappables;
   std::unique_ptr<ScriptWrappableVisitor> m_scriptWrappableVisitor;
 };
 
 }  // namespace blink
 
 #endif  // V8PerIsolateData_h