Abstract out ThreadDebugger from V8PerIsolateData

third_party/WebKit/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 "bindings/core/v8/RejectedPromises.h"
 
+#include <memory>
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/events/EventTarget.h"
 #include "core/events/PromiseRejectionEvent.h"
 #include "core/inspector/ThreadDebugger.h"
 #include "platform/WebTaskRunner.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "wtf/Functional.h"
 #include "wtf/PtrUtil.h"
-#include <memory>
 
 namespace blink {
 
 static const unsigned maxReportedHandlersPendingResolution = 1000;
 
 class RejectedPromises::Message final {
  public:
   static std::unique_ptr<Message> create(
       ScriptState* scriptState,
       v8::Local<v8::Promise> promise,
@@ skipping 41 matching lines @@
       init.setReason(ScriptValue(m_scriptState, reason));
       init.setCancelable(true);
       PromiseRejectionEvent* event = PromiseRejectionEvent::create(
           m_scriptState, EventTypeNames::unhandledrejection, init);
       // Log to console if event was not canceled.
       m_shouldLogToConsole =
           target->dispatchEvent(event) == DispatchEventResult::NotCanceled;
     }
 
     if (m_shouldLogToConsole) {
-      V8PerIsolateData* data = V8PerIsolateData::from(m_scriptState->isolate());
-      if (data->threadDebugger())
-        m_promiseRejectionId = data->threadDebugger()->promiseRejected(
-            m_scriptState->context(), m_errorMessage, reason,
-            std::move(m_location));
+      ThreadDebugger* debugger = ThreadDebugger::from(m_scriptState->isolate());
+      if (debugger) {
+        m_promiseRejectionId =
+            debugger->promiseRejected(m_scriptState->context(), m_errorMessage,
+                                      reason, std::move(m_location));
+      }
     }
 
     m_location.reset();
   }
 
   void revoke() {
     ExecutionContext* executionContext = m_scriptState->getExecutionContext();
     if (!executionContext)
       return;
 
@@ skipping 11 matching lines @@
                                                      m_corsStatus)) {
       PromiseRejectionEventInit init;
       init.setPromise(ScriptPromise(m_scriptState, value));
       init.setReason(ScriptValue(m_scriptState, reason));
       PromiseRejectionEvent* event = PromiseRejectionEvent::create(
           m_scriptState, EventTypeNames::rejectionhandled, init);
       target->dispatchEvent(event);
     }
 
     if (m_shouldLogToConsole && m_promiseRejectionId) {
-      V8PerIsolateData* data = V8PerIsolateData::from(m_scriptState->isolate());
-      if (data->threadDebugger())
-        data->threadDebugger()->promiseRejectionRevoked(
-            m_scriptState->context(), m_promiseRejectionId);
+      ThreadDebugger* debugger = ThreadDebugger::from(m_scriptState->isolate());
+      if (debugger) {
+        debugger->promiseRejectionRevoked(m_scriptState->context(),
+                                          m_promiseRejectionId);
+      }
     }
   }
 
   void makePromiseWeak() {
     ASSERT(!m_promise.isEmpty() && !m_promise.isWeak());
     m_promise.setWeak(this, &Message::didCollectPromise);
     m_exception.setWeak(this, &Message::didCollectException);
   }
 
   void makePromiseStrong() {
@@ skipping 142 matching lines @@
         m_reportedAsErrors.remove(0, maxReportedHandlersPendingResolution / 10);
     }
   }
 }
 
 void RejectedPromises::revokeNow(std::unique_ptr<Message> message) {
   message->revoke();
 }
 
 }  // namespace blink