Support fetching attribute listeners from outside v8 context scopes.

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

 /*
  * Copyright (C) 2006, 2007, 2008, 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:
  *
  *     * 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
@@ skipping 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "bindings/core/v8/V8AbstractEventListener.h"
 
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8Event.h"
 #include "bindings/core/v8/V8EventListenerHelper.h"
 #include "bindings/core/v8/V8EventTarget.h"
 #include "bindings/core/v8/V8HiddenValue.h"
+#include "core/dom/Document.h"
+#include "core/dom/DocumentParser.h"
 #include "core/events/BeforeUnloadEvent.h"
 #include "core/events/Event.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "platform/InstanceCounters.h"
 
 namespace blink {
 
 V8AbstractEventListener::V8AbstractEventListener(bool isAttribute,
                                                  DOMWrapperWorld& world,
                                                  v8::Isolate* isolate)
@@ skipping 144 matching lines @@
 
   EventTarget* target = event->currentTarget();
   v8::Local<v8::Value> value =
       toV8(target, scriptState->context()->Global(), isolate());
   if (value.IsEmpty())
     return v8::Local<v8::Object>();
   return v8::Local<v8::Object>::New(isolate(),
                                     v8::Local<v8::Object>::Cast(value));
 }
 
-bool V8AbstractEventListener::belongsToTheCurrentWorld() const {
-  return ScriptState::hasCurrentScriptState(isolate()) &&
-         &world() == &DOMWrapperWorld::current(isolate());
+bool V8AbstractEventListener::belongsToTheCurrentWorld(
+    ExecutionContext* executionContext) const {
+  if (ScriptState::hasCurrentScriptState(isolate()) &&
+      &world() == &DOMWrapperWorld::current(isolate()))
+    return true;
+  // If currently parsing, the parser could be accessing this listener
+  // outside of any v8 context; check if it belongs to the main world.
+  if (!isolate()->InContext() && executionContext->isDocument()) {

[haraken, 2016/11/11 03:54:40]

Maybe the following looks a bit tidier?

if (ScriptState::hasCurrentScriptState(isolate())) {
  return world() == &DOMWrapperWorld::current(isolate());
}
if (executionContext->isDocument()) {
  Document* document = toDocument(executionContext);
  return isParsing() && world().isMainWorld();
}
return false;

[sof, 2016/11/11 06:27:04]

If the current context is a debugger context, you want this predicate to fail.
That makes things a bit fiddly to get right -- I don't think the above version
handles that case as-wanted.

+    Document* document = toDocument(executionContext);
+    if (document->parser() && document->parser()->isParsing())
+      return world().isMainWorld();
+  }
+  return false;
 }
 
 void V8AbstractEventListener::clearListenerObject() {
   if (!hasExistingListenerObject())
     return;
   m_listener.clear();
   if (m_workerGlobalScope) {
     m_workerGlobalScope->deregisterEventListener(this);
   } else {
     m_keepAlive.clear();
   }
 }
 
 void V8AbstractEventListener::wrapperCleared(
     const v8::WeakCallbackInfo<V8AbstractEventListener>& data) {
   data.GetParameter()->clearListenerObject();
 }
 
 DEFINE_TRACE(V8AbstractEventListener) {
   visitor->trace(m_workerGlobalScope);
   EventListener::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(V8AbstractEventListener) {
   visitor->traceWrappers(m_listener.cast<v8::Value>());
 }
 
 }  // namespace blink