plugins/org.symbian.tools.tmw.debug/src/org/symbian/tools/wrttools/debug/internal/model/WorkspaceBreakpointHandler.java
changeset 471 06589bf52fa7
parent 470 d4809db37847
child 472 bd9f2d7c64a6
equal deleted inserted replaced
470:d4809db37847 471:06589bf52fa7
     1 /**
       
     2  * 
       
     3  */
       
     4 package org.symbian.tools.wrttools.debug.internal.model;
       
     5 
       
     6 import java.util.Collection;
       
     7 
       
     8 import org.chromium.debug.core.ChromiumDebugPlugin;
       
     9 import org.chromium.debug.core.model.BreakpointMap;
       
    10 import org.chromium.debug.core.model.BreakpointSynchronizer.BreakpointHelper.CreateCallback;
       
    11 import org.chromium.debug.core.model.ChromiumLineBreakpoint;
       
    12 import org.chromium.debug.core.model.DebugTargetImpl;
       
    13 import org.chromium.debug.core.model.VProjectWorkspaceBridge;
       
    14 import org.chromium.debug.core.model.VmResourceId;
       
    15 import org.chromium.debug.core.model.WorkspaceBridge.BreakpointHandler;
       
    16 import org.chromium.sdk.Breakpoint;
       
    17 import org.chromium.sdk.JavascriptVm;
       
    18 import org.chromium.sdk.SyncCallback;
       
    19 import org.eclipse.core.resources.IFile;
       
    20 import org.eclipse.core.resources.IMarkerDelta;
       
    21 import org.eclipse.core.runtime.CoreException;
       
    22 import org.eclipse.debug.core.model.IBreakpoint;
       
    23 import org.symbian.tools.tmw.previewer.PreviewerPlugin;
       
    24 import org.symbian.tools.wrttools.debug.internal.launch.WRTProjectWorkspaceBridge;
       
    25 
       
    26 public final class WorkspaceBreakpointHandler implements BreakpointHandler {
       
    27 	private final BreakpointMap.InTargetMap breakpointInTargetMap = new BreakpointMap.InTargetMap();
       
    28 	private final DebugTargetImpl debugTarget;
       
    29 	private final ResourceManager resourceManager;
       
    30 	
       
    31     public WorkspaceBreakpointHandler(DebugTargetImpl debugTarget, ResourceManager resourceManager) {
       
    32 		this.debugTarget = debugTarget;
       
    33         //		this.vm = vm;
       
    34 		this.resourceManager = resourceManager;
       
    35 	}
       
    36 
       
    37     public void breakpointAdded(IBreakpoint breakpoint) {
       
    38         ChromiumLineBreakpoint lineBreakpoint = tryCastBreakpoint(breakpoint);
       
    39         if (lineBreakpoint == null) {
       
    40             return;
       
    41         }
       
    42         if (ChromiumLineBreakpoint.getIgnoreList().contains(breakpoint)) {
       
    43             return;
       
    44         }
       
    45         if (!lineBreakpoint.isEnabled()) {
       
    46             return;
       
    47         }
       
    48         IFile file = (IFile) lineBreakpoint.getMarker().getResource();
       
    49         VmResourceId vmResourceId;
       
    50         try {
       
    51             vmResourceId = findVmResourceIdFromWorkspaceFile(file);
       
    52         } catch (CoreException e) {
       
    53             ChromiumDebugPlugin.log(new Exception("Failed to resolve script for the file " + file, e)); //$NON-NLS-1$
       
    54             return;
       
    55         }
       
    56         if (vmResourceId == null) {
       
    57             // Might be a script from a different debug target
       
    58             return;
       
    59         }
       
    60         createBreakpointOnRemote(lineBreakpoint, vmResourceId, null, null);
       
    61     }
       
    62 
       
    63     public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
       
    64         ChromiumLineBreakpoint lineBreakpoint = tryCastBreakpoint(breakpoint);
       
    65         if (lineBreakpoint == null) {
       
    66             return;
       
    67         }
       
    68         if (ChromiumLineBreakpoint.getIgnoreList().contains(lineBreakpoint)) {
       
    69             return;
       
    70         }
       
    71         Breakpoint sdkBreakpoint = breakpointInTargetMap.getSdkBreakpoint(lineBreakpoint);
       
    72         if (sdkBreakpoint == null) {
       
    73             return;
       
    74         }
       
    75 
       
    76         try {
       
    77             ChromiumLineBreakpoint.Helper.updateOnRemote(sdkBreakpoint, lineBreakpoint);
       
    78         } catch (RuntimeException e) {
       
    79             ChromiumDebugPlugin.log(new Exception("Failed to change breakpoint in " + //$NON-NLS-1$
       
    80                     getTargetNameSafe(), e));
       
    81         }
       
    82 
       
    83     }
       
    84 
       
    85     public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
       
    86         ChromiumLineBreakpoint lineBreakpoint = tryCastBreakpoint(breakpoint);
       
    87         if (lineBreakpoint == null) {
       
    88             return;
       
    89         }
       
    90         if (ChromiumLineBreakpoint.getIgnoreList().contains(lineBreakpoint)) {
       
    91             return;
       
    92         }
       
    93 
       
    94         Breakpoint sdkBreakpoint = breakpointInTargetMap.getSdkBreakpoint(lineBreakpoint);
       
    95         if (sdkBreakpoint == null) {
       
    96             return;
       
    97         }
       
    98 
       
    99         try {
       
   100             if (!breakpoint.isEnabled()) {
       
   101             return;
       
   102             }
       
   103         } catch (CoreException e) {
       
   104             ChromiumDebugPlugin.log(e);
       
   105             return;
       
   106         }
       
   107         JavascriptVm.BreakpointCallback callback = new JavascriptVm.BreakpointCallback() {
       
   108             public void failure(String errorMessage) {
       
   109                 ChromiumDebugPlugin.log(new Exception("Failed to remove breakpoint in " + //$NON-NLS-1$
       
   110                         getTargetNameSafe() + ": " + errorMessage)); //$NON-NLS-1$
       
   111             }
       
   112 
       
   113             public void success(Breakpoint breakpoint) {
       
   114             }
       
   115         };
       
   116         try {
       
   117             sdkBreakpoint.clear(callback, null);
       
   118         } catch (RuntimeException e) {
       
   119             ChromiumDebugPlugin.log(new Exception("Failed to remove breakpoint in " + //$NON-NLS-1$
       
   120                     getTargetNameSafe(), e));
       
   121         }
       
   122         breakpointInTargetMap.remove(lineBreakpoint);
       
   123     }
       
   124 
       
   125     public void breakpointsHit(Collection<? extends Breakpoint> breakpointsHit) {
       
   126         if (breakpointsHit.isEmpty()) {
       
   127             return;
       
   128         }
       
   129 
       
   130         for (Breakpoint sdkBreakpoint : breakpointsHit) {
       
   131             ChromiumLineBreakpoint uiBreakpoint = breakpointInTargetMap.getUiBreakpoint(sdkBreakpoint);
       
   132             if (uiBreakpoint != null) {
       
   133                 uiBreakpoint.setIgnoreCount(-1); // reset ignore count as we've hit it
       
   134             }
       
   135         }
       
   136     }
       
   137 
       
   138     public void createBreakpointOnRemote(final ChromiumLineBreakpoint lineBreakpoint, final VmResourceId vmResourceId,
       
   139             final CreateCallback createCallback, SyncCallback syncCallback) {
       
   140         try {
       
   141             ChromiumLineBreakpoint.Helper.CreateOnRemoveCallback callback = new ChromiumLineBreakpoint.Helper.CreateOnRemoveCallback() {
       
   142                 public void failure(String errorMessage) {
       
   143                     if (createCallback == null) {
       
   144                         ChromiumDebugPlugin.logError(errorMessage);
       
   145                     } else {
       
   146                         createCallback.failure(new Exception(errorMessage));
       
   147                     }
       
   148                 }
       
   149 
       
   150                 public void success(Breakpoint breakpoint) {
       
   151                     breakpointInTargetMap.add(breakpoint, lineBreakpoint);
       
   152                     if (createCallback != null) {
       
   153                         createCallback.success();
       
   154                     }
       
   155                 }
       
   156             };
       
   157 
       
   158             ChromiumLineBreakpoint.Helper.createOnRemote(lineBreakpoint, vmResourceId, debugTarget, callback,
       
   159                     syncCallback);
       
   160         } catch (CoreException e) {
       
   161             ChromiumDebugPlugin.log(new Exception("Failed to create breakpoint in " + //$NON-NLS-1$
       
   162                     getTargetNameSafe(), e));
       
   163         }
       
   164     }
       
   165 
       
   166     private VmResourceId findVmResourceIdFromWorkspaceFile(IFile resource) throws CoreException {
       
   167         return VmResourceId.forName(PreviewerPlugin.getDefault().getHttpPreviewer().getHttpUrl(resource));
       
   168     }
       
   169 
       
   170     private String getTargetNameSafe() {
       
   171         try {
       
   172             return debugTarget.getLaunch().getLaunchConfiguration().getName();
       
   173         } catch (RuntimeException e) {
       
   174           return "<unknown>"; //$NON-NLS-1$
       
   175         }
       
   176     }
       
   177 
       
   178     public boolean supportsBreakpoint(IBreakpoint breakpoint) {
       
   179 		return (WRTProjectWorkspaceBridge.DEBUG_MODEL_ID.equals(breakpoint
       
   180 				.getModelIdentifier()) || VProjectWorkspaceBridge.DEBUG_MODEL_ID
       
   181 				.equals(breakpoint.getModelIdentifier()))
       
   182 				&& !debugTarget.isDisconnected();
       
   183 	}
       
   184 
       
   185     public ChromiumLineBreakpoint tryCastBreakpoint(IBreakpoint breakpoint) {
       
   186         if (!supportsBreakpoint(breakpoint)) {
       
   187             return null;
       
   188         }
       
   189         if (breakpoint instanceof ChromiumLineBreakpoint == false) {
       
   190             return null;
       
   191         }
       
   192         return (ChromiumLineBreakpoint) breakpoint;
       
   193     }
       
   194 
       
   195 }