Dispatching errors across iframes don't match webplatform tests

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 127 matching lines @@
   ExecutionContext* context = scriptState->getExecutionContext();
   std::unique_ptr<SourceLocation> location =
       SourceLocation::fromMessage(isolate, message, context);
 
   AccessControlStatus accessControlStatus = NotSharableCrossOrigin;
   if (message->IsOpaque())
     accessControlStatus = OpaqueResource;
   else if (message->IsSharedCrossOrigin())
     accessControlStatus = SharableCrossOrigin;
 
+  ScriptState* errorEventScriptState = context->errorEventScriptState();

[haraken, 2016/10/15 02:25:25]

Add a comment about what this is doing.

[dominicc (has gone to gerrit), 2016/10/16 08:45:57]

This could be simpler if the errorEventScriptState always returns a script
state--one for the context if one was not explicitly set.

It may make sense to use context and not script state here since that's lighter.
haraken WDYT?

+  if (!errorEventScriptState)
+      errorEventScriptState = scriptState;
+
+  if (!errorEventScriptState->contextIsValid())
+      return;
+
+  ExecutionContext* errorEventContext =
+      errorEventScriptState->getExecutionContext();
   ErrorEvent* event =
       ErrorEvent::create(toCoreStringWithNullCheck(message->Get()),
-                         std::move(location), &scriptState->world());
+                         std::move(location), &errorEventScriptState->world());
 
   String messageForConsole = extractMessageForConsole(isolate, data);
   if (!messageForConsole.isEmpty())
     event->setUnsanitizedMessage("Uncaught " + messageForConsole);
 
   // This method might be called while we're creating a new context. In this
   // case, we avoid storing the exception object, as we can't create a wrapper
   // during context creation.
   // FIXME: Can we even get here during initialization now that we bail out when
   // GetEntered returns an empty handle?
-  if (context->isDocument()) {
-    LocalFrame* frame = toDocument(context)->frame();
-    if (frame && frame->script().existingWindowProxy(scriptState->world())) {
+  if (errorEventContext->isDocument()) {
+    LocalFrame* frame = toDocument(errorEventContext)->frame();
+    if (frame && frame->script().existingWindowProxy(errorEventScriptState->world())) {
       V8ErrorHandler::storeExceptionOnErrorEventWrapper(
-          scriptState, event, data, scriptState->context()->Global());
+          errorEventScriptState, event, data, errorEventScriptState->context()->Global());
     }
   }
 
-  if (scriptState->world().isPrivateScriptIsolatedWorld()) {
+  if (errorEventScriptState->world().isPrivateScriptIsolatedWorld()) {
     // We allow a private script to dispatch error events even in a
     // EventDispatchForbiddenScope scope.  Without having this ability, it's
     // hard to debug the private script because syntax errors in the private
     // script are not reported to console (the private script just crashes
     // silently).  Allowing error events in private scripts is safe because
     // error events don't propagate to other isolated worlds (which means that
     // the error events won't fire any event listeners in user's scripts).
     EventDispatchForbiddenScope::AllowUserAgentEvents allowUserAgentEvents;
-    context->dispatchErrorEvent(event, accessControlStatus);
+    errorEventContext->dispatchErrorEvent(event, accessControlStatus);
   } else {
-    context->dispatchErrorEvent(event, accessControlStatus);
+    errorEventContext->dispatchErrorEvent(event, accessControlStatus);
   }
 }
 
 namespace {
 
 static RejectedPromises& rejectedPromisesOnMainThread() {
   ASSERT(isMainThread());
   DEFINE_STATIC_LOCAL(RefPtr<RejectedPromises>, rejectedPromises,
                       (RejectedPromises::create()));
   return *rejectedPromises;
@@ skipping 310 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