Examples with SuspendContextCommandImpl com.intellij.debugger.engine.events.SuspendContextCommandImpl used on opensource projects

Example 6 with SuspendContextCommandImpl

use of com.intellij.debugger.engine.events.SuspendContextCommandImpl in project intellij-community by JetBrains.

the class SourceCodeChecker method checkSource.

public static void checkSource(DebuggerContextImpl debuggerContext) {
    if (!Registry.is("debugger.check.source")) {
        return;
    }
    SuspendContextImpl suspendContext = debuggerContext.getSuspendContext();
    if (suspendContext == null) {
        return;
    }
    suspendContext.getDebugProcess().getManagerThread().schedule(new SuspendContextCommandImpl(suspendContext) {

        @Override
        public Priority getPriority() {
            return Priority.LOW;
        }

        @Override
        public void contextAction() throws Exception {
            try {
                StackFrameProxyImpl frameProxy = debuggerContext.getFrameProxy();
                if (frameProxy == null) {
                    return;
                }
                Location location = frameProxy.location();
                check(location, debuggerContext.getSourcePosition(), suspendContext.getDebugProcess().getProject());
            //checkAllClasses(debuggerContext);
            } catch (EvaluateException e) {
                LOG.info(e);
            }
        }
    });
}

Example 7 with SuspendContextCommandImpl

use of com.intellij.debugger.engine.events.SuspendContextCommandImpl in project intellij-community by JetBrains.

the class ExecutionWithDebuggerToolsTestCase method addDefaultBreakpointListener.

protected void addDefaultBreakpointListener() {
    if (myPauseScriptListener == null) {
        final DebugProcessImpl debugProcess = getDebugProcess();
        assertTrue("Debug process was not started", debugProcess != null);
        myPauseScriptListener = new DelayedEventsProcessListener(new DebugProcessAdapterImpl() {

            @Override
            public void paused(SuspendContextImpl suspendContext) {
                try {
                    if (myScriptRunnables.isEmpty()) {
                        print("resuming ", ProcessOutputTypes.SYSTEM);
                        printContext(suspendContext);
                        resume(suspendContext);
                        return;
                    }
                    SuspendContextRunnable suspendContextRunnable = myScriptRunnables.remove(0);
                    suspendContextRunnable.run(suspendContext);
                } catch (Exception e) {
                    addException(e);
                    error(e);
                } catch (AssertionError e) {
                    addException(e);
                    resume(suspendContext);
                }
                if (myScriptRunnables.isEmpty()) {
                    myScriptRunnablesSema.up();
                }
            }

            //executed in manager thread
            @Override
            public void resumed(SuspendContextImpl suspendContext) {
                final SuspendContextImpl pausedContext = debugProcess.getSuspendManager().getPausedContext();
                if (pausedContext != null) {
                    debugProcess.getManagerThread().schedule(new SuspendContextCommandImpl(pausedContext) {

                        @Override
                        public void contextAction() throws Exception {
                            paused(pausedContext);
                        }
                    });
                }
            }
        });
        debugProcess.addDebugProcessListener(myPauseScriptListener);
    }
}

Example 8 with SuspendContextCommandImpl

use of com.intellij.debugger.engine.events.SuspendContextCommandImpl in project intellij-community by JetBrains.

the class ExecutionWithDebuggerToolsTestCase method pumpSwingThread.

protected void pumpSwingThread() {
    LOG.assertTrue(SwingUtilities.isEventDispatchThread());
    final InvokeRatherLaterRequest request = myRatherLaterRequests.get(0);
    request.invokesN++;
    if (request.invokesN == RATHER_LATER_INVOKES_N) {
        myRatherLaterRequests.remove(0);
        if (!myRatherLaterRequests.isEmpty())
            pumpSwingThread();
    }
    if (request.myDebuggerCommand instanceof SuspendContextCommandImpl) {
        request.myDebugProcess.getManagerThread().schedule(new SuspendContextCommandImpl(((SuspendContextCommandImpl) request.myDebuggerCommand).getSuspendContext()) {

            @Override
            public void contextAction() throws Exception {
                pumpDebuggerThread(request);
            }

            @Override
            protected void commandCancelled() {
                pumpDebuggerThread(request);
            }
        });
    } else {
        request.myDebugProcess.getManagerThread().schedule(new DebuggerCommandImpl() {

            @Override
            protected void action() throws Exception {
                pumpDebuggerThread(request);
            }

            @Override
            protected void commandCancelled() {
                pumpDebuggerThread(request);
            }
        });
    }
}

Example 9 with SuspendContextCommandImpl

