DevTools: [console] Logged promise rejections do not change state once handled

Source/bindings/core/v8/RejectedPromises.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "bindings/core/v8/RejectedPromises.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/ScriptArguments.h"
 
 namespace blink {
 
+static const unsigned maxReportedHandlersPendingResolution = 1000;
+
 class RejectedPromises::Message final : public NoBaseWillBeGarbageCollectedFinalized<RejectedPromises::Message> {
 public:
     static PassOwnPtrWillBeRawPtr<Message> create(const ScriptValue& promise, const ScriptValue& exception, const String& errorMessage, const String& resourceName, int scriptId, int lineNumber, int columnNumber, PassRefPtrWillBeRawPtr<ScriptCallStack> callStack)
     {
         return adoptPtrWillBeNoop(new Message(promise, exception, errorMessage, resourceName, scriptId, lineNumber, columnNumber, callStack));
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_callStack);
     }
 
 private:
     Message(const ScriptValue& promise, const ScriptValue& exception, const String& errorMessage, const String& resourceName, int scriptId, int lineNumber, int columnNumber, PassRefPtrWillBeRawPtr<ScriptCallStack> callStack)
         : m_promise(promise)
         , m_exception(exception)
         , m_errorMessage(errorMessage)
         , m_resourceName(resourceName)
         , m_scriptId(scriptId)
         , m_lineNumber(lineNumber)
         , m_columnNumber(columnNumber)
         , m_callStack(callStack)
+        , m_consoleMessageId(0)
     {
     }
 
     friend class RejectedPromises;
 
     const ScriptValue m_promise;
     const ScriptValue m_exception;
     const String m_errorMessage;
     const String m_resourceName;
     const int m_scriptId;
     const int m_lineNumber;
     const int m_columnNumber;
     const RefPtrWillBeMember<ScriptCallStack> m_callStack;
+    unsigned m_consoleMessageId;
 };
 
 RejectedPromises::RejectedPromises()
 {
 }
 
 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(RejectedPromises);
 
 DEFINE_TRACE(RejectedPromises)
 {
     visitor->trace(m_queue);
 }
 
-void RejectedPromises::add(ScriptState* scriptState, v8::PromiseRejectMessage data, const String& errorMessage, const String& resourceName, int scriptId, int lineNumber, int columnNumber, PassRefPtrWillBeRawPtr<ScriptCallStack> callStack)
+void RejectedPromises::rejectedWithNoHandler(ScriptState* scriptState, v8::PromiseRejectMessage data, const String& errorMessage, const String& resourceName, int scriptId, int lineNumber, int columnNumber, PassRefPtrWillBeRawPtr<ScriptCallStack> callStack)
 {
     v8::Handle<v8::Promise> promise = data.GetPromise();
     OwnPtrWillBeRawPtr<Message> message = Message::create(ScriptValue(scriptState, promise), ScriptValue(scriptState, data.GetValue()), errorMessage, resourceName, scriptId, lineNumber, columnNumber, callStack);
 
     m_queue.append(message.release());
 }
 
+void RejectedPromises::handlerAdded(v8::PromiseRejectMessage data)
+{
+    // First look it up in the pending messages and fast return, it'll be covered by processQueue().
+    for (auto it = m_queue.begin(); it != m_queue.end(); ++it) {
+        ScriptState* scriptState = (*it)->m_promise.scriptState();
+        if (!scriptState->contextIsValid())
+            continue;
+
+        ScriptState::Scope scope(scriptState);
+        v8::Handle<v8::Value> promise = (*it)->m_promise.v8Value();
+        if (promise == data.GetPromise())
+            return;
+    }
+
+    // Then look it up in the reported errors.
+    for (auto it = m_reportedAsErrors.begin(); it != m_reportedAsErrors.end(); ++it) {
+        ScriptState* scriptState = (*it)->m_promise.scriptState();
+        if (!scriptState->contextIsValid())
+            continue;
+
+        ScriptState::Scope scope(scriptState);
+        v8::Handle<v8::Value> promise = (*it)->m_promise.v8Value();
+        if (promise != data.GetPromise())
+            continue;
+
+        // If execution termination has been triggered, quietly bail out.
+        if (v8::V8::IsExecutionTerminating(scriptState->isolate()))
+            continue;
+        ExecutionContext* executionContext = scriptState->executionContext();
+        if (!executionContext)
+            continue;
+
+        RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(JSMessageSource, RevokedErrorMessageLevel, "Handler added to rejected promise");
+        consoleMessage->setRelatedMessageId((*it)->m_consoleMessageId);
+        executionContext->addConsoleMessage(consoleMessage.release());
+        m_reportedAsErrors.remove(it);
+        break;
+    }
+}
+
 void RejectedPromises::dispose()
 {
     processQueue();
 }
 
 void RejectedPromises::processQueue()
 {
     while (!m_queue.isEmpty()) {
         OwnPtrWillBeRawPtr<Message> message = m_queue.takeFirst();
         ScriptState* scriptState = message->m_promise.scriptState();
@@ skipping 25 matching lines @@
         String embedderErrorMessage = message->m_errorMessage;
         if (embedderErrorMessage.isEmpty())
             embedderErrorMessage = errorMessage;
         else if (embedderErrorMessage.startsWith("Uncaught "))
             embedderErrorMessage.insert(" (in promise)", 8);
 
         RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, embedderErrorMessage, message->m_resourceName, message->m_lineNumber, message->m_columnNumber);
         consoleMessage->setScriptArguments(arguments);
         consoleMessage->setCallStack(message->m_callStack);
         consoleMessage->setScriptId(message->m_scriptId);
+        message->m_consoleMessageId = consoleMessage->assignMessageId();
         executionContext->addConsoleMessage(consoleMessage.release());
+
+        m_reportedAsErrors.append(message.release());
+        if (m_reportedAsErrors.size() > maxReportedHandlersPendingResolution)
+            m_reportedAsErrors.removeFirst();
     }
 }
 
 } // namespace blink