Initialize debugger together with isolate.

third_party/WebKit/Source/core/inspector/MainThreadDebugger.cpp

 /*
  * Copyright (c) 2011 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 27 matching lines @@
 #include "core/frame/FrameConsole.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectedFrames.h"
 #include "core/inspector/InspectorTaskRunner.h"
 #include "core/workers/MainThreadWorkletGlobalScope.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/v8_inspector/public/V8Debugger.h"
+#include "public/platform/Platform.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/ThreadingPrimitives.h"
 
 namespace blink {
 
 namespace {
 
 int frameId(LocalFrame* frame)
 {
     ASSERT(frame);
     return WeakIdentifierMap<LocalFrame>::identifier(frame);
 }
 
+Mutex& creationMutex()
+{
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(Mutex, mutex, (new Mutex));
+    return mutex;
+}
+
 }
 
 // TODO(Oilpan): avoid keeping a raw reference separate from the
 // owner one; does not enable heap-movable objects.
 MainThreadDebugger* MainThreadDebugger::s_instance = nullptr;
 
-MainThreadDebugger::MainThreadDebugger(PassOwnPtr<ClientMessageLoop> clientMessageLoop, v8::Isolate* isolate)
+MainThreadDebugger::MainThreadDebugger(v8::Isolate* isolate)
     : ThreadDebugger(isolate)
-    , m_clientMessageLoop(clientMessageLoop)
     , m_taskRunner(adoptPtr(new InspectorTaskRunner()))
 {
     MutexLocker locker(creationMutex());
     ASSERT(!s_instance);
     s_instance = this;
+    IdentifiersFactory::setProcessId(Platform::current()->getUniqueIdForProcess());
 }
 
 MainThreadDebugger::~MainThreadDebugger()
 {
     MutexLocker locker(creationMutex());
     ASSERT(s_instance == this);
     s_instance = nullptr;
 }
 
-Mutex& MainThreadDebugger::creationMutex()
+void MainThreadDebugger::setClientMessageLoop(PassOwnPtr<ClientMessageLoop> clientMessageLoop)
 {
-    DEFINE_THREAD_SAFE_STATIC_LOCAL(Mutex, mutex, (new Mutex));
-    return mutex;
+    ASSERT(!m_clientMessageLoop);
+    ASSERT(clientMessageLoop);
+    m_clientMessageLoop = clientMessageLoop;
 }
 
 void MainThreadDebugger::contextCreated(ScriptState* scriptState, LocalFrame* frame, SecurityOrigin* origin)
 {
     ASSERT(isMainThread());
     v8::HandleScope handles(scriptState->isolate());
     DOMWrapperWorld& world = scriptState->world();
-    V8Debugger::setContextDebugData(scriptState->context(), world.isMainWorld() ? "page" : "injected", contextGroupId(frame));
-    if (s_instance) {
-        if (frame->localFrameRoot() == frame && world.isMainWorld())
-            s_instance->debugger()->resetContextGroup(contextGroupId(frame));
-        s_instance->debugger()->contextCreated(V8ContextInfo(scriptState->context(), world.isMainWorld(), origin ? origin->toRawString() : "", world.isIsolatedWorld() ? world.isolatedWorldHumanReadableName() : "", IdentifiersFactory::frameId(frame)));
-    }
+    if (frame->localFrameRoot() == frame && world.isMainWorld())
+        debugger()->resetContextGroup(contextGroupId(frame));
+    debugger()->contextCreated(V8ContextInfo(scriptState->context(), contextGroupId(frame), world.isMainWorld(), origin ? origin->toRawString() : "", world.isIsolatedWorld() ? world.isolatedWorldHumanReadableName() : "", IdentifiersFactory::frameId(frame)));
 }
 
 void MainThreadDebugger::contextWillBeDestroyed(ScriptState* scriptState)
 {
-    if (s_instance) {
-        v8::HandleScope handles(scriptState->isolate());
-        s_instance->debugger()->contextDestroyed(scriptState->context());
-    }
+    v8::HandleScope handles(scriptState->isolate());
+    debugger()->contextDestroyed(scriptState->context());
 }
 
 int MainThreadDebugger::contextGroupId(LocalFrame* frame)
 {
     LocalFrame* localFrameRoot = frame->localFrameRoot();
     return frameId(localFrameRoot);
 }
 
 MainThreadDebugger* MainThreadDebugger::instance()
 {
     ASSERT(isMainThread());
-    return s_instance;
+    v8::Isolate* isolate = V8PerIsolateData::mainThreadIsolate();
+    V8PerIsolateData* data = V8PerIsolateData::from(isolate);
+    return static_cast<MainThreadDebugger*>(data->threadDebugger());
 }
 
 void MainThreadDebugger::interruptMainThreadAndRun(PassOwnPtr<InspectorTaskRunner::Task> task)
 {
     MutexLocker locker(creationMutex());
     if (s_instance) {
         s_instance->m_taskRunner->appendTask(task);
         s_instance->m_taskRunner->interruptAndRunAllTasksDontWait(s_instance->m_isolate);
     }
 }
 
 void MainThreadDebugger::runMessageLoopOnPause(int contextGroupId)
 {
     LocalFrame* pausedFrame = WeakIdentifierMap<LocalFrame>::lookup(contextGroupId);
     // Do not pause in Context of detached frame.
     if (!pausedFrame)
         return;
     ASSERT(pausedFrame == pausedFrame->localFrameRoot());
 
     if (UserGestureToken* token = UserGestureIndicator::currentToken())
         token->setPauseInDebugger();
     // Wait for continue or step command.
-    m_clientMessageLoop->run(pausedFrame);
+    if (m_clientMessageLoop)
+        m_clientMessageLoop->run(pausedFrame);
 }
 
 void MainThreadDebugger::quitMessageLoopOnPause()
 {
-    m_clientMessageLoop->quitNow();
+    if (m_clientMessageLoop)
+        m_clientMessageLoop->quitNow();
 }
 
 void MainThreadDebugger::muteWarningsAndDeprecations()
 {
     FrameConsole::mute();
     UseCounter::muteForInspector();
 }
 
 void MainThreadDebugger::unmuteWarningsAndDeprecations()
 {
@@ skipping 32 matching lines @@
     Vector<std::pair<ScriptState*, SecurityOrigin*>> isolatedContexts;
     for (LocalFrame* frame : *inspectedFrames) {
         if (!frame->script().canExecuteScripts(NotAboutToExecuteScript))
             continue;
         String frameId = IdentifiersFactory::frameId(frame);
 
         // Ensure execution context is created.
         // If initializeMainWorld returns true, then is registered by didCreateScriptContext
         if (!frame->script().initializeMainWorld()) {
             ScriptState* scriptState = ScriptState::forMainWorld(frame);
-            contexts.append(V8ContextInfo(scriptState->context(), true, "", "", frameId));
+            contexts.append(V8ContextInfo(scriptState->context(), contextGroupId, true, "", "", frameId));
         }
         frame->script().collectIsolatedContexts(isolatedContexts);
         if (isolatedContexts.isEmpty())
             continue;
         for (const auto& pair : isolatedContexts) {
             String originString = pair.second ? pair.second->toRawString() : "";
             ScriptState* scriptState = pair.first;
-            contexts.append(V8ContextInfo(scriptState->context(), false, originString, scriptState->world().isolatedWorldHumanReadableName(), frameId));
+            contexts.append(V8ContextInfo(scriptState->context(), contextGroupId, false, originString, scriptState->world().isolatedWorldHumanReadableName(), frameId));
         }
         isolatedContexts.clear();
     }
 }
 
 } // namespace blink