use of com.intellij.debugger.engine.events.SuspendContextCommandImpl in project intellij-community by JetBrains.

the class SuspendContextImpl method resume.

protected void resume() {
    assertNotResumed();
    if (isEvaluating()) {
        LOG.error("Resuming context while evaluating", ThreadDumper.dumpThreadsToString());
    }
    DebuggerManagerThreadImpl.assertIsManagerThread();
    try {
        if (!Patches.IBM_JDK_DISABLE_COLLECTION_BUG) {
            myKeptReferences.forEach(DebuggerUtilsEx::enableCollection);
            myKeptReferences.clear();
        }
        for (SuspendContextCommandImpl cmd = pollPostponedCommand(); cmd != null; cmd = pollPostponedCommand()) {
            cmd.notifyCancelled();
        }
        resumeImpl();
    } finally {
        myIsResumed = true;
    }
}

Example 10 with SuspendContextCommandImpl

use of com.intellij.debugger.engine.events.SuspendContextCommandImpl in project intellij-community by JetBrains.

the class DebugProcessEvents method processLocatableEvent.

private void processLocatableEvent(final SuspendContextImpl suspendContext, final LocatableEvent event) {
    ThreadReference thread = event.thread();
    //LOG.assertTrue(thread.isSuspended());
    preprocessEvent(suspendContext, thread);
    //we use schedule to allow processing other events during processing this one
    //this is especially necessary if a method is breakpoint condition
    getManagerThread().schedule(new SuspendContextCommandImpl(suspendContext) {

        @Override
        public void contextAction() throws Exception {
            final SuspendManager suspendManager = getSuspendManager();
            SuspendContextImpl evaluatingContext = SuspendManagerUtil.getEvaluatingContext(suspendManager, suspendContext.getThread());
            if (evaluatingContext != null && !DebuggerSession.enableBreakpointsDuringEvaluation()) {
                // is inside evaluation, so ignore any breakpoints
                suspendManager.voteResume(suspendContext);
                return;
            }
            final LocatableEventRequestor requestor = (LocatableEventRequestor) getRequestsManager().findRequestor(event.request());
            boolean resumePreferred = requestor != null && DebuggerSettings.SUSPEND_NONE.equals(requestor.getSuspendPolicy());
            boolean requestHit;
            try {
                requestHit = (requestor != null) && requestor.processLocatableEvent(this, event);
            } catch (final LocatableEventRequestor.EventProcessingException ex) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug(ex.getMessage());
                }
                final boolean[] considerRequestHit = new boolean[] { true };
                DebuggerInvocationUtil.invokeAndWait(getProject(), () -> {
                    final String displayName = requestor instanceof Breakpoint ? ((Breakpoint) requestor).getDisplayName() : requestor.getClass().getSimpleName();
                    final String message = DebuggerBundle.message("error.evaluating.breakpoint.condition.or.action", displayName, ex.getMessage());
                    considerRequestHit[0] = Messages.showYesNoDialog(getProject(), message, ex.getTitle(), Messages.getQuestionIcon()) == Messages.YES;
                }, ModalityState.NON_MODAL);
                requestHit = considerRequestHit[0];
                resumePreferred = !requestHit;
            }
            if (requestHit && requestor instanceof Breakpoint) {
                // if requestor is a breakpoint and this breakpoint was hit, no matter its suspend policy
                ApplicationManager.getApplication().runReadAction(() -> {
                    XDebugSession session = getSession().getXDebugSession();
                    if (session != null) {
                        XBreakpoint breakpoint = ((Breakpoint) requestor).getXBreakpoint();
                        if (breakpoint != null) {
                            ((XDebugSessionImpl) session).processDependencies(breakpoint);
                        }
                    }
                });
            }
            if (!requestHit || resumePreferred) {
                suspendManager.voteResume(suspendContext);
            } else {
                if (myReturnValueWatcher != null) {
                    myReturnValueWatcher.disable();
                }
                //if (suspendContext.getSuspendPolicy() == EventRequest.SUSPEND_ALL) {
                //  // there could be explicit resume as a result of call to voteSuspend()
                //  // e.g. when breakpoint was considered invalid, in that case the filter will be applied _after_
                //  // resuming and all breakpoints in other threads will be ignored.
                //  // As resume() implicitly cleares the filter, the filter must be always applied _before_ any resume() action happens
                //  myBreakpointManager.applyThreadFilter(DebugProcessEvents.this, event.thread());
                //}
                suspendManager.voteSuspend(suspendContext);
                showStatusText(DebugProcessEvents.this, event);
            }
        }
    });
}