67 import org.eclipse.core.resources.IMarker;

    68 import org.eclipse.core.resources.IMarkerDelta;

    69 import org.eclipse.core.resources.IResource;

    70 import org.eclipse.core.resources.IWorkspaceRunnable;

    71 import org.eclipse.core.resources.ResourcesPlugin;

    72 import org.eclipse.core.runtime.CoreException;

    73 import org.eclipse.core.runtime.IProgressMonitor;

    74 import org.eclipse.core.runtime.IStatus;

    75 import org.eclipse.core.runtime.Platform;

    76 import org.eclipse.core.runtime.Status;

    77 import org.eclipse.core.runtime.jobs.ISchedulingRule;

    78 import org.eclipse.core.runtime.jobs.Job;

    79 import org.eclipse.core.runtime.jobs.MultiRule;

    80 import org.eclipse.debug.core.DebugPlugin;

    81 import org.eclipse.debug.core.IBreakpointListener;

    82 import org.eclipse.debug.core.IBreakpointManager;

    83 import org.eclipse.debug.core.IBreakpointManagerListener;

    84 import org.eclipse.debug.core.model.IBreakpoint;

    85 import org.osgi.framework.BundleContext;

    95     // Note: Find a way to import this (careful of circular dependencies)

    96     public final static String GDB_DEBUG_MODEL_ID = "org.eclipse.cdt.dsf.gdb"; //$NON-NLS-1$

    97 

    98     // Extra breakpoint attributes

    99     private static final String ATTR_DEBUGGER_PATH = GdbPlugin.PLUGIN_ID + ".debuggerPath";   //$NON-NLS-1$

   100     private static final String ATTR_THREAD_FILTER = GdbPlugin.PLUGIN_ID + ".threadFilter";   //$NON-NLS-1$

   101     private static final String ATTR_THREAD_ID     = GdbPlugin.PLUGIN_ID + ".threadID";       //$NON-NLS-1$

   102 

   103     // Services

   104     ICommandControl    fConnection;

   105     IRunControl        fRunControl;

   106     ISourceLookup      fSourceLookup;

   107     IBreakpoints       fBreakpoints;

   108     IBreakpointManager fBreakpointManager;  // Platform breakpoint manager (not this!)

   109     BreakpointActionManager fBreakpointActionManager;

   110 

   111     ///////////////////////////////////////////////////////////////////////////

   112     // Breakpoints tracking

   113     ///////////////////////////////////////////////////////////////////////////

   114 

   115     private String fDebugModelId;

   116     

   117     // Holds the set of platform breakpoints with their corresponding back-end

   118     // breakpoint attributes, per context (i.e. each platform breakpoint is

   119     // replicated for each execution context).

   120     // - Context entry added/removed on start/stopTrackingBreakpoints()

   121     // - Augmented on breakpointAdded()

   122     // - Modified on breakpointChanged()

   123     // - Diminished on breakpointRemoved()

   124     private Map<IBreakpointsTargetDMContext, Map<ICBreakpoint, Map<String, Object>>> fPlatformBPs =

   125         new HashMap<IBreakpointsTargetDMContext, Map<ICBreakpoint, Map<String, Object>>>();

   126 

   127     // Holds the set of target breakpoints, per execution context, and their

   128     // mapping to the corresponding platform breakpoint. In a given execution

   129     // context there can only be one platform breakpoint per target breakpoint.

   130     // Acts as a mapping from target (low-level) BP to the corresponding platform

   131     // (high-level) BP.

   132     // Updated when:

   133     // - We start/stop tracking an execution context

   134     // - A platform breakpoint is added/removed

   135     // - A thread filter is applied/removed

   136     private Map<IBreakpointsTargetDMContext, Map<IBreakpointDMContext, ICBreakpoint>> fTargetBPs =

   137         new HashMap<IBreakpointsTargetDMContext, Map<IBreakpointDMContext, ICBreakpoint>>();

   138 

   139     // Holds the mapping from platform breakpoint to the corresponding target

   140     // breakpoint(s), per context. There can be multiple back-end BPs for a

   141     // single platform BP in the case of [1] multiple target contexts, and/or

   142     // [2] thread filtering.

   143     // Updated when:

   144     // - We start/stop tracking an execution context

   145     // - A platform breakpoint is added/removed

   146     // - A thread filter is applied/removed

   147     private Map<IBreakpointsTargetDMContext, Map<ICBreakpoint, Vector<IBreakpointDMContext>>> fBreakpointIDs =

   148         new HashMap<IBreakpointsTargetDMContext, Map<ICBreakpoint, Vector<IBreakpointDMContext>>>();

   149 

   150     // Holds the mapping from platform breakpoint to the corresponding target

   151     // breakpoint threads, per context.

   152     // Updated when:

   153     // - We start/stop tracking an execution context

   154     // - A platform breakpoint is added/removed

   155     // - A thread filter is applied/removed

   156     private Map<IBreakpointsTargetDMContext, Map<ICBreakpoint, Set<String>>> fBreakpointThreads =

   157         new HashMap<IBreakpointsTargetDMContext, Map<ICBreakpoint, Set<String>>>();

   158 

   159     // Due to the very asynchronous nature of DSF, a new breakpoint request can

   160     // pop up at any time before an ongoing one is completed. The following set

   161     // is used to store requests until the ongoing operation completes.

   162     private Set<IBreakpoint> fPendingRequests    = new HashSet<IBreakpoint>();

   163     private Set<IBreakpoint> fPendingBreakpoints = new HashSet<IBreakpoint>();

   164 

   165     private Map<ICBreakpoint, IMarker> fBreakpointMarkerProblems =

   166         new HashMap<ICBreakpoint, IMarker>();

   167 

   168     ///////////////////////////////////////////////////////////////////////////

   169     // String constants

   170     ///////////////////////////////////////////////////////////////////////////

   171 

   172     private static final String NULL_STRING = ""; //$NON-NLS-1$

   173 

   174     static final String CONTEXT_ALREADY_INITIALIZED  = "Context already initialized";  //$NON-NLS-1$

   175     static final String INVALID_CONTEXT_TYPE         = "Invalid context type";         //$NON-NLS-1$

   176     static final String INVALID_CONTEXT              = "Invalid context";              //$NON-NLS-1$

   177 

   178     static final String UNABLE_TO_READ_BREAKPOINT    = "Unable to read initial breakpoint attributes"; //$NON-NLS-1$

   179     static final String BREAKPOINT_NOT_INSTALLED     = "Breakpoints not installed for given context";  //$NON-NLS-1$

   180     static final String BREAKPOINT_ALREADY_INSTALLED = "Breakpoint already installed"; //$NON-NLS-1$

   181     static final String BREAKPOINT_ALREADY_REMOVED   = "Breakpoint already removed";   //$NON-NLS-1$

   182 

   183     static final String INVALID_BREAKPOINT           = "Invalid breakpoint";                    //$NON-NLS-1$

   184     static final String UNKNOWN_BREAKPOINT           = "Unknown breakpoint";                    //$NON-NLS-1$

   185     static final String INVALID_PARAMETER            = "Invalid breakpoint parameter(s)";       //$NON-NLS-1$

   186 

   187     static final String NO_DEBUGGER_PATH             = "No debugger path for breakpoint";       //$NON-NLS-1$

   188     static final String NO_MARKER_FOR_BREAKPOINT     = "No marker associated with breakpoint";  //$NON-NLS-1$

   189 

   190     ///////////////////////////////////////////////////////////////////////////

   191     // AbstractDsfService

   192     ///////////////////////////////////////////////////////////////////////////

   193 

   206 

   207     //-------------------------------------------------------------------------

   208     // initialize

   209     //-------------------------------------------------------------------------

   210     // - Collect references for the services we interact with

   211     // - Register to interesting events

   212     // - Obtain the list of platform breakpoints

   213     // - Register the service for interested parties

   214     //-------------------------------------------------------------------------

   215 

   216     /* (non-Javadoc)

   217      * @see org.eclipse.cdt.dsf.service.AbstractDsfService#initialize(org.eclipse.cdt.dsf.concurrent.RequestMonitor)

   218      */

   219     @Override

   220     public void initialize(final RequestMonitor rm) {

   221         super.initialize(

   222             new RequestMonitor(getExecutor(), rm) {

   223                 @Override

   224                 protected void handleSuccess() {

   225                     doInitialize(rm);

   226                 }});

   227     }

   228 

   229     /**

   230      * @param rm

   231      */

   232     private void doInitialize(RequestMonitor rm) {

   233         

   234         // Get the required services references from central repository

   235         fConnection     = getServicesTracker().getService(ICommandControl.class);

   236         fRunControl     = getServicesTracker().getService(IRunControl.class);

   237         fSourceLookup   = getServicesTracker().getService(ISourceLookup.class);

   238         fBreakpoints    = getServicesTracker().getService(IBreakpoints.class);

   239         fBreakpointManager = DebugPlugin.getDefault().getBreakpointManager();

   240         fBreakpointActionManager = CDebugCorePlugin.getDefault().getBreakpointActionManager();

   241 

   242         // Register to the useful events

   243         getSession().addServiceEventListener(this, null);

   244         fBreakpointManager.addBreakpointListener(this);

   245         fBreakpointManager.addBreakpointManagerListener(this);

   246 

   247         // And register this service

   248         register(new String[] { MIBreakpointsManager.class.getName() },

   249                  new Hashtable<String, String>());

   250         rm.done();

   251     }

   252 

   253     //-------------------------------------------------------------------------

   254     // shutdown

   255     //-------------------------------------------------------------------------

   256     // - Un-register the service

   257     // - Stop listening to events

   258     // - Remove the breakpoints installed by this service

   259     //

   260     //  Since we are shutting down, there is no overwhelming need

   261     //  to keep the maps coherent...

   262     //-------------------------------------------------------------------------

   263     

   264     /* (non-Javadoc)

   265      * @see org.eclipse.cdt.dsf.service.AbstractDsfService#shutdown(org.eclipse.cdt.dsf.concurrent.RequestMonitor)

   266      */

   267     @Override

   268     public void shutdown(final RequestMonitor rm) {

   269 

   270         // Stop accepting requests and events

   271         unregister();

   272         getSession().removeServiceEventListener(this);

   273         fBreakpointManager.removeBreakpointListener(this);

   274         fBreakpointManager.removeBreakpointManagerListener(this);

   275 

   276         // Cleanup the breakpoints that are still installed by the service.

   277         // Use a counting monitor which will call mom to complete the shutdown

   278         // after the breakpoints are un-installed (successfully or not).

   279         CountingRequestMonitor countingRm = new CountingRequestMonitor(getExecutor(), rm) {

   280             @Override

   281             protected void handleCompleted() {

   282                 MIBreakpointsManager.super.shutdown(rm);

   283             }

   284         };

   285 

   286         List<IBreakpointsTargetDMContext> targetBPKeys = new ArrayList<IBreakpointsTargetDMContext>(fTargetBPs.size());

   287         targetBPKeys.addAll(0, fTargetBPs.keySet());

   288         for (IBreakpointsTargetDMContext dmc : targetBPKeys) {

   289             stopTrackingBreakpoints(dmc, countingRm);

   290         }

   291         countingRm.setDoneCount(targetBPKeys.size());

   292     }

   293 

   294     //-------------------------------------------------------------------------

   295     // getBundleContext

   296     //-------------------------------------------------------------------------

   297 

   298     /* (non-Javadoc)

   299      * @see org.eclipse.cdt.dsf.service.AbstractDsfService#getBundleContext()

   300      */

   301     @Override

   302     protected BundleContext getBundleContext() {

   303         return GdbPlugin.getBundleContext();

   304     }

   305 

   306     ///////////////////////////////////////////////////////////////////////////

   307     // IBreakpointsManager

   308     ///////////////////////////////////////////////////////////////////////////

   309 

   310     //-------------------------------------------------------------------------

   311     // startTrackingBreakpoints

   312     //-------------------------------------------------------------------------

   313     // - Augment the maps with the new execution context

   314     // - Install the platform breakpoints on the selected target

   315     //-------------------------------------------------------------------------

   316 

   317     /**

   318      * Install and begin tracking breakpoints for given context.  The service

   319      * will keep installing new breakpoints that appear in the IDE for this

   320      * context until {@link #uninstallBreakpoints(IDMContext)} is called for that

   321      * context.

   322      * @param dmc Context to start tracking breakpoints for.

   323      * @param rm Completion callback.

   324      */

   325     public void startTrackingBreakpoints(final IBreakpointsTargetDMContext dmc, final RequestMonitor rm) {

   326 

   327         // Validate the execution context

   328         if (dmc == null) {

   329             rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, REQUEST_FAILED, INVALID_CONTEXT, null));

   330             rm.done();

   331             return;

   332         }

   333 

   334         // Make sure a mapping for this execution context does not already exist

   335         Map<ICBreakpoint,Map<String, Object>> platformBPs = fPlatformBPs.get(dmc);

   336         Map<ICBreakpoint, Vector<IBreakpointDMContext>> breakpointIDs = fBreakpointIDs.get(dmc);

   337         Map<IBreakpointDMContext, ICBreakpoint> targetIDs = fTargetBPs.get(dmc);

   338         Map<ICBreakpoint, Set<String>> threadIDs = fBreakpointThreads.get(dmc);

   339         if ((platformBPs != null) || (breakpointIDs != null) || (targetIDs != null) || (threadIDs != null)) {

   340             rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, CONTEXT_ALREADY_INITIALIZED, null));

   341             rm.done();

   342             return;

   343         }

   344 

   345         // Create entries in the breakpoint tables for the new context. These entries should only

   346         // be removed when this service stops tracking breakpoints for the given context.

   347         fPlatformBPs.put(dmc, new HashMap<ICBreakpoint, Map<String, Object>>());

   348         fBreakpointIDs.put(dmc, new HashMap<ICBreakpoint, Vector<IBreakpointDMContext>>());

   349         fTargetBPs.put(dmc, new HashMap<IBreakpointDMContext, ICBreakpoint>());

   350         fBreakpointThreads.put(dmc, new HashMap<ICBreakpoint, Set<String>>());

   351 

   352         // Install the platform breakpoints (stored in fPlatformBPs) on the target.

   353         new Job("DSF BreakpointsManager: Install initial breakpoints on target") { //$NON-NLS-1$

   354             @Override

   355             protected IStatus run(IProgressMonitor monitor) {

   356                 // Submit the runnable to plant the breakpoints on dispatch thread.

   357                 getExecutor().submit(new Runnable() {

   358                     public void run() {

   359                         installInitialBreakpoints(dmc, rm);

   360                     }

   361                 });

   362 

   363                 return Status.OK_STATUS;

   364             }

   365         }.schedule();

   366     }

   367 

   368     /**

   369      * Installs the breakpoints that existed prior to the activation of this

   370      * execution context.

   371      * 

   372      * @param dmc

   373      * @param initialPlatformBPs

   374      * @param rm

   375      */

   376     private void installInitialBreakpoints(final IBreakpointsTargetDMContext dmc, final RequestMonitor rm)

   377     {

   378         // Retrieve the set of platform breakpoints for this context

   379         final Map<ICBreakpoint,Map<String, Object>> platformBPs = fPlatformBPs.get(dmc);

   380         if (platformBPs == null) {

   381             rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, INVALID_CONTEXT, null));

   382             rm.done();

   383             return;

   384         }

   385 

   386         // Read current breakpoints from platform and copy their augmented

   387         // attributes into the local reference map

   388         try {

   389             IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(fDebugModelId);

   390             for (IBreakpoint breakpoint : breakpoints) {

   391                 if (supportsBreakpoint(breakpoint)) {

   392                     @SuppressWarnings("unchecked")

   393                     Map<String, Object> attributes = breakpoint.getMarker().getAttributes();

   394                     attributes.put(ATTR_DEBUGGER_PATH, NULL_STRING);

   395                     attributes.put(ATTR_THREAD_FILTER, extractThreads(dmc, (ICBreakpoint) breakpoint));

   396                     attributes.put(ATTR_THREAD_ID, NULL_STRING);

   397                     platformBPs.put((ICBreakpoint) breakpoint, attributes);

   398                 }

   399             }

   400         } catch (CoreException e) {

   401             IStatus status = new Status(

   402                 IStatus.ERROR, GdbPlugin.PLUGIN_ID, REQUEST_FAILED, UNABLE_TO_READ_BREAKPOINT, e);

   403             rm.setStatus(status);

   404             rm.done();

   405         }

   406 

   407         // Install the individual breakpoints on the dispatcher thread

   408         // Requires a counting monitor to know when we are done

   409         final CountingRequestMonitor countingRm = new CountingRequestMonitor(getExecutor(), rm);

   410         countingRm.setDoneCount(platformBPs.size());

   411 

   412         for (final ICBreakpoint breakpoint : platformBPs.keySet()) {

   413             final Map<String, Object> attributes = platformBPs.get(breakpoint);

   414             // Upon determining the debuggerPath, the breakpoint is installed

   415             determineDebuggerPath(dmc, attributes, new RequestMonitor(getExecutor(), countingRm) {

   416                 @Override

   417                 protected void handleSuccess() {

   418                 	// Install only if the breakpoint is enabled at startup (Bug261082)

   419                 	boolean bpEnabled = attributes.get(ICBreakpoint.ENABLED).equals(true) && fBreakpointManager.isEnabled();

   420                 	if (bpEnabled)

   421                 		installBreakpoint(dmc, breakpoint, attributes, countingRm);

   422                 	else

   423                 		countingRm.done();

   424                 }

   425             });

   426         }

   427     }

   428 

   429     //-------------------------------------------------------------------------

   430     // stopTrackingBreakpoints

   431     //-------------------------------------------------------------------------

   432     // - Remove the target breakpoints for the given execution context

   433     // - Update the maps

   434     //-------------------------------------------------------------------------

   435 

   436     /**

   437      * Uninstall and stop tracking breakpoints for the given context.

   438      * @param dmc Context to start tracking breakpoints for.

   439      * @param rm Completion callback.

   440      */

   441     public void stopTrackingBreakpoints(final IBreakpointsTargetDMContext dmc, final RequestMonitor rm) {

   442 

   443         // Validate the context

   444         if (dmc == null) {

   445             rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, INVALID_CONTEXT, null));

   446             rm.done();

   447             return;

   448         }

   449 

   450         // Retrieve the set of platform breakpoints for this context

   451         final Map<ICBreakpoint,Map<String, Object>> platformBPs = fPlatformBPs.get(dmc);

   452         if (platformBPs == null) {

   453             rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, INVALID_CONTEXT, null));

   454             rm.done();

   455             return;

   456         }

   457 

   458         // Un-install the individual breakpoints on the dispatcher thread

   459         // (requires a counting monitor to know when we are done).

   460         // On completion (success or failure), update the maps.

   461         final CountingRequestMonitor countingRm = new CountingRequestMonitor(getExecutor(), rm) {

   462             @Override

   463             protected void handleCompleted() {

   464                 fPlatformBPs.remove(dmc);

   465                 fBreakpointIDs.remove(dmc);

   466                 fTargetBPs.remove(dmc);

   467                 fBreakpointThreads.remove(dmc);

   468                 rm.done();

   469             }

   470         };

   471         countingRm.setDoneCount(platformBPs.size());

   472 

   473         for (final ICBreakpoint breakpoint : platformBPs.keySet()) {

   474             uninstallBreakpoint(dmc, breakpoint,

   475                 new RequestMonitor(getExecutor(), countingRm) {

   476                     @Override

   477                     protected void handleCompleted() {

   478                         countingRm.done();

   479                     }

   480                 });

   481         }

   482     }

   483 

   484     ///////////////////////////////////////////////////////////////////////////

   485     // Back-end interface functions

   486     ///////////////////////////////////////////////////////////////////////////

   487 

   488     //-------------------------------------------------------------------------

   489     // installBreakpoint

   490     //-------------------------------------------------------------------------

   491 

   492     /**

   493      * Install a platform breakpoint on the back-end. For a given context, a

   494      * platform breakpoint can resolve into multiple back-end breakpoints when

   495      * threads are taken into account.

   496      * 

   497      * @param dmc

   498      * @param breakpoint

   499      * @param attributes

   500      * @param rm

   501      */

   502     private void installBreakpoint(IBreakpointsTargetDMContext dmc, final ICBreakpoint breakpoint,

   503         final Map<String, Object> attributes, final RequestMonitor rm)

   504     {

   505         // Retrieve the breakpoint maps

   506         final Map<ICBreakpoint,Map<String,Object>> platformBPs = fPlatformBPs.get(dmc);

   507         assert platformBPs != null;

   508 

   509         final Map<ICBreakpoint, Vector<IBreakpointDMContext>> breakpointIDs = fBreakpointIDs.get(dmc);

   510         assert breakpointIDs != null;

   511 

   512         final Map<IBreakpointDMContext, ICBreakpoint> targetBPs = fTargetBPs.get(dmc);

   513         assert targetBPs != null;

   514 

   515         final Map<ICBreakpoint, Set<String>> threadsIDs = fBreakpointThreads.get(dmc);

   516         assert threadsIDs != null;

   517 

   518         // Minimal validation

   519         if (breakpointIDs.containsKey(breakpoint) || targetBPs.containsValue(breakpoint)) {

   520             rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, BREAKPOINT_ALREADY_INSTALLED, null));

   521             rm.done();

   522             return;

   523         }

   524 

   525         // Ensure the breakpoint has a valid debugger source path

   526         if (breakpoint instanceof ICLineBreakpoint && !(breakpoint instanceof ICAddressBreakpoint)) {

   527             String debuggerPath = (String) attributes.get(ATTR_DEBUGGER_PATH);

   528             if (debuggerPath == null || debuggerPath == NULL_STRING) {

   529                 rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, REQUEST_FAILED, NO_DEBUGGER_PATH, null));

   530                 rm.done();

   531                 return;

   532             }

   533         }

   534 

   535         // A back-end breakpoint needs to be installed for each specified thread

   536         // Note: This is a bit academic since [1] thread info is not kept by the

   537         // BreakpointManager (so it can not possibly be restored when a target is

   538         // started), and [2] the standard GUI doesn't allow to specify thread at

   539         // breakpoint creation. However, it is conceivable that an enhanced Editor

   540         // would permit it.

   541         final Set<String> threads = getThreads(attributes);

   542 

   543         // Update the breakpoint state when all back-end breakpoints have been installed

   544         final CountingRequestMonitor installRM = new CountingRequestMonitor(getExecutor(), rm) {

   545             @Override

   546             protected void handleCompleted() {

   547                 // Store the platform breakpoint

   548                 platformBPs.put(breakpoint, attributes);

   549                 rm.done();

   550             }

   551         };

   552         installRM.setDoneCount(threads.size());

   553 

   554         // Install the back-end breakpoint(s)

   555         for (final String thread : threads) {

   556             DataRequestMonitor<IBreakpointDMContext> drm =

   557                 new DataRequestMonitor<IBreakpointDMContext>(getExecutor(), installRM) {

   558                     @Override

   559                     protected void handleSuccess() {

   560                         // Add the new back-end breakpoint to the map

   561                         Vector<IBreakpointDMContext> list = breakpointIDs.get(breakpoint);

   562                         if (list == null)

   563                             list = new Vector<IBreakpointDMContext>();

   564                         IBreakpointDMContext targetBP = getData();

   565                         list.add(targetBP);

   566                         breakpointIDs.put(breakpoint, list);

   567 

   568                         // Add the reverse mapping

   569                         targetBPs.put(targetBP, breakpoint);

   570 

   571                         // And update the corresponding thread list

   572                         Set<String> thrds = threadsIDs.get(breakpoint);

   573                         if (thrds == null)

   574                             thrds = new HashSet<String>();

   575                         thrds.add(thread);

   576                         threadsIDs.put(breakpoint, thrds);

   577 

   578                         // Reset the thread (is it necessary?)

   579                         attributes.put(ATTR_THREAD_ID, NULL_STRING);

   580 

   581                         // Remove breakpoint problem marker (if any)

   582                         removeBreakpointProblemMarker(breakpoint);

   583 

   584                         // Finally, update the platform breakpoint

   585                         try {

   586 							breakpoint.incrementInstallCount();

   587 						} catch (CoreException e) {

   588 						}

   589                         installRM.done();

   590                     }

   591 

   592                     @Override

   593                     protected void handleError() {

   594                         addBreakpointProblemMarker(breakpoint, "Breakpoint attribute problem: installation failed", IMarker.SEVERITY_WARNING); //$NON-NLS-1$

   595                         installRM.done();

   596                     }

   597                 };

   598 

   599             // Convert the breakpoint attributes for the back-end

   600             attributes.put(ATTR_THREAD_ID, thread);

   601             Map<String,Object> targetAttributes = convertToTargetBreakpoint(breakpoint, attributes);

   602             fBreakpoints.insertBreakpoint(dmc, targetAttributes, drm);

   603         }

   604     }

   605 

   606     private void addBreakpointProblemMarker(final ICBreakpoint breakpoint, final String description, final int severity) {

   607 

   608         new Job("Add Breakpoint Problem Marker") { //$NON-NLS-1$

   609             @Override

   610             protected IStatus run(IProgressMonitor monitor) {

   611                 

   612                 if (breakpoint instanceof ICLineBreakpoint) {

   613                 	// If we have already have a problem marker on this breakpoint

   614                 	// we should remove it first.

   615                     IMarker marker = fBreakpointMarkerProblems.remove(breakpoint);

   616                     if (marker != null) {

   617                         try {

   618                             marker.delete();

   619                         } catch (CoreException e) {

   620                         }

   621                 	}

   622 

   623                     ICLineBreakpoint lineBreakpoint = (ICLineBreakpoint) breakpoint;

   624                     try {

   625                         // Locate the workspace resource via the breakpoint marker

   626                         IMarker breakpoint_marker = lineBreakpoint.getMarker();

   627                         IResource resource = breakpoint_marker.getResource();

   628 

   629                         // Add a problem marker to the resource

   630                         IMarker problem_marker = resource.createMarker(BreakpointProblems.BREAKPOINT_PROBLEM_MARKER_ID);

   631                         int line_number = lineBreakpoint.getLineNumber();

   632                         problem_marker.setAttribute(IMarker.LOCATION,    String.valueOf(line_number));

   633                         problem_marker.setAttribute(IMarker.MESSAGE,     description);

   634                         problem_marker.setAttribute(IMarker.SEVERITY,    severity);

   635                         problem_marker.setAttribute(IMarker.LINE_NUMBER, line_number);

   636 

   637                         // And save the baby

   638                         fBreakpointMarkerProblems.put(breakpoint, problem_marker);

   639                     } catch (CoreException e) {

   640                     }

   641                 }

   642                 return Status.OK_STATUS;

   643             }

   644         }.schedule();

   645     }

   646 

   647     private void removeBreakpointProblemMarker(final ICBreakpoint breakpoint) {

   648 

   649         new Job("Remove Breakpoint Problem Marker") { //$NON-NLS-1$

   650             @Override

   651             protected IStatus run(IProgressMonitor monitor) {

   652                 

   653                 IMarker marker = fBreakpointMarkerProblems.remove(breakpoint);

   654                 if (marker != null) {

   655                     try {

   656                         marker.delete();

   657                     } catch (CoreException e) {

   658                     }

   659                 }

   660 

   661                 return Status.OK_STATUS;

   662             }

   663         }.schedule();

   664     }

   665 

   666     //-------------------------------------------------------------------------

   667     // uninstallBreakpoint

   668     //-------------------------------------------------------------------------

   669 

   670     /**

   671      * Un-install an individual breakpoint on the back-end. For one platform

   672      * breakpoint in a given execution context, there could be multiple

   673      * corresponding back-end breakpoints (one per thread).

   674      * 

   675      * @param dmc

   676      * @param breakpoint

   677      * @param rm

   678      */

   679     private void uninstallBreakpoint(final IBreakpointsTargetDMContext dmc,

   680             final ICBreakpoint breakpoint, final RequestMonitor rm)

   681     {

   682         // Retrieve the breakpoint maps

   683         final Map<ICBreakpoint,Map<String,Object>> platformBPs = fPlatformBPs.get(dmc);

   684         assert platformBPs != null;

   685 

   686         final Map<ICBreakpoint, Vector<IBreakpointDMContext>> breakpointIDs = fBreakpointIDs.get(dmc);

   687         assert breakpointIDs != null;

   688 

   689         final Map<IBreakpointDMContext, ICBreakpoint> targetBPs = fTargetBPs.get(dmc);

   690         assert targetBPs != null;

   691 

   692         final Map<ICBreakpoint, Set<String>> threadsIDs = fBreakpointThreads.get(dmc);

   693         assert threadsIDs != null;

   694 

   695         // Remove breakpoint problem marker (if any)

   696         removeBreakpointProblemMarker(breakpoint);

   697 

   698         // Minimal validation

   699         if (!platformBPs.containsKey(breakpoint) || !breakpointIDs.containsKey(breakpoint) || !targetBPs.containsValue(breakpoint)) {

   700             rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, BREAKPOINT_ALREADY_REMOVED, null));

   701             rm.done();

   702             return;

   703         }

   704 

   705         // Remove completion monitor

   706         // Upon completion, update the mappings

   707         CountingRequestMonitor removeRM = new CountingRequestMonitor(getExecutor(), rm) {

   708             @Override

   709             protected void handleSuccess() {

   710                 // Update the mappings

   711                 platformBPs.remove(breakpoint);

   712                 threadsIDs.remove(breakpoint);

   713 

   714                 Vector<IBreakpointDMContext> contexts = breakpointIDs.get(breakpoint);

   715                 if (contexts != null) {

   716                     for (IBreakpointDMContext context : contexts)

   717                         targetBPs.remove(context);

   718                 }

   719 

   720                 breakpointIDs.get(breakpoint).clear();

   721                 breakpointIDs.remove(breakpoint);

   722 

   723                 fPendingRequests.remove(breakpoint);

   724 

   725 				rm.done();

   726             }

   727         };

   728 

   729         // Remove the back-end breakpoints

   730         Vector<IBreakpointDMContext> list = breakpointIDs.get(breakpoint);

   731         int count = 0;

   732         if (list != null) {

   733             for (IBreakpointDMContext bp : list) {

   734                 fBreakpoints.removeBreakpoint(bp, removeRM);

   735                 try {

   736 					breakpoint.decrementInstallCount();

   737 				} catch (CoreException e) {

   738 				}

   739             }

   740             count = list.size();

   741         }

   742         removeRM.setDoneCount(count);

   743     }

   744 

   745     //-------------------------------------------------------------------------

   746     // modifyBreakpoint

   747     //-------------------------------------------------------------------------

   748 

   749     /**

   750      * Modify a platform breakpoint which can translate to quite a few updates

   751      * on the target...

   752      * 

   753      * @param dmc

   754      * @param breakpoint

   755      * @param attributes

   756      * @param oldValues

   757      * @param rm

   758      */

   759     private void modifyBreakpoint(final IBreakpointsTargetDMContext dmc, final ICBreakpoint breakpoint,

   760             final Map<String,Object> attributes, final IMarkerDelta oldValues, final RequestMonitor rm)

   761     {

   762         // Retrieve the breakpoint maps

   763         final Map<ICBreakpoint,Map<String,Object>> platformBPs = fPlatformBPs.get(dmc);

   764         assert platformBPs != null;

   765 

   766         final Map<ICBreakpoint, Vector<IBreakpointDMContext>> breakpointIDs = fBreakpointIDs.get(dmc);

   767         assert breakpointIDs != null;

   768 

   769         final Map<IBreakpointDMContext, ICBreakpoint> targetBPs = fTargetBPs.get(dmc);

   770         assert targetBPs != null;

   771 

   772         final Map<ICBreakpoint, Set<String>> threadsIDs = fBreakpointThreads.get(dmc);

   773         assert threadsIDs != null;

   774 

   775         // Minimal validation

   776         if (!platformBPs.containsKey(breakpoint)) {

   777             rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, UNKNOWN_BREAKPOINT, null));

   778             rm.done();

   779             return;

   780         }

   781 

   782         // Check if the breakpoint is installed: it might not have been if it wasn't enabled at startup (Bug261082)

   783         // Or the installation might have failed; in this case, we still try to install it again because

   784         // some attribute might have changed which will make the install succeed.

   785         if (!breakpointIDs.containsKey(breakpoint) && !targetBPs.containsValue(breakpoint)) {

   786         	// Install only if the breakpoint is enabled

   787         	boolean bpEnabled = attributes.get(ICBreakpoint.ENABLED).equals(true) && fBreakpointManager.isEnabled();

   788         	if (bpEnabled) {

   789                 attributes.put(ATTR_DEBUGGER_PATH, NULL_STRING);

   790                 attributes.put(ATTR_THREAD_FILTER, extractThreads(dmc, breakpoint));

   791                 attributes.put(ATTR_THREAD_ID, NULL_STRING);

   792                 determineDebuggerPath(dmc, attributes, new RequestMonitor(getExecutor(), rm) {

   793                     @Override

   794                     protected void handleSuccess() {

   795                       	installBreakpoint(dmc, breakpoint, attributes, rm);

   796                     }

   797                 });

   798         	}

   799         	else {

   800                 rm.done();

   801         	}

   802        		return;

   803         }

   804 

   805         // Get the original breakpoint attributes

   806         final Map<String,Object> original_attributes = platformBPs.get(breakpoint);

   807         if (original_attributes == null) {

   808             rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, INVALID_BREAKPOINT, null));

   809             rm.done();

   810             return;

   811         }

   812 

   813         // Determine the attributes delta

   814         final Map<String,Object> oldAttributes = new HashMap<String,Object>(original_attributes);

   815         oldAttributes.put(ATTR_THREAD_FILTER, threadsIDs.get(breakpoint));

   816 

   817         final Set<String> newThreads = extractThreads(dmc, breakpoint);

   818         Map<String,Object> newAttributes = new HashMap<String,Object>(attributes);

   819         newAttributes.put(ATTR_THREAD_FILTER, newThreads);

   820 

   821         final Map<String,Object> attributesDelta = determineAttributesDelta(oldAttributes, newAttributes);

   822 

   823         // Get the list of back-end breakpoints

   824         final Vector<IBreakpointDMContext> oldTargetBPs = new Vector<IBreakpointDMContext>(breakpointIDs.get(breakpoint));

   825         if (oldTargetBPs == null) {

   826             rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, INVALID_BREAKPOINT, null));

   827             rm.done();

   828             return;

   829         }

   830 

   831         // We're all set for the breakpoint update.

   832         //

   833         // The path for a simple update is straightforward:

   834         // - For each back-end BP corresponding to a platform BP

   835         //   - Send an update command to the back-end

   836         //   - If the operation succeeded, update the data structures

   837         //   - If the operation failed, try to roll-back

   838         //

   839         // In cases where the the back-end breakpoint cannot be

   840         // simply updated (e.g. thread filter modification), the old

   841         // breakpoint has to be removed and new one(s) inserted.

   842         //

   843         // The path for such an update is:

   844         // - Install the updated breakpoint

   845         // - In the operation succeeded

   846         //   - Remove the old breakpoint(s)

   847         //   - Perform any pending update

   848 

   849         // Update completion monitor

   850         final CountingRequestMonitor updateRM = new CountingRequestMonitor(getExecutor(), rm) {

   851             @Override

   852             protected void handleSuccess() {

   853                 // Success: simply store the new attributes

   854                 platformBPs.put(breakpoint, attributes);

   855                 rm.done();

   856             }

   857 

   858             @Override

   859             protected void handleError() {

   860                 // Reset the breakpoint attributes. This will trigger a

   861                 // breakpoint change event and the correct delta will be

   862                 // computed, resulting in a correctly restored breakpoint

   863                 // at the back-end.

   864                 rollbackAttributes(breakpoint, oldValues);

   865                 platformBPs.put(breakpoint, attributes);

   866 

   867                 rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, REQUEST_FAILED, INVALID_PARAMETER, null));

   868                 rm.done();

   869             }

   870         };

   871 

   872         // Everything OK: remove the old back-end breakpoints

   873         final Vector<IBreakpointDMContext> newTargetBPs = new Vector<IBreakpointDMContext>();

   874         final CountingRequestMonitor removeRM = new CountingRequestMonitor(getExecutor(), rm) {

   875             @Override

   876             protected void handleSuccess() {

   877                 // All right! Save the new list and perform the final update

   878                 Map<ICBreakpoint, Vector<IBreakpointDMContext>> breakpointIDs = fBreakpointIDs.get(dmc);

   879                 if (breakpointIDs == null) {

   880                     rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, REQUEST_FAILED, INVALID_BREAKPOINT, null));

   881                     rm.done();

   882                     return;

   883                 }

   884                 breakpointIDs.put(breakpoint, newTargetBPs);

   885                 for (IBreakpointDMContext ref : newTargetBPs) {

   886                     fBreakpoints.updateBreakpoint(ref, attributesDelta, updateRM);

   887                 }

   888                 updateRM.setDoneCount(newTargetBPs.size());

   889             }};

   890 

   891         // New back-end breakpoints insertion monitor

   892         // Holds the list of new back-end breakpoint contexts of the platform breakpoint

   893         final DataRequestMonitor<Vector<IBreakpointDMContext>> insertRM =

   894             new DataRequestMonitor<Vector<IBreakpointDMContext>>(getExecutor(), null) {

   895 

   896                 @Override

   897                 // In theory, we could have had a partial success and the original threads

   898                 // list would be invalid. We think it is highly unlikely so we assume that

   899                 // either everything went fine or else everything failed.

   900                 protected void handleSuccess() {

   901                     // Get the list of new back-end breakpoints contexts

   902                     newTargetBPs.addAll(getData());

   903                     threadsIDs.put(breakpoint, newThreads);

   904                     for (IBreakpointDMContext ref : oldTargetBPs) {

   905                         fBreakpoints.removeBreakpoint(ref, removeRM);

   906                         try {

   907 							breakpoint.decrementInstallCount();  // A tad early but it should work...

   908 						} catch (CoreException e) {

   909 						}

   910                     }

   911                     removeRM.setDoneCount(oldTargetBPs.size());

   912                 }

   913                 

   914                 @Override

   915                 protected void handleError() {

   916                     // Keep the old threads list and reset the attributes

   917                     // (bad attributes are the likely cause of failure)

   918                     updateRM.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, REQUEST_FAILED, INVALID_PARAMETER, null));

   919                     updateRM.setDoneCount(0);

   920                 }

   921         };

   922 

   923         // If the changes in the breakpoint attributes justify it, install a

   924         // new set of back-end breakpoint(s) and then update them

   925         if (needsResinstallation(attributesDelta)) {

   926             reinstallBreakpoint(dmc, breakpoint, attributes, newThreads, insertRM);

   927         }

   928         else {

   929             // Update the back-end breakpoint(s) state

   930             for (IBreakpointDMContext ref : oldTargetBPs) {

   931                 fBreakpoints.updateBreakpoint(ref, attributesDelta, updateRM);

   932             }

   933             updateRM.setDoneCount(oldTargetBPs.size());

   934         }

   935     }

   936 

   937     /**

   938      * Re-install the back-end breakpoints

   939      * 

   940      * @param context       the target context

   941      * @param breakpoint    the platform breakpoint

   942      * @param attributes    breakpoint augmented attributes

   943      * @param threads       list of threads where breakpoint is to be installed

   944      * @param drm           will contain the list of successfully installed back-end breakpoints

   945      */

   946     private void reinstallBreakpoint(final IBreakpointsTargetDMContext context, final ICBreakpoint breakpoint,

   947             final Map<String,Object> attributes, Set<String> threads, final DataRequestMonitor<Vector<IBreakpointDMContext>> drm)

   948     {

   949         // Our new list of back-end breakpoints. Built as we go.

   950         final Vector<IBreakpointDMContext> breakpointList = new Vector<IBreakpointDMContext>();

   951 

   952         // Counting monitor for the new back-end breakpoints to install

   953         // Once we're done, return the new list of back-end breakpoints contexts

   954         final CountingRequestMonitor installRM = new CountingRequestMonitor(getExecutor(), drm) {

   955             @Override

   956             protected void handleSuccess() {

   957                 // Report whatever we have managed to install

   958                 // It is very likely installation either succeeded or failed for all

   959                 drm.setData(breakpointList);

   960                 drm.done();

   961             }

   962         };

   963         installRM.setDoneCount(threads.size());

   964 

   965         // And install the new back-end breakpoints

   966         for (String thread : threads) {

   967             // Convert the breakpoint attributes for the back-end

   968             // Refresh the set of attributes at each iteration just in case...

   969             Map<String,Object> attrs = convertToTargetBreakpoint(breakpoint, attributes);

   970             if (!fBreakpointManager.isEnabled()) {

   971                 attrs.put(MIBreakpoints.IS_ENABLED, false);

   972             }

   973             // Add the secret ingredient..

   974             attrs.put(MIBreakpointDMData.THREAD_ID, thread);

   975 

   976             // Then install the spiked breakpoint

   977             fBreakpoints.insertBreakpoint(context, attrs,

   978                 new DataRequestMonitor<IBreakpointDMContext>(getExecutor(), installRM) {

   979                     @Override

   980                     protected void handleSuccess() {

   981                         // Add the new back-end breakpoint context to the list

   982                         breakpointList.add(getData());

   983                         try {

   984 							breakpoint.incrementInstallCount();

   985 						} catch (CoreException e) {

   986 						}

   987                         installRM.done();

   988                     }

   989 

   990                     @Override

   991                     protected void handleError() {

   992                         // Add the new back-end breakpoint context to the list

   993                         installRM.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, REQUEST_FAILED, INVALID_PARAMETER, null));

   994                         installRM.done();

   995                     }

   996             });

   997         }

   998     }

   999 

  1000     ///////////////////////////////////////////////////////////////////////////

  1001     // IBreakpointManagerListener implementation

  1002     ///////////////////////////////////////////////////////////////////////////

  1003 

  1004     /* (non-Javadoc)

  1005      * @see org.eclipse.debug.core.IBreakpointManagerListener#breakpointManagerEnablementChanged(boolean)

  1006      */

  1007     public void breakpointManagerEnablementChanged(boolean enabled) {

  1008 

  1009         // Only modify enabled breakpoints

  1010         for (IBreakpointsTargetDMContext context : fBreakpointIDs.keySet()) {

  1011             for (ICBreakpoint breakpoint : fBreakpointIDs.get(context).keySet()) {

  1012                 try {

  1013                     if (breakpoint.isEnabled()) {

  1014                         for (IBreakpointDMContext ref : fBreakpointIDs.get(context).get(breakpoint)) {

  1015                             Map<String,Object> delta = new HashMap<String,Object>();

  1016                             delta.put(MIBreakpoints.IS_ENABLED, enabled);

  1017                             fBreakpoints.updateBreakpoint(ref, delta, new RequestMonitor(getExecutor(), null));

  1018                         }

  1019                     }

  1020                 } catch (CoreException e) {

  1021                 }

  1022             }

  1023         }

  1024     }

  1025 

  1026     ///////////////////////////////////////////////////////////////////////////

  1027     // IBreakpointListener implementation

  1028     ///////////////////////////////////////////////////////////////////////////

  1029 

  1030     /* (non-Javadoc)

  1031      * @see org.eclipse.debug.core.IBreakpointListener#breakpointAdded(org.eclipse.debug.core.model.IBreakpoint)

  1032      */

  1033     @ThreadSafe

  1034     public void breakpointAdded(final IBreakpoint breakpoint) {

  1035 

  1036         if (supportsBreakpoint(breakpoint)) {

  1037             try {

  1038                 // Retrieve the breakpoint attributes

  1039                 @SuppressWarnings("unchecked")

  1040                 final Map<String, Object> attrs = breakpoint.getMarker().getAttributes();

  1041 

  1042                 getExecutor().execute(new DsfRunnable() {

  1043                     public void run() {

  1044                         final CountingRequestMonitor countingRm = new CountingRequestMonitor(getExecutor(), null) {

  1045                             @Override

  1046                             protected void handleError() {

  1047                                 if (getStatus().getSeverity() == IStatus.ERROR) {

  1048                                     GdbPlugin.getDefault().getLog().log(getStatus());

  1049                                 }

  1050                             }

  1051                         };

  1052                         countingRm.setDoneCount(fPlatformBPs.size());

  1053 

  1054                         // Install the breakpoint in all the execution contexts

  1055                         for (final IBreakpointsTargetDMContext dmc : fPlatformBPs.keySet()) {

  1056                             determineDebuggerPath(dmc, attrs,

  1057                                     new RequestMonitor(getExecutor(), countingRm) {

  1058                                     @Override

  1059                                     protected void handleSuccess() {

  1060                                         installBreakpoint(dmc, (ICBreakpoint) breakpoint,

  1061                                             attrs, countingRm);

  1062                                     }

  1063                                 });

  1064                         }

  1065                     }

  1066                 });

  1067             } catch (CoreException e) {

  1068             } catch (RejectedExecutionException e) {

  1069             }

  1070         }

  1071     }

  1072 

  1073     /**

  1074      * @param bp

  1075      * @return

  1076      * @throws CoreException

  1077      */

  1078     private IDsfBreakpointExtension getFilterExtension(ICBreakpoint bp) throws CoreException {

  1079         return (IDsfBreakpointExtension) bp.getExtension(GDB_DEBUG_MODEL_ID, ICBreakpointExtension.class);

  1080     }

  1081 

  1082     /* (non-Javadoc)

  1083      * @see org.eclipse.debug.core.IBreakpointListener#breakpointChanged(org.eclipse.debug.core.model.IBreakpoint, org.eclipse.core.resources.IMarkerDelta)

  1084      */

  1085     public void breakpointChanged(final IBreakpoint breakpoint, final IMarkerDelta delta) {

  1086 

  1087         if (supportsBreakpoint(breakpoint)) {

  1088 

  1089             try {

  1090                 // Retrieve the breakpoint attributes

  1091                 @SuppressWarnings("unchecked")

  1092                 final Map<String, Object> attrs = breakpoint.getMarker().getAttributes();

  1093                 if (!fBreakpointManager.isEnabled()) {

  1094                     attrs.put(ICBreakpoint.ENABLED, false);

  1095                 }

  1096 

  1097                 // Modify the breakpoint in all the target contexts

  1098                 getExecutor().execute( new DsfRunnable() {

  1099                     public void run() {

  1100 

  1101                         // If the breakpoint is currently being updated, queue the request and exit

  1102                         if (fPendingRequests.contains(breakpoint)) {

  1103                             fPendingBreakpoints.add(breakpoint);

  1104                             return;

  1105                         }

  1106 

  1107                         // Keep track of the updates

  1108                         final CountingRequestMonitor countingRm = new CountingRequestMonitor(getExecutor(), null) {

  1109                             @Override

  1110                             protected void handleCompleted() {

  1111 

  1112                                 if (!isSuccess()) {

  1113                                     if (getStatus().getSeverity() == IStatus.ERROR) {

  1114                                         GdbPlugin.getDefault().getLog().log(getStatus());

  1115                                     }

  1116                                 }

  1117 

  1118                                 // Indicate that the pending request has completed

  1119                                 fPendingRequests.remove(breakpoint);

  1120 

  1121                                 // Process the next pending update for this breakpoint

  1122                                 if (fPendingBreakpoints.contains(breakpoint)) {

  1123                                     fPendingBreakpoints.remove(breakpoint);

  1124                                     breakpointChanged(breakpoint, delta);

  1125                                 }

  1126                             }

  1127                         };

  1128                         countingRm.setDoneCount(fPlatformBPs.size());

  1129 

  1130                         // Mark the breakpoint as being updated and go

  1131                         fPendingRequests.add(breakpoint);

  1132                         

  1133                         // Modify the breakpoint in all the execution contexts

  1134                         for (final IBreakpointsTargetDMContext dmc : fPlatformBPs.keySet()) {

  1135                             determineDebuggerPath(dmc, attrs,

  1136                                 new RequestMonitor(getExecutor(), countingRm) {

  1137                                     @Override

  1138                                     protected void handleSuccess() {

  1139                                         modifyBreakpoint(dmc, (ICBreakpoint) breakpoint, attrs, delta, new RequestMonitor(getExecutor(), countingRm));

  1140                                     }

  1141                                  });

  1142                         }

  1143                     }

  1144                 });

  1145             } catch (CoreException e) {

  1146             } catch (RejectedExecutionException e) {