/*
- * Copyright 2000-2015 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @author egor
*/
public interface ActionMethodFilter {
- int onReached(SuspendContextImpl context);
+ int onReached(SuspendContextImpl context, RequestHint hint);
}
}
@Override
- public int onReached(SuspendContextImpl context) {
+ public int onReached(SuspendContextImpl context, RequestHint hint) {
StackFrameProxyImpl proxy = context.getFrameProxy();
if (proxy != null) {
try {
breakpoint.setInstanceFiltersEnabled(true);
breakpoint.setSuspendPolicy(context.getSuspendPolicy() == EventRequest.SUSPEND_EVENT_THREAD ? DebuggerSettings.SUSPEND_THREAD : DebuggerSettings.SUSPEND_ALL);
breakpoint.createRequest(debugProcess);
+ breakpoint.setRequestHint(hint);
debugProcess.setRunToCursorBreakpoint(breakpoint);
return RequestHint.RESUME;
}
import com.intellij.debugger.engine.requests.LocatableEventRequestor;
import com.intellij.debugger.engine.requests.MethodReturnValueWatcher;
import com.intellij.debugger.impl.DebuggerSession;
-import com.intellij.debugger.impl.DebuggerUtilsEx;
import com.intellij.debugger.jdi.ThreadReferenceProxyImpl;
import com.intellij.debugger.jdi.VirtualMachineProxyImpl;
import com.intellij.debugger.requests.Requestor;
import com.intellij.openapi.ui.MessageType;
import com.intellij.openapi.ui.Messages;
import com.intellij.openapi.util.Pair;
-import com.intellij.openapi.util.registry.Registry;
-import com.intellij.ui.classFilter.ClassFilter;
import com.intellij.xdebugger.XDebugSession;
import com.intellij.xdebugger.breakpoints.XBreakpoint;
import com.intellij.xdebugger.impl.XDebugSessionImpl;
import com.sun.jdi.request.ThreadStartRequest;
import org.jetbrains.annotations.Nullable;
-import java.util.List;
-
/**
* @author lex
*/
XDebugSessionImpl.NOTIFICATION_GROUP.createNotification(message, MessageType.INFO).notify(project);
}
if (hint.wasStepTargetMethodMatched() && hint.isResetIgnoreFilters()) {
- List<ClassFilter> activeFilters = getActiveFilters();
- String currentClassName = getCurrentClassName(suspendContext.getThread());
- if (currentClassName == null || !DebuggerUtilsEx.isFiltered(currentClassName, activeFilters)) {
- mySession.resetIgnoreStepFiltersFlag();
- }
+ checkPositionNotFiltered(suspendContext.getThread(), filters -> mySession.resetIgnoreStepFiltersFlag());
}
}
}
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.ui.classFilter.ClassFilter;
import com.intellij.ui.classFilter.DebuggerClassFilterProvider;
-import com.intellij.util.Alarm;
-import com.intellij.util.EventDispatcher;
-import com.intellij.util.ReflectionUtil;
-import com.intellij.util.StringBuilderSpinAllocator;
+import com.intellij.util.*;
import com.intellij.util.concurrency.Semaphore;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.containers.HashMap;
EventRequestManager requestManager = getVirtualMachineProxy().eventRequestManager();
StepRequest stepRequest = requestManager.createStepRequest(stepThreadReference, size, depth);
if (!(hint != null && hint.isIgnoreFilters()) /*&& depth == StepRequest.STEP_INTO*/) {
- List<ClassFilter> activeFilters = getActiveFilters();
-
- if (!activeFilters.isEmpty()) {
- final String currentClassName = getCurrentClassName(stepThread);
- if (currentClassName == null || !DebuggerUtilsEx.isFiltered(currentClassName, activeFilters)) {
- // add class filters
- for (ClassFilter filter : activeFilters) {
- stepRequest.addClassExclusionFilter(filter.getPattern());
- }
- }
- }
+ checkPositionNotFiltered(stepThread, filters -> filters.forEach(f -> stepRequest.addClassExclusionFilter(f.getPattern())));
}
// suspend policy to match the suspend policy of the context:
}
}
+ public void checkPositionNotFiltered(ThreadReferenceProxyImpl thread, Consumer<List<ClassFilter>> action) {
+ List<ClassFilter> activeFilters = getActiveFilters();
+ if (!activeFilters.isEmpty()) {
+ String currentClassName = getCurrentClassName(thread);
+ if (currentClassName == null || !DebuggerUtilsEx.isFiltered(currentClassName, activeFilters)) {
+ action.consume(activeFilters);
+ }
+ }
+ }
+
@NotNull
- static List<ClassFilter> getActiveFilters() {
+ private static List<ClassFilter> getActiveFilters() {
List<ClassFilter> activeFilters = new ArrayList<>();
DebuggerSettings settings = DebuggerSettings.getInstance();
if (settings.TRACING_FILTERS_ENABLED) {
if (myBreakpoint != null) {
myBreakpoint.setSuspendPolicy(suspendContext.getSuspendPolicy() == EventRequest.SUSPEND_EVENT_THREAD? DebuggerSettings.SUSPEND_THREAD : DebuggerSettings.SUSPEND_ALL);
myBreakpoint.createRequest(suspendContext.getDebugProcess());
+ myBreakpoint.setRequestHint(hint);
setRunToCursorBreakpoint(myBreakpoint);
}
doStep(suspendContext, stepThread, myStepSize, StepRequest.STEP_INTO, hint);
/*
- * Copyright 2000-2015 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
}
}
- private static int reached(MethodFilter filter, SuspendContextImpl context) {
+ private int reached(MethodFilter filter, SuspendContextImpl context) {
if (filter instanceof ActionMethodFilter) {
- return ((ActionMethodFilter)filter).onReached(context);
+ return ((ActionMethodFilter)filter).onReached(context, this);
}
return STOP;
}
package com.intellij.debugger.ui.breakpoints;
import com.intellij.debugger.SourcePosition;
-import com.intellij.debugger.engine.BreakpointStepMethodFilter;
-import com.intellij.debugger.engine.CompoundPositionManager;
-import com.intellij.debugger.engine.DebugProcessImpl;
-import com.intellij.debugger.engine.LambdaMethodFilter;
+import com.intellij.debugger.engine.*;
import com.intellij.debugger.engine.evaluation.EvaluateException;
+import com.intellij.debugger.engine.events.SuspendContextCommandImpl;
import com.intellij.debugger.engine.requests.RequestManagerImpl;
import com.intellij.debugger.impl.DebuggerUtilsEx;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.util.containers.MultiMap;
import com.sun.jdi.*;
+import com.sun.jdi.event.LocatableEvent;
import com.sun.jdi.request.BreakpointRequest;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
*/
public class StepIntoBreakpoint extends RunToCursorBreakpoint {
private static final Logger LOG = Logger.getInstance("#com.intellij.debugger.ui.breakpoints.StepIntoBreakpoint");
- @NotNull
- private final BreakpointStepMethodFilter myFilter;
+ @NotNull private final BreakpointStepMethodFilter myFilter;
+ @Nullable private RequestHint myHint;
StepIntoBreakpoint(@NotNull Project project, @NotNull SourcePosition pos, @NotNull BreakpointStepMethodFilter filter) {
super(project, pos, false);
}
return null;
}
+
+ @Override
+ public boolean processLocatableEvent(SuspendContextCommandImpl action, LocatableEvent event)
+ throws EventProcessingException {
+ boolean res = super.processLocatableEvent(action, event);
+ if (res && myHint != null && myHint.isResetIgnoreFilters()) {
+ SuspendContextImpl context = action.getSuspendContext();
+ if (context != null) {
+ DebugProcessImpl process = context.getDebugProcess();
+ process.checkPositionNotFiltered(context.getThread(), f -> process.getSession().resetIgnoreStepFiltersFlag());
+ }
+ }
+ return res;
+ }
+
+ public void setRequestHint(RequestHint hint) {
+ myHint = hint;
+ }
}