Version 1.1.0-dev.5.3

dart/editor/tools/plugins/com.google.dart.tools.debug.core/src/com/google/dart/tools/debug/core/dartium/BreakpointManager.java

 /*
  * Copyright (c) 2012, the Dart project authors.
- * 
+ *
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
- * 
+ *
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 
 package com.google.dart.tools.debug.core.dartium;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.dart.tools.core.DartCore;
 import com.google.dart.tools.debug.core.DartDebugCorePlugin;
 import com.google.dart.tools.debug.core.breakpoints.DartBreakpoint;
 import com.google.dart.tools.debug.core.util.IResourceResolver;
 import com.google.dart.tools.debug.core.webkit.WebkitBreakpoint;
 import com.google.dart.tools.debug.core.webkit.WebkitCallback;
 import com.google.dart.tools.debug.core.webkit.WebkitLocation;
 import com.google.dart.tools.debug.core.webkit.WebkitResult;
 import com.google.dart.tools.debug.core.webkit.WebkitScript;
 
 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IMarkerDelta;
 import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.runtime.Path;
 import org.eclipse.debug.core.DebugPlugin;
 import org.eclipse.debug.core.IBreakpointListener;
 import org.eclipse.debug.core.model.IBreakpoint;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 /**
  * Handle adding a removing breakpoints to the WebKit connection for the DartiumDebugTarget class.
  */
-class BreakpointManager implements IBreakpointListener {
+public class BreakpointManager implements IBreakpointListener {
 
   private static String PACKAGES_DIRECTORY_PATH = "/packages/";
   private static String LIB_DIRECTORY_PATH = "/lib/";
 
   private DartiumDebugTarget debugTarget;
 
-  private Map<IBreakpoint, List<String>> breakpointToIdMap = new HashMap<IBreakpoint, List<String>>();
-  private Map<String, DartBreakpoint> breakpointsToUpdateMap = new HashMap<String, DartBreakpoint>();
+  private Map<IBreakpoint, List<String>>
+      breakpointToIdMap = new HashMap<IBreakpoint, List<String>>();
+  private Map<String, DartBreakpoint>
+      breakpointsToUpdateMap = new HashMap<String, DartBreakpoint>();
 
   private List<IBreakpoint> ignoredBreakpoints = new ArrayList<IBreakpoint>();
 
   public BreakpointManager(DartiumDebugTarget debugTarget) {
     this.debugTarget = debugTarget;
   }
 
   @Override
   public void breakpointAdded(IBreakpoint breakpoint) {
     if (debugTarget.supportsBreakpoint(breakpoint)) {
@@ skipping 37 matching lines @@
             if (!debugTarget.isTerminated()) {
               DartDebugCorePlugin.logError(exception);
             }
           }
         }
       }
     }
   }
 
   public void connect() throws IOException {
-    IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(
-        DartDebugCorePlugin.DEBUG_MODEL_ID);
+    IBreakpoint[] breakpoints = DebugPlugin.getDefault()
+        .getBreakpointManager().getBreakpoints(DartDebugCorePlugin.DEBUG_MODEL_ID);
 
     for (IBreakpoint breakpoint : breakpoints) {
       if (debugTarget.supportsBreakpoint(breakpoint)) {
         addBreakpoint((DartBreakpoint) breakpoint);
       }
     }
 
     DebugPlugin.getDefault().getBreakpointManager().addBreakpointListener(this);
   }
 
@@ skipping 14 matching lines @@
             DartDebugCorePlugin.logError(exception);
           }
         }
       }
 
       DebugPlugin.getDefault().getBreakpointManager().removeBreakpointListener(this);
     }
   }
 
   public DartBreakpoint getBreakpointFor(WebkitLocation location) {
-    IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(
-        DartDebugCorePlugin.DEBUG_MODEL_ID);
+    IBreakpoint[] breakpoints = DebugPlugin.getDefault()
+        .getBreakpointManager().getBreakpoints(DartDebugCorePlugin.DEBUG_MODEL_ID);
 
-    WebkitScript script = debugTarget.getWebkitConnection().getDebugger().getScript(
-        location.getScriptId());
+    WebkitScript script = debugTarget.getWebkitConnection()
+        .getDebugger().getScript(location.getScriptId());
 
     if (script == null) {
       return null;
     }
 
     String url = script.getUrl();
     int line = WebkitLocation.webkitToElipseLine(location.getLineNumber());
 
     for (IBreakpoint bp : breakpoints) {
       if (debugTarget.supportsBreakpoint(bp)) {
         DartBreakpoint breakpoint = (DartBreakpoint) bp;
 
         if (breakpoint.getLine() == line) {
           String bpUrl = getResourceResolver().getUrlForResource(breakpoint.getFile());
 
           if (bpUrl != null && bpUrl.equals(url)) {
             return breakpoint;
           }
         }
       }
     }
 
     return null;
   }
 
+  @VisibleForTesting
+  public String getPackagePath(String regex, IFile resource) {
+    Path path = new Path(regex);
+    int i = 0;
+    if (regex.indexOf(LIB_DIRECTORY_PATH) != -1) {
+      // remove all segments after "lib", they show path in the package
+      while (i < path.segmentCount() && !path.segment(i).equals("lib")) {
+        i++;
+      }
+    } else {
+      i = 1;
+    }
+    String filePath = new Path(regex).removeLastSegments(path.segmentCount() - (i + 1)).toString();
+
+    String packagePath = resolvePathToPackage(resource, filePath);
+    if (packagePath != null) {
+      packagePath += "/" + path.removeFirstSegments(i + 1);
+    }
+    return packagePath;
+  }
+
+  @VisibleForTesting
+  protected String resolvePathToPackage(IFile resource, String filePath) {
+    return DartCore.getProjectManager().resolvePathToPackage(resource, filePath);
+  }
+
   void addToBreakpointMap(IBreakpoint breakpoint, String id, boolean trackChanges) {
     synchronized (breakpointToIdMap) {
       if (breakpointToIdMap.get(breakpoint) == null) {
         breakpointToIdMap.put(breakpoint, new ArrayList<String>());
       }
 
       breakpointToIdMap.get(breakpoint).add(id);
 
       if (trackChanges) {
         breakpointsToUpdateMap.put(id, (DartBreakpoint) breakpoint);
       }
     }
   }
 
   void handleBreakpointResolved(WebkitBreakpoint webkitBreakpoint) {
     DartBreakpoint breakpoint = breakpointsToUpdateMap.get(webkitBreakpoint.getBreakpointId());
 
     if (breakpoint != null) {
-      int eclipseLine = WebkitLocation.webkitToElipseLine(webkitBreakpoint.getLocation().getLineNumber());
+      int eclipseLine = WebkitLocation.webkitToElipseLine(
+          webkitBreakpoint.getLocation().getLineNumber());
 
       if (breakpoint.getLine() != eclipseLine) {
         ignoredBreakpoints.add(breakpoint);
 
         String message = "[breakpoint in " + breakpoint.getFile().getName() + " moved from line "
             + breakpoint.getLine() + " to " + eclipseLine + "]";
         debugTarget.writeToStdout(message);
 
         breakpoint.updateLineNumber(eclipseLine);
       }
@@ skipping 23 matching lines @@
         // Check if source is located in the "lib" directory; if there is a link to it from the 
         // packages directory breakpoint should be /packages/...
         String packageName = DartCore.getSelfLinkedPackageName(breakpoint.getFile());
 
         if (packageName != null) {
           // Create a breakpoint for self-links.
           int libIndex = regex.lastIndexOf(LIB_DIRECTORY_PATH);
           String packageRegex = packageName + "/"
               + regex.substring(libIndex + LIB_DIRECTORY_PATH.length());
 
-          debugTarget.getWebkitConnection().getDebugger().setBreakpointByUrl(
-              null,
-              packageRegex,
-              line,
-              -1,
-              new WebkitCallback<String>() {
+          debugTarget.getWebkitConnection().getDebugger()
+              .setBreakpointByUrl(null, packageRegex, line, -1, new WebkitCallback<String>() {
                 @Override
                 public void handleResult(WebkitResult<String> result) {
                   if (!result.isError()) {
                     addToBreakpointMap(breakpoint, result.getResult(), false);
                   }
                 }
               });
         }
       }
 
-      debugTarget.getWebkitConnection().getDebugger().setBreakpointByUrl(
-          null,
-          regex,
-          line,
-          -1,
-          new WebkitCallback<String>() {
+      // check if it is a file in a package, if so replace regex with package uri path
+      // TODO(keertip): revisit when moved to calling pub for package info
+      String packagePath = getPackagePath(regex, breakpoint.getFile());
+      if (packagePath != null) {
+        regex = packagePath;
+      }
+
+      debugTarget.getWebkitConnection()
+          .getDebugger().setBreakpointByUrl(null, regex, line, -1, new WebkitCallback<String>() {
             @Override
             public void handleResult(WebkitResult<String> result) {
               if (!result.isError()) {
                 addToBreakpointMap(breakpoint, result.getResult(), true);
               }
             }
           });
 
       // Handle source mapped breakpoints - set an additional breakpoint if the file is under
       // source mapping.
       SourceMapManager sourceMapManager = debugTarget.getSourceMapManager();
 
       if (sourceMapManager.isMapTarget(breakpoint.getFile())) {
         List<SourceMapManager.SourceLocation> locations = sourceMapManager.getReverseMappingsFor(
             breakpoint.getFile(),
             line);
 
         for (SourceMapManager.SourceLocation location : locations) {
           String mappedRegex = getResourceResolver().getUrlRegexForResource(location.getFile());
 
           if (mappedRegex != null) {
             if (DartDebugCorePlugin.LOGGING) {
-              System.out.println("breakpoint [" + regex + "," + breakpoint.getLine()
-                  + ",-1] ==> mapped to [" + mappedRegex + "," + location.getLine() + ","
-                  + location.getColumn() + "]");
+              System.out.println(
+                  "breakpoint [" + regex + "," + breakpoint.getLine() + ",-1] ==> mapped to ["
+                      + mappedRegex + "," + location.getLine() + "," + location.getColumn() + "]");
             }
 
             debugTarget.getWebkitConnection().getDebugger().setBreakpointByUrl(
                 null,
                 mappedRegex,
                 location.getLine(),
                 location.getColumn(),
                 new WebkitCallback<String>() {
                   @Override
                   public void handleResult(WebkitResult<String> result) {
@@ skipping 32 matching lines @@
     }
 
     if (container.getParent() instanceof IWorkspaceRoot) {
       return false;
     }
 
     return isPubLib(container.getParent());
   }
 
 }