# HG changeset patch
# User paulb
# Date 1276038771 25200
# Node ID dd7d3426144c5598686b8e8cf6d86bdb6708c575
# Parent  1f666f57e7776fd4b34326ae2ac72134cf83d81a# Parent  8e561bc07a21b26593c3743fc1480703900de4ee
merged heads

diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/plugin.properties
--- a/org.chromium.debug.core/plugin.properties	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/plugin.properties	Tue Jun 08 16:12:51 2010 -0700
@@ -4,4 +4,7 @@
 
 providerName = The Chromium Authors
 
-pluginName = Chromium JavaScript Remote Debugger Core
\ No newline at end of file
+pluginName = Chromium JavaScript Remote Debugger Core
+
+SourceNameMapperContainer.name = JavaScript Source Name Mapper
+SourceNameMapperContainer.description = Transforms name of source and delegates lookup to another source container.
\ No newline at end of file
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/plugin.xml
--- a/org.chromium.debug.core/plugin.xml	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/plugin.xml	Tue Jun 08 16:12:51 2010 -0700
@@ -41,4 +41,40 @@
         <run class="org.chromium.debug.core.efs.ChromiumScriptFileSystem"/>
      </filesystem>
   </extension>
+
+  <extension point="org.eclipse.debug.core.sourceLocators">
+     <sourceLocator 
+        id="org.chromium.debug.core.ChromiumSourceDirector"
+        class="org.chromium.debug.core.ChromiumSourceDirector"
+        name="a ChromiumSourceDirector">
+     </sourceLocator>
+   </extension>
+
+  <extension point="org.eclipse.debug.core.sourcePathComputers">
+     <sourcePathComputer
+        id="org.chromium.debug.core.ChromiumSourceComputer"
+        class="org.chromium.debug.core.ChromiumSourceComputer">
+      </sourcePathComputer>
+  </extension>
+  
+  <extension point="org.eclipse.debug.core.sourceContainerTypes">
+    <sourceContainerType
+      name="JS Server Scripts"
+      class="org.chromium.debug.core.VProjectSourceContainer$TypeDelegate"
+      id="org.chromium.debug.core.VProjectSourceContainer.type"
+      description="Remote V8/Chrome VM JavaScript Scripts">
+    </sourceContainerType>
+   </extension>
+
+  
+  <extension point="org.eclipse.debug.core.sourceContainerTypes">
+    <sourceContainerType
+      name="%SourceNameMapperContainer.name"
+      class="org.chromium.debug.core.SourceNameMapperContainer$TypeDelegate"
+      id="org.chromium.debug.core.SourceNameMapperContainer.type"
+      description="%SourceNameMapperContainer.description">
+    </sourceContainerType>
+   </extension>
+  
+
 </plugin>
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/ChromiumDebugPlugin.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/ChromiumDebugPlugin.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/ChromiumDebugPlugin.java	Tue Jun 08 16:12:51 2010 -0700
@@ -6,6 +6,7 @@
 
 import java.text.MessageFormat;
 
+import org.chromium.debug.core.model.BreakpointMap;
 import org.chromium.debug.core.model.ChromiumBreakpointWBAFactory;
 import org.chromium.debug.core.model.ChromiumLineBreakpoint;
 import org.eclipse.core.runtime.CoreException;
@@ -30,6 +31,8 @@
   /** The shared instance. */
   private static ChromiumDebugPlugin plugin;
 
+  private final BreakpointMap breakpointMap = new BreakpointMap();
+
   private ChromiumBreakpointWBAFactory breakpointWorkbenchAdapterFactory;
 
   public ChromiumDebugPlugin() {
@@ -52,6 +55,10 @@
     super.stop(context);
   }
 
+  public BreakpointMap getBreakpointMap() {
+    return breakpointMap;
+  }
+
   /**
    * @return the shared instance
    */
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/ChromiumSourceComputer.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/ChromiumSourceComputer.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,22 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.core;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
+import org.eclipse.debug.core.sourcelookup.ISourcePathComputerDelegate;
+
+/**
+ * A source path computer implementation that provides {@link VProjectSourceContainer} as
+ * a default source files container for V8/Chrome debug sessions.
+ */
+public class ChromiumSourceComputer implements ISourcePathComputerDelegate {
+  public ISourceContainer[] computeSourceContainers(ILaunchConfiguration configuration,
+      IProgressMonitor monitor) throws CoreException {
+    return new ISourceContainer[] { new VProjectSourceContainer() };
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/ChromiumSourceDirector.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/ChromiumSourceDirector.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,68 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.core;
+
+import org.chromium.debug.core.model.ResourceManager;
+import org.chromium.debug.core.model.StackFrame;
+import org.chromium.debug.core.model.VmResourceId;
+import org.chromium.sdk.Breakpoint;
+import org.chromium.sdk.Script;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.debug.core.sourcelookup.AbstractSourceLookupDirector;
+import org.eclipse.debug.core.sourcelookup.AbstractSourceLookupParticipant;
+import org.eclipse.debug.core.sourcelookup.ISourceLookupParticipant;
+
+/**
+ * A source lookup director implementation that provides a simple participant and
+ * accepts instance of virtual project once it is created.
+ */
+public class ChromiumSourceDirector extends AbstractSourceLookupDirector {
+  private volatile ResourceManager resourceManager = null;
+  private volatile IProject project = null;
+  private volatile ReverseSourceLookup reverseSourceLookup = null;
+
+
+  public void initializeParticipants() {
+    ISourceLookupParticipant participant = new AbstractSourceLookupParticipant() {
+      public String getSourceName(Object object) throws CoreException {
+        Script script = null;
+        if (object instanceof Script) {
+          script = (Script) object;
+        } else if (object instanceof StackFrame) {
+          StackFrame jsStackFrame = (StackFrame) object;
+          script = jsStackFrame.getCallFrame().getScript();
+        } else if (object instanceof Breakpoint) {
+          Breakpoint breakpoint = (Breakpoint) object;
+          return breakpoint.getScriptName();
+        }
+        if (script == null) {
+          return null;
+        }
+
+        return VmResourceId.forScript(script).getEclipseSourceName();
+      }
+    };
+    addParticipants(new ISourceLookupParticipant[] { participant } );
+  }
+
+  public void initializeVProjectContainers(IProject project, ResourceManager resourceManager) {
+    this.resourceManager = resourceManager;
+    this.project = project;
+    this.reverseSourceLookup = new ReverseSourceLookup(this);
+  }
+
+  public ReverseSourceLookup getReverseSourceLookup() {
+    return reverseSourceLookup;
+  }
+
+  public ResourceManager getResourceManager() {
+    return resourceManager;
+  }
+
+  IProject getProject() {
+    return project;
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/Messages.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/Messages.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/Messages.java	Tue Jun 08 16:12:51 2010 -0700
@@ -15,6 +15,10 @@
 
   public static String ChromiumDebugPlugin_InternalError;
 
+  public static String SourceNameMapperContainer_NAME;
+
+  public static String VProjectSourceContainer_DEFAULT_TYPE_NAME;
+
   static {
     // initialize resource bundle
     NLS.initializeMessages(BUNDLE_NAME, Messages.class);
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/ReverseSourceLookup.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/ReverseSourceLookup.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,100 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.core;
+
+import org.chromium.debug.core.model.VmResourceId;
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
+import org.eclipse.debug.core.sourcelookup.ISourceLookupDirector;
+import org.eclipse.debug.core.sourcelookup.containers.ContainerSourceContainer;
+import org.eclipse.debug.core.sourcelookup.containers.DefaultSourceContainer;
+
+/**
+ * Eclipse has a standard facility for looking up source file for a debug artifact.
+ * LiveEdit feature has an opposite problem: find script in remote VM for a particular js file.
+ * This class implements some approach to this problem. An instance of this class corresponds
+ * to a particular debug launch.
+ */
+public class ReverseSourceLookup {
+  private final ISourceLookupDirector sourceDirector;
+
+  public ReverseSourceLookup(ISourceLookupDirector sourceDirector) {
+    this.sourceDirector = sourceDirector;
+  }
+
+  /**
+   * Tries to find a corresponding script for a file from a user workspace. The method uses
+   * the file name and current source lookup rules to retrieve a resource id, regardless of
+   * whether the resource has actually been loaded into the VM (you may want to set a breakpoint
+   * on resource before it is actually loaded).
+   */
+  public VmResourceId findVmResource(IFile sourceFile) throws CoreException {
+    for (ISourceContainer container : sourceDirector.getSourceContainers()) {
+      VmResourceId scriptName = tryForContainer(sourceFile, container);
+      if (scriptName != null) {
+        return scriptName;
+      }
+    }
+    return null;
+  }
+
+  private VmResourceId tryForContainer(IFile sourceFile, ISourceContainer container)
+      throws CoreException {
+    if (container.isComposite() && isSupportedCompositeContainer(container)) {
+      ISourceContainer[] subContainers = container.getSourceContainers();
+      for (ISourceContainer subContainer : subContainers) {
+        VmResourceId res = tryForContainer(sourceFile, subContainer);
+        if (res != null) {
+          return res;
+        }
+      }
+      return null;
+    } else if (container instanceof VProjectSourceContainer) {
+      VProjectSourceContainer projectSourceContainer = (VProjectSourceContainer) container;
+      return projectSourceContainer.findScriptId(sourceFile);
+    } else {
+      String name = tryForNonVirtualContainer(sourceFile, container);
+      if (name == null) {
+        return null;
+      }
+      return VmResourceId.forName(name);
+    }
+  }
+
+  /**
+   * We use {@link ISourceContainer#getSourceContainers()} method to unwrap internal containers.
+   * However it doesn't make sense for all composite containers (some of them may return their
+   * subdirectories as containers, which is not what we need).
+   */
+  private boolean isSupportedCompositeContainer(ISourceContainer container) {
+    return container instanceof DefaultSourceContainer;
+  }
+
+  /**
+   * @param container that may not wrap VProjectSourceContainer
+   */
+  private String tryForNonVirtualContainer(IFile resource, ISourceContainer container) {
+    if (container instanceof ContainerSourceContainer) {
+      ContainerSourceContainer containerSourceContainer = (ContainerSourceContainer) container;
+      IContainer resourceContainer = containerSourceContainer.getContainer();
+      if (resourceContainer.getFullPath().isPrefixOf(resource.getFullPath())) {
+        String name = resource.getFullPath().makeRelativeTo(
+            resourceContainer.getFullPath()).toPortableString();
+        return name;
+      }
+    } else if (container instanceof SourceNameMapperContainer) {
+      SourceNameMapperContainer mappingContainer =
+          (SourceNameMapperContainer) container;
+      String subResult = tryForNonVirtualContainer(resource, mappingContainer.getTargetContainer());
+      if (subResult != null) {
+        return mappingContainer.getPrefix() + subResult;
+      }
+    }
+
+    return null;
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/SourceNameMapperContainer.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/SourceNameMapperContainer.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,188 @@
+package org.chromium.debug.core;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
+import org.eclipse.debug.core.sourcelookup.ISourceContainerType;
+import org.eclipse.debug.core.sourcelookup.ISourceContainerTypeDelegate;
+import org.eclipse.debug.core.sourcelookup.ISourceLookupDirector;
+import org.eclipse.osgi.util.NLS;
+
+/**
+ * A special type of container that translates names of the source and delegates lookup
+ * to another source container.
+ * This could be useful when JS resource name is like "http://localhost/scripts/util.js"; such
+ * source name could be converted into "scripts/util.js".
+ * Currently container supports only prefix-based translation: if source name starts with a prefix,
+ * the prefix is truncated; otherwise the source name is discarded.
+ */
+public class SourceNameMapperContainer implements ISourceContainer {
+
+  private static final String TYPE_ID =
+      "org.chromium.debug.core.SourceNameMapperContainer.type"; //$NON-NLS-1$
+
+  private final ISourceContainer targetContainer;
+  private final String prefix;
+
+  public SourceNameMapperContainer(String prefix, ISourceContainer targetContainer) {
+    this.targetContainer = targetContainer;
+    this.prefix = prefix;
+  }
+
+  public void dispose() {
+  }
+
+  public String getPrefix() {
+    return prefix;
+  }
+
+  public ISourceContainer getTargetContainer() {
+    return targetContainer;
+  }
+
+  public Object[] findSourceElements(String name) throws CoreException {
+    if (!name.startsWith(prefix)) {
+      return new Object[0];
+    }
+    String shortName = name.substring(prefix.length());
+    return targetContainer.findSourceElements(shortName);
+  }
+
+
+  public String getName() {
+    return NLS.bind(Messages.SourceNameMapperContainer_NAME, prefix);
+  }
+
+
+  public ISourceContainer[] getSourceContainers() {
+    return new ISourceContainer[] { targetContainer };
+  }
+
+
+  public ISourceContainerType getType() {
+    return DebugPlugin.getDefault().getLaunchManager().getSourceContainerType(TYPE_ID);
+  }
+
+
+  public void init(ISourceLookupDirector director) {
+  }
+
+
+  public boolean isComposite() {
+    return true;
+  }
+
+  private String getMemento() throws CoreException {
+    StringBuilder builder = new StringBuilder();
+    MementoFormat.encodeComponent(prefix, builder);
+    MementoFormat.encodeComponent(targetContainer.getType().getId(), builder);
+    MementoFormat.encodeComponent(targetContainer.getType().getMemento(targetContainer), builder);
+    return builder.toString();
+  }
+
+
+  public Object getAdapter(Class adapter) {
+    return null;
+  }
+
+  /**
+   * A type delegate that serializes/deserializes container instances into/from memento.
+   */
+  public static class TypeDelegate implements ISourceContainerTypeDelegate {
+    public ISourceContainer createSourceContainer(String memento) throws CoreException {
+      MementoFormat.Parser parser = new MementoFormat.Parser(memento);
+      String prefix;
+      String typeId;
+      String subContainerMemento;
+      try {
+        prefix = parser.nextComponent();
+        typeId = parser.nextComponent();
+        subContainerMemento = parser.nextComponent();
+      } catch (MementoFormat.ParserException e) {
+        throw new CoreException(new Status(IStatus.ERROR,
+            ChromiumDebugPlugin.PLUGIN_ID, "Failed to parse memento", e)); //$NON-NLS-1$
+      }
+      ISourceContainerType subContainerType =
+          DebugPlugin.getDefault().getLaunchManager().getSourceContainerType(typeId);
+      ISourceContainer subContainer = subContainerType.createSourceContainer(subContainerMemento);
+      return new SourceNameMapperContainer(prefix, subContainer);
+    }
+
+    public String getMemento(ISourceContainer container) throws CoreException {
+      SourceNameMapperContainer chromeContainer = (SourceNameMapperContainer) container;
+      return chromeContainer.getMemento();
+    }
+  }
+
+  /**
+   * Handles memento string format. The format is just a sequence of strings that are preceded
+   * with their lengths and decorated with parentheses to make it more human-readable.
+   */
+  private static class MementoFormat {
+
+    static void encodeComponent(String component, StringBuilder output) {
+      output.append(component.length());
+      output.append('(').append(component).append(')');
+    }
+
+    /**
+     * A simple parser that reads char sequence as a sequence of strings.
+     */
+    static class Parser {
+      private final CharSequence charSequence;
+      private int pos = 0;
+      Parser(CharSequence charSequence) {
+        this.charSequence = charSequence;
+      }
+      String nextComponent() throws ParserException {
+        if (pos >= charSequence.length()) {
+          throw new ParserException("Unexpected end of line"); //$NON-NLS-1$
+        }
+        char ch = charSequence.charAt(pos);
+        pos++;
+        int num = Character.digit(ch, 10);
+        if (num == -1) {
+          throw new ParserException("Digit expected"); //$NON-NLS-1$
+        }
+        int len = num;
+        while (true) {
+          if (pos >= charSequence.length()) {
+            throw new ParserException("Unexpected end of line"); //$NON-NLS-1$
+          }
+          ch = charSequence.charAt(pos);
+          if (!Character.isDigit(ch)) {
+            break;
+          }
+          pos++;
+          num = Character.digit(ch, 10);
+          if (num == -1) {
+            throw new ParserException("Digit expected"); //$NON-NLS-1$
+          }
+          len = len * 10 + num;
+        }
+        pos++;
+        if (pos + len + 1 > charSequence.length()) {
+          throw new ParserException("Unexpected end of line"); //$NON-NLS-1$
+        }
+        String result = charSequence.subSequence(pos, pos + len).toString();
+        pos += len + 1;
+        return result;
+      }
+    }
+    private static class ParserException extends Exception {
+      ParserException() {
+      }
+      ParserException(String message, Throwable cause) {
+        super(message, cause);
+      }
+      ParserException(String message) {
+        super(message);
+      }
+      ParserException(Throwable cause) {
+        super(cause);
+      }
+    }
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/VProjectSourceContainer.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/VProjectSourceContainer.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,107 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.core;
+
+import org.chromium.debug.core.model.ResourceManager;
+import org.chromium.debug.core.model.VmResourceId;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
+import org.eclipse.debug.core.sourcelookup.ISourceContainerType;
+import org.eclipse.debug.core.sourcelookup.ISourceContainerTypeDelegate;
+import org.eclipse.debug.core.sourcelookup.ISourceLookupDirector;
+
+/**
+ * A source container implementation that wraps V8 virtual project. Currently virtual project
+ * has a flat file structure, so the container is accordingly one-level.
+ * <p>
+ * Unlike other implementation of {@link ISourceContainer} this class initially gets instantiated
+ * with no data. In this state it serves as an empty container because actual VM scripts are
+ * not available yet. Launch configuration UI will use it in this state more as a symbolic
+ * place-holder in sources tab. Later when VM is connected, method
+ * {@link #init(ISourceLookupDirector)} will be called and the actual content will be set.
+ */
+public class VProjectSourceContainer implements ISourceContainer {
+
+  private static final String TYPE_ID =
+      "org.chromium.debug.core.VProjectSourceContainer.type"; //$NON-NLS-1$
+
+  private ChromiumSourceDirector chromiumSourceDirector = null;
+
+  VProjectSourceContainer() {
+  }
+
+  public void init(ISourceLookupDirector director) {
+    if (director instanceof ChromiumSourceDirector) {
+      chromiumSourceDirector = (ChromiumSourceDirector) director;
+    }
+  }
+
+  public void dispose() {
+  }
+
+  public Object[] findSourceElements(String name) {
+    if (chromiumSourceDirector == null) {
+      return new Object[0];
+    }
+    ResourceManager resourceManager = chromiumSourceDirector.getResourceManager();
+    IFile file = resourceManager.getFile(name);
+    if (file == null) {
+      return new Object[0];
+    }
+    return new Object[] { file };
+  }
+
+  public String getName() {
+    IProject project = null;
+    if (chromiumSourceDirector != null) {
+      project = chromiumSourceDirector.getProject();
+    }
+    if (project == null) {
+      return Messages.VProjectSourceContainer_DEFAULT_TYPE_NAME;
+    } else {
+      return project.getName();
+    }
+  }
+
+  public ISourceContainer[] getSourceContainers() {
+    return null;
+  }
+
+  public ISourceContainerType getType() {
+    return DebugPlugin.getDefault().getLaunchManager().getSourceContainerType(TYPE_ID);
+  }
+
+  public boolean isComposite() {
+    return false;
+  }
+
+  public VmResourceId findScriptId(IFile resource) {
+    if (chromiumSourceDirector == null) {
+      throw new IllegalStateException();
+    }
+    return chromiumSourceDirector.getResourceManager().getResourceId(resource);
+  }
+
+  public Object getAdapter(Class adapter) {
+    return null;
+  }
+
+  /**
+   * A type delegate that implements a trivial memento. We do not save any actual data here,
+   * because it all should be derived from a current VM launch.
+   */
+  public static class TypeDelegate implements ISourceContainerTypeDelegate {
+    public ISourceContainer createSourceContainer(String memento) throws CoreException {
+      return new VProjectSourceContainer();
+    }
+
+    public String getMemento(ISourceContainer container) throws CoreException {
+      return "VProjectSourceContainer.memento.stub"; //$NON-NLS-1$
+    }
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/messages.properties
--- a/org.chromium.debug.core/src/org/chromium/debug/core/messages.properties	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/messages.properties	Tue Jun 08 16:12:51 2010 -0700
@@ -3,3 +3,5 @@
 # found in the LICENSE file.
 
 ChromiumDebugPlugin_InternalError=Internal Error
+SourceNameMapperContainer_NAME=Source mapper with prefix {0}
+VProjectSourceContainer_DEFAULT_TYPE_NAME=Remote V8/Chrome Scripts
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/BreakpointAdapterFactory.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/BreakpointAdapterFactory.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/BreakpointAdapterFactory.java	Tue Jun 08 16:12:51 2010 -0700
@@ -23,7 +23,7 @@
           (IResource) editorPart.getEditorInput().getAdapter(IResource.class);
       if (resource != null) {
         String extension = resource.getFileExtension();
-        if (extension != null && ChromiumDebugPluginUtil.CHROMIUM_EXTENSION.equals(extension)) {
+        if (extension != null && ChromiumDebugPluginUtil.SUPPORTED_EXTENSIONS.contains(extension)) {
           return new LineBreakpointAdapter.ForVirtualProject();
         }
       }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/BreakpointMap.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/BreakpointMap.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,59 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.core.model;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.chromium.sdk.Breakpoint;
+
+/**
+ * TODO(peter.rybin): this class is obsolete, it only holds useful inner class;
+ * consider removing this class.
+ */
+public class BreakpointMap {
+
+  /**
+   * A one-to-one map between SDK and UI breakpoints inside one debug target.
+   */
+  public static class InTargetMap {
+    private final Map<Breakpoint, ChromiumLineBreakpoint> sdkToUiMap =
+        new HashMap<Breakpoint, ChromiumLineBreakpoint>();
+    private final Map<ChromiumLineBreakpoint, Breakpoint> uiToSdkMap =
+      new HashMap<ChromiumLineBreakpoint, Breakpoint>();
+
+    public InTargetMap() {
+    }
+
+    public synchronized Breakpoint getSdkBreakpoint(ChromiumLineBreakpoint chromiumLineBreakpoint) {
+      return uiToSdkMap.get(chromiumLineBreakpoint);
+    }
+
+    public synchronized ChromiumLineBreakpoint getUiBreakpoint(Breakpoint sdkBreakpoint) {
+      return sdkToUiMap.get(sdkBreakpoint);
+    }
+
+    public synchronized void add(Breakpoint sdkBreakpoint, ChromiumLineBreakpoint uiBreakpoint) {
+      Object conflict1 = uiToSdkMap.put(uiBreakpoint, sdkBreakpoint);
+      Object conflict2 = sdkToUiMap.put(sdkBreakpoint, uiBreakpoint);
+      if (conflict1 != null || conflict2 != null) {
+        throw new RuntimeException();
+      }
+    }
+
+    public synchronized void remove(ChromiumLineBreakpoint lineBreakpoint) {
+      Breakpoint sdkBreakpoint = uiToSdkMap.remove(lineBreakpoint);
+      if (sdkBreakpoint == null) {
+        throw new RuntimeException();
+      }
+      sdkToUiMap.remove(sdkBreakpoint);
+    }
+
+    public synchronized void clear() {
+      sdkToUiMap.clear();
+      uiToSdkMap.clear();
+    }
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/BreakpointRegistry.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/BreakpointRegistry.java	Tue Jun 08 16:06:40 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,227 +0,0 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package org.chromium.debug.core.model;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.Map;
-
-import org.chromium.sdk.Breakpoint;
-import org.chromium.sdk.Script;
-
-/**
- * A registry of existing breakpoints associated with their script locations. It
- * is used to restore
- */
-public class BreakpointRegistry {
-
-  /**
-   * Script identifier for a breakpoint location.
-   */
-  public static class ScriptIdentifier {
-    private final String name;
-
-    private final long id;
-
-    private final int startLine;
-
-    private final int endLine;
-
-    public static ScriptIdentifier forScript(Script script) {
-      String name = script.getName();
-      return new ScriptIdentifier(
-          name,
-          name != null ? -1 : script.getId(),
-          script.getStartLine(),
-          script.getEndLine());
-    }
-
-    private ScriptIdentifier(String name, long id, int startLine, int endLine) {
-      this.name = name;
-      this.id = id;
-      this.startLine = startLine;
-      this.endLine = endLine;
-    }
-
-    @Override
-    public int hashCode() {
-      final int prime = 31;
-      int result = 1;
-      result = prime * result + (int) (id ^ (id >>> 32));
-      result = prime * result + ((name == null) ? 0 : name.hashCode());
-      result = prime * result + 17 * startLine + 19 * endLine;
-      return result;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-      if (!(obj instanceof ScriptIdentifier)) {
-        return false;
-      }
-      ScriptIdentifier that = (ScriptIdentifier) obj;
-      if (this.startLine != that.startLine || this.endLine != that.endLine) {
-        return false;
-      }
-      if (name == null) {
-        // an unnamed script, only id is known
-        return that.name == null && this.id == that.id;
-      }
-      // a named script
-      return this.name.equals(that.name);
-    }
-  }
-
-  static class BreakpointLocation {
-    private final ScriptIdentifier scriptIdentifier;
-
-    private final int line;
-
-    public BreakpointLocation(ScriptIdentifier scriptIdentifier, int line) {
-      this.scriptIdentifier = scriptIdentifier;
-      this.line = line;
-    }
-
-    public ScriptIdentifier getScriptIdentifier() {
-      return scriptIdentifier;
-    }
-
-    public int getLine() {
-      return line;
-    }
-
-    @Override
-    public int hashCode() {
-      final int prime = 31;
-      int result = 1;
-      result = prime * result + line;
-      result = prime * result + ((scriptIdentifier == null)
-          ? 0
-          : scriptIdentifier.hashCode());
-      return result;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-      if (!(obj instanceof BreakpointLocation)) {
-        return false;
-      }
-      BreakpointLocation that = (BreakpointLocation) obj;
-      return (this.line == that.line && eq(this.scriptIdentifier, that.scriptIdentifier));
-    }
-  }
-
-  /**
-   * A breakpoint accompanied by its line number in the corresponding enclosing
-   * resource.
-   */
-  public static class BreakpointEntry {
-    public final Breakpoint breakpoint;
-
-    public final int line;
-
-    private BreakpointEntry(Breakpoint breakpoint, int line) {
-      this.breakpoint = breakpoint;
-      this.line = line;
-    }
-
-    boolean isWithinScriptRange(Script script) {
-      return line >= script.getStartLine() && line <= script.getEndLine();
-    }
-
-    @Override
-    public int hashCode() {
-      return 31 * line + 17 * breakpoint.hashCode();
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-      if (!(obj instanceof BreakpointEntry)) {
-        return false;
-      }
-      BreakpointEntry that = (BreakpointEntry) obj;
-      return this.line == that.line && this.breakpoint.equals(that.breakpoint);
-    }
-  }
-
-  private final Map<ScriptIdentifier, Collection<BreakpointEntry>> scriptIdToBreakpointEntries =
-      new HashMap<ScriptIdentifier, Collection<BreakpointEntry>>();
-
-  /**
-   * Adds the given line breakpoint.
-   *
-   * @param script where the breakpoint is set
-   * @param line (0-based, like in V8) in the script
-   * @param breakpoint
-   */
-  public void add(Script script, int line, Breakpoint breakpoint) {
-    ScriptIdentifier scriptId = ScriptIdentifier.forScript(script);
-    Collection<BreakpointEntry> entries = scriptIdToBreakpointEntries.get(scriptId);
-    if (entries == null) {
-      entries = new HashSet<BreakpointEntry>();
-      scriptIdToBreakpointEntries.put(scriptId, entries);
-    }
-    entries.add(new BreakpointEntry(breakpoint, line));
-  }
-
-  /**
-   * Gets breakpoint entries for the given script. An empty collection for a
-   * {@code null} script.
-   *
-   * @param script to extract the breakpoints for
-   * @return the breakpoints that fall within the given script line range
-   */
-  public Collection<? extends BreakpointEntry> getBreakpointEntries(Script script) {
-    if (script == null) {
-      return Collections.emptySet();
-    }
-    Collection<BreakpointEntry> entries =
-        scriptIdToBreakpointEntries.get(ScriptIdentifier.forScript(script));
-    if (entries == null) {
-      return Collections.emptySet();
-    }
-    Collection<BreakpointEntry> scriptBreakpoints = new LinkedList<BreakpointEntry>();
-    // Linear search should work fairly well for a reasonable number of
-    // breakpoints per script
-    for (BreakpointEntry entry : entries) {
-      if (entry.isWithinScriptRange(script)) {
-        scriptBreakpoints.add(entry);
-      }
-    }
-    return scriptBreakpoints;
-  }
-
-  /**
-   * Removes the given line breakpoint in the given script. Does nothing for a
-   * {@code null} script (which may be the case after a navigation + disconnect
-   * when the resource referenced by the breakpoint marker is absent.)
-   *
-   * @param script where the breakpoint is set
-   * @param line (0-based, like in V8) in the script
-   * @param breakpoint
-   */
-  public void remove(Script script, int line, Breakpoint breakpoint) {
-    if (script == null) {
-      return;
-    }
-    ScriptIdentifier scriptId = ScriptIdentifier.forScript(script);
-    Collection<BreakpointEntry> entries = scriptIdToBreakpointEntries.get(scriptId);
-    if (entries == null) {
-      return;
-    }
-    if (entries.size() == 1) {
-      scriptIdToBreakpointEntries.remove(scriptId);
-    } else {
-      entries.remove(new BreakpointEntry(breakpoint, line));
-    }
-  }
-
-  protected static boolean eq(Object left, Object right) {
-    return left == right || (left != null && left.equals(right));
-  }
-
-}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/BreakpointSynchronizer.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/BreakpointSynchronizer.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,631 @@
+package org.chromium.debug.core.model;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.chromium.debug.core.ChromiumDebugPlugin;
+import org.chromium.debug.core.ChromiumSourceDirector;
+import org.chromium.sdk.Breakpoint;
+import org.chromium.sdk.CallbackSemaphore;
+import org.chromium.sdk.JavascriptVm;
+import org.chromium.sdk.SyncCallback;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.MultiStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.IBreakpointManager;
+import org.eclipse.debug.core.model.IBreakpoint;
+
+/**
+ * A class responsible for comparing breakpoints in workspace and on remote VM and synchronizing
+ * them in both directions. {@link Direction#RESET_REMOTE} allows several synchronization
+ * jobs to different VMs.
+ */
+public class BreakpointSynchronizer {
+  private final JavascriptVm javascriptVm;
+  private final BreakpointMap.InTargetMap breakpointInTargetMap;
+  private final ChromiumSourceDirector sourceDirector;
+  private final BreakpointHelper breakpointHelper;
+  private final String debugModelId;
+
+  public BreakpointSynchronizer(JavascriptVm javascriptVm,
+      BreakpointMap.InTargetMap breakpointInTargetMap,
+      ChromiumSourceDirector sourceDirector, BreakpointHelper breakpointHelper,
+      String debugModelId) {
+    this.javascriptVm = javascriptVm;
+    this.breakpointInTargetMap = breakpointInTargetMap;
+    this.sourceDirector = sourceDirector;
+    this.breakpointHelper = breakpointHelper;
+    this.debugModelId = debugModelId;
+  }
+
+  /**
+   * Describes a direction the breakpoint synchronization should be performed in.
+   */
+  public enum Direction {
+
+    /**
+     * All breakpoints in remote VM/VMs are cleared/updated/created to conform to breakpoints in
+     * Eclipse workspace.
+     */
+    RESET_REMOTE,
+
+    /**
+     * All breakpoints in local workspace are cleared/updated/created to conform to breakpoints in
+     * remote VM (not applicable for multiple VMs).
+     */
+    RESET_LOCAL,
+
+    /**
+     * Breakpoints are created locally or remotely or tied together so that every breakpoint
+     * has a counterpart on other side.
+     */
+    MERGE
+  }
+
+  /**
+   * Additional interface used by {@link BreakpointSynchronizer}.
+   */
+  public interface BreakpointHelper {
+    /**
+     * Create breakpoint on remote VM (asynchronously) and link it to uiBreakpoint.
+     */
+    void createBreakpointOnRemote(ChromiumLineBreakpoint uiBreakpoint,
+        VmResourceId vmResourceId,
+        CreateCallback createCallback, SyncCallback syncCallback);
+
+    interface CreateCallback {
+      void failure(Exception ex);
+      void success();
+    }
+  }
+
+  public interface Callback {
+    void onDone(IStatus status);
+  }
+
+  /**
+   * The main entry method of the class. Asynchronously performs synchronization job.
+   * TODO(peter.rybin): consider some end-of-job notification for this method and possibly locks
+   */
+  public void syncBreakpoints(Direction direction, Callback callback) {
+    ReportBuilder reportBuilder = new ReportBuilder(direction);
+    StatusBuilder statusBuilder = new StatusBuilder(callback, reportBuilder);
+
+    statusBuilder.plan();
+    Exception ex = null;
+    try {
+      syncBreakpointsImpl(direction, statusBuilder);
+    } catch (RuntimeException e) {
+      ex = e;
+    } finally {
+      statusBuilder.done(ex);
+    }
+  }
+
+  private void syncBreakpointsImpl(final Direction direction, final StatusBuilder statusBuilder) {
+    // Collect the remote breakpoints.
+    Collection<? extends Breakpoint> sdkBreakpoints = readSdkBreakpoints(javascriptVm);
+    // Collect all local breakpoints.
+    Set<ChromiumLineBreakpoint> uiBreakpoints = getUiBreakpoints();
+
+    List<Breakpoint> sdkBreakpoints2 = new ArrayList<Breakpoint>(sdkBreakpoints.size());
+
+    if (direction != Direction.MERGE) {
+      breakpointInTargetMap.clear();
+    }
+
+    // Throw away all already linked breakpoints and put remaining into sdkBreakpoints2 list.
+    for (Breakpoint sdkBreakpoint : sdkBreakpoints) {
+      ChromiumLineBreakpoint uiBreakpoint = breakpointInTargetMap.getUiBreakpoint(sdkBreakpoint);
+      if (uiBreakpoint == null) {
+        // No mapping. Schedule for further processing.
+        sdkBreakpoints2.add(sdkBreakpoint);
+      } else {
+        // There is a live mapping. This set should also contain this breakpoint.
+        uiBreakpoints.remove(uiBreakpoint);
+        statusBuilder.getReportBuilder().increment(ReportBuilder.Property.LINKED);
+      }
+    }
+
+    // Sort all breakpoints by (script_name, line_number).
+    SortedBreakpoints<ChromiumLineBreakpoint> sortedUiBreakpoints =
+        sortBreakpoints(uiBreakpoints, uiBreakpointHandler);
+    SortedBreakpoints<Breakpoint> sortedSdkBreakpoints =
+        sortBreakpoints(sdkBreakpoints2, sdkBreakpointHandler);
+
+    BreakpointMerger breakpointMerger = new BreakpointMerger(direction, breakpointInTargetMap);
+
+    // Find all unlinked breakpoints on both sides.
+    mergeBreakpoints(breakpointMerger, sortedUiBreakpoints, sortedSdkBreakpoints);
+
+    List<Breakpoint> sdkBreakpointsToDelete;
+    List<Breakpoint> sdkBreakpointsToCreate;
+    List<ChromiumLineBreakpoint> uiBreakpointsToDelete;
+    List<ChromiumLineBreakpoint> uiBreakpointsToCreate;
+
+    // Plan actions for all breakpoints without pair.
+    if (direction == Direction.RESET_REMOTE) {
+      sdkBreakpointsToDelete = breakpointMerger.getMissingSdk();
+      sdkBreakpointsToCreate = Collections.emptyList();
+    } else {
+      sdkBreakpointsToCreate = breakpointMerger.getMissingSdk();
+      sdkBreakpointsToDelete = Collections.emptyList();
+    }
+
+    if (direction == Direction.RESET_LOCAL) {
+      uiBreakpointsToDelete = breakpointMerger.getMissingUi();
+      uiBreakpointsToCreate = Collections.emptyList();
+    } else {
+      uiBreakpointsToCreate = breakpointMerger.getMissingUi();
+      uiBreakpointsToDelete = Collections.emptyList();
+    }
+
+    // First delete everything, then create (we may need to re-create some breakpoints, so order
+    // is significant).
+    deteleBreakpoints(sdkBreakpointsToDelete, uiBreakpointsToDelete, statusBuilder);
+    createBreakpoints(sdkBreakpointsToCreate, uiBreakpointsToCreate, statusBuilder);
+  }
+
+  private void deteleBreakpoints(List<Breakpoint> sdkBreakpointsToDelete,
+      List<ChromiumLineBreakpoint> uiBreakpointsToDelete, final StatusBuilder statusBuilder) {
+    for (Breakpoint sdkBreakpoint : sdkBreakpointsToDelete) {
+      final PlannedTaskHelper deleteTaskHelper = new PlannedTaskHelper(statusBuilder);
+      JavascriptVm.BreakpointCallback callback = new JavascriptVm.BreakpointCallback() {
+        public void failure(String errorMessage) {
+          deleteTaskHelper.setException(new Exception(errorMessage));
+        }
+        public void success(Breakpoint breakpoint) {
+          statusBuilder.getReportBuilder().increment(ReportBuilder.Property.DELETED_ON_REMOTE);
+        }
+      };
+      sdkBreakpoint.clear(callback, deleteTaskHelper);
+    }
+    for (ChromiumLineBreakpoint uiBreakpoint : uiBreakpointsToDelete) {
+      ChromiumLineBreakpoint.getIgnoreList().add(uiBreakpoint);
+      try {
+        try {
+          uiBreakpoint.delete();
+        } catch (CoreException e) {
+          throw new RuntimeException(e);
+        }
+      } finally {
+        ChromiumLineBreakpoint.getIgnoreList().remove(uiBreakpoint);
+      }
+      statusBuilder.getReportBuilder().increment(ReportBuilder.Property.DELETED_LOCALLY);
+    }
+  }
+
+  private void createBreakpoints(List<Breakpoint> sdkBreakpointsToCreate,
+      List<ChromiumLineBreakpoint> uiBreakpointsToCreate, final StatusBuilder statusBuilder) {
+    IBreakpointManager breakpointManager = DebugPlugin.getDefault().getBreakpointManager();
+    for (Breakpoint sdkBreakpoint : sdkBreakpointsToCreate) {
+      Object sourceElement = sourceDirector.getSourceElement(sdkBreakpoint);
+      if (sourceElement instanceof IFile == false) {
+        continue;
+      }
+      // We do not actually support working files for scripts with offset.
+      int script_line_offset = 0;
+      IFile resource = (IFile) sourceElement;
+      ChromiumLineBreakpoint uiBreakpoint;
+      try {
+        uiBreakpoint = ChromiumLineBreakpoint.Helper.createLocal(sdkBreakpoint, breakpointManager,
+            resource, script_line_offset, debugModelId);
+        breakpointInTargetMap.add(sdkBreakpoint, uiBreakpoint);
+      } catch (CoreException e) {
+        throw new RuntimeException(e);
+      }
+      statusBuilder.getReportBuilder().increment(ReportBuilder.Property.CREATED_LOCALLY);
+    }
+    for (ChromiumLineBreakpoint uiBreakpoint : uiBreakpointsToCreate) {
+      VmResourceId vmResourceId = uiBreakpointHandler.getVmResourceId(uiBreakpoint);
+      if (vmResourceId == null) {
+        // Actually we should not get here, because getScript call succeeded before.
+        continue;
+      }
+
+      final PlannedTaskHelper createTaskHelper = new PlannedTaskHelper(statusBuilder);
+      BreakpointHelper.CreateCallback createCallback = new BreakpointHelper.CreateCallback() {
+        public void success() {
+          statusBuilder.getReportBuilder().increment(ReportBuilder.Property.CREATED_ON_REMOTE);
+        }
+        public void failure(Exception ex) {
+          createTaskHelper.setException(ex);
+        }
+      };
+      breakpointHelper.createBreakpointOnRemote(uiBreakpoint, vmResourceId, createCallback,
+          createTaskHelper);
+    }
+  }
+
+  private static class BreakpointMerger extends Merger<ChromiumLineBreakpoint, Breakpoint> {
+    private final Direction direction;
+    private final List<ChromiumLineBreakpoint> missingUi = new ArrayList<ChromiumLineBreakpoint>();
+    private final List<Breakpoint> missingSdk = new ArrayList<Breakpoint>();
+    private final BreakpointMap.InTargetMap breakpointMap;
+
+    BreakpointMerger(Direction direction, BreakpointMap.InTargetMap breakpointMap) {
+      this.direction = direction;
+      this.breakpointMap = breakpointMap;
+    }
+    @Override
+    void both(ChromiumLineBreakpoint v1, Breakpoint v2) {
+      if (direction == Direction.MERGE) {
+        breakpointMap.add(v2, v1);
+      } else {
+        onlyFirst(v1);
+        onlySecond(v2);
+      }
+    }
+    @Override
+    void onlyFirst(ChromiumLineBreakpoint v1) {
+      missingUi.add(v1);
+    }
+    @Override
+    void onlySecond(Breakpoint v2) {
+      missingSdk.add(v2);
+    }
+    List<ChromiumLineBreakpoint> getMissingUi() {
+      return missingUi;
+    }
+    List<Breakpoint> getMissingSdk() {
+      return missingSdk;
+    }
+  }
+
+  /**
+   * A class responsible for creating a summary status of synchronization operation. The status
+   * is created once all asynchronous jobs have finished. Each job first registers itself
+   * via {@link #plan()} method and
+   * later reports its result via {@link #done(Exception)} method.
+   * When the last job is reporting its finishing, the status gets built and sent to
+   * {@link #callback}. If no exceptions were registered,
+   * status contains text report from {@link ReportBuilder}.
+   */
+  private static class StatusBuilder {
+    private final Callback callback;
+    private int plannedNumber = 0;
+    private final List<Exception> exceptions = new ArrayList<Exception>(0);
+    private boolean alreadyReported = false;
+    private final ReportBuilder reportBuilder;
+
+    StatusBuilder(Callback callback, ReportBuilder reportBuilder) {
+      this.callback = callback;
+      this.reportBuilder = reportBuilder;
+    }
+
+    ReportBuilder getReportBuilder() {
+      return reportBuilder;
+    }
+
+    public synchronized void plan() {
+      if (alreadyReported) {
+        throw new IllegalStateException();
+      }
+      plannedNumber++;
+    }
+
+    public void done(Exception ex) {
+      boolean timeToReport = doneImpl(ex);
+      if (timeToReport) {
+        reportResult();
+      }
+    }
+
+    private synchronized boolean doneImpl(Exception ex) {
+      if (ex != null) {
+        exceptions.add(ex);
+      }
+      plannedNumber--;
+      if (plannedNumber == 0) {
+        if (!alreadyReported) {
+          alreadyReported = true;
+          return true;
+        }
+      }
+      return false;
+    }
+
+    private void reportResult() {
+      IStatus status;
+      if (exceptions.isEmpty()) {
+        status = new Status(IStatus.OK, ChromiumDebugPlugin.PLUGIN_ID,
+            "Breakpoint synchronization done: " + reportBuilder.build(), null); //$NON-NLS-1$
+      } else {
+        IStatus[] subStatuses = new IStatus[exceptions.size()];
+        for (int i = 0 ; i < subStatuses.length; i++) {
+          subStatuses[i] = new Status(IStatus.ERROR, ChromiumDebugPlugin.PLUGIN_ID,
+              exceptions.get(i).getMessage(), exceptions.get(i));
+        }
+        status = new MultiStatus(ChromiumDebugPlugin.PLUGIN_ID, IStatus.ERROR, subStatuses,
+            "Breakpoint synchronization errors", null); //$NON-NLS-1$
+      }
+      if (callback != null) {
+        callback.onDone(status);
+      }
+    }
+  }
+
+  private static class PlannedTaskHelper implements SyncCallback {
+    private final StatusBuilder statusBuilder;
+    private volatile Exception exception = null;
+    PlannedTaskHelper(StatusBuilder statusBuilder) {
+      this.statusBuilder = statusBuilder;
+      statusBuilder.plan();
+    }
+    public void callbackDone(RuntimeException e) {
+      if (e != null) {
+        exception = e;
+      }
+      statusBuilder.done(exception);
+    }
+    void setException(Exception ex) {
+      exception = ex;
+    }
+  }
+
+  /**
+   * A class that contains several conunters.
+   */
+  private static class ReportBuilder {
+    enum Property {
+      LINKED,
+      CREATED_LOCALLY,
+      DELETED_LOCALLY,
+      CREATED_ON_REMOTE,
+      DELETED_ON_REMOTE;
+      String getVisibleName() {
+        return toString();
+      }
+    }
+
+    private final Direction direction;
+    private final Map<Property, AtomicInteger> counters;
+
+    ReportBuilder(Direction direction) {
+      this.direction = direction;
+      counters = new EnumMap<Property, AtomicInteger>(Property.class);
+      for (Property property : Property.class.getEnumConstants()) {
+        counters.put(property, new AtomicInteger(0));
+      }
+    }
+
+    public void increment(Property property) {
+      counters.get(property).addAndGet(1);
+    }
+
+    public String build() {
+      StringBuilder builder = new StringBuilder();
+      builder.append("direction=").append(direction); //$NON-NLS-1$
+      for (Map.Entry<Property, AtomicInteger> en : counters.entrySet()) {
+        int number = en.getValue().get();
+        if (number == 0) {
+          continue;
+        }
+        builder.append(" ").append(en.getKey().getVisibleName()); //$NON-NLS-1$
+        builder.append("=").append(number); //$NON-NLS-1$
+      }
+      return builder.toString();
+    }
+  }
+
+  /**
+   * A handler for properties of breakpoint type B that helps reading them.
+   */
+  private static abstract class PropertyHandler<B> {
+    /** @return vm resource name or null */
+    abstract VmResourceId getVmResourceId(B breakpoint);
+    /** @return 0-based number */
+    abstract long getLineNumber(B breakpoint);
+  }
+
+  private final PropertyHandler<ChromiumLineBreakpoint> uiBreakpointHandler =
+      new PropertyHandler<ChromiumLineBreakpoint>() {
+      @Override
+    long getLineNumber(ChromiumLineBreakpoint chromiumLineBreakpoint) {
+      int lineNumber;
+      try {
+        // TODO(peter.rybin): Consider supporting inline scripts here.
+        return chromiumLineBreakpoint.getLineNumber() - 1;
+      } catch (CoreException e) {
+        throw new RuntimeException(e);
+      }
+    }
+
+    @Override
+    VmResourceId getVmResourceId(ChromiumLineBreakpoint chromiumLineBreakpoint) {
+      IMarker marker = chromiumLineBreakpoint.getMarker();
+      if (marker == null) {
+        return null;
+      }
+      IResource resource = marker.getResource();
+      if (resource instanceof IFile == false) {
+        return null;
+      }
+      IFile file = (IFile) resource;
+      try {
+        return sourceDirector.getReverseSourceLookup().findVmResource(file);
+      } catch (CoreException e) {
+        throw new RuntimeException("Failed to read script name from breakpoint", e); //$NON-NLS-1$
+      }
+    }
+  };
+
+  private static final PropertyHandler<Breakpoint> sdkBreakpointHandler =
+      new PropertyHandler<Breakpoint>() {
+    @Override
+    long getLineNumber(Breakpoint breakpoint) {
+      return breakpoint.getLineNumber();
+    }
+
+    @Override
+    VmResourceId getVmResourceId(Breakpoint breakpoint) {
+      if (breakpoint.getType() == Breakpoint.Type.SCRIPT_NAME) {
+        return VmResourceId.forName(breakpoint.getScriptName());
+      } else {
+        Long scriptId = breakpoint.getScriptId();
+        if (scriptId == null) {
+          return null;
+        }
+        return VmResourceId.forId(scriptId);
+      }
+    }
+  };
+
+  /**
+   * A helping structure that holds field of complicated type.
+   */
+  private static class SortedBreakpoints<B> {
+    final Map<VmResourceId, Map<Long, B>> data;
+
+    SortedBreakpoints(Map<VmResourceId, Map<Long, B>> data) {
+      this.data = data;
+    }
+  }
+
+  /**
+   * Put all breakpoints into map script_name -> line_number -> breakpoint.
+   */
+  private static <B> SortedBreakpoints<B> sortBreakpoints(Collection<? extends B> breakpoints,
+      PropertyHandler<B> handler) {
+    Map<VmResourceId, Map<Long, B>> result = new HashMap<VmResourceId, Map<Long, B>>();
+    for (B breakpoint : breakpoints) {
+      VmResourceId vmResourceId = handler.getVmResourceId(breakpoint);
+      if (vmResourceId == null) {
+        continue;
+      }
+      Map<Long, B> subMap = result.get(vmResourceId);
+      if (subMap == null) {
+        subMap = new HashMap<Long, B>(3);
+        result.put(vmResourceId, subMap);
+      }
+      long line = handler.getLineNumber(breakpoint);
+      // For simplicity we ignore multiple breakpoints on the same line.
+      subMap.put(line, breakpoint);
+    }
+    return new SortedBreakpoints<B>(result);
+  }
+
+  /**
+   * A class that implements merge operation for a particular complete/incomplete pair of values.
+   */
+  private static abstract class Merger<V1, V2> {
+    abstract void onlyFirst(V1 v1);
+    abstract void onlySecond(V2 v2);
+    abstract void both(V1 v1, V2 v2);
+  }
+
+  /**
+   * Merges values of 2 maps.
+   * @param map2 must implement {@link Map#remove} method.
+   */
+  private static <K, V1, V2> void mergeMaps(Map<K, V1> map1, Map<K, V2> map2,
+      Merger<V1, V2> merger) {
+    for (Map.Entry<K, V1> en : map1.entrySet()) {
+      V2 v2 = map2.remove(en.getKey());
+      if (v2 == null) {
+        merger.onlyFirst(en.getValue());
+      } else {
+        merger.both(en.getValue(), v2);
+      }
+    }
+    for (V2 v2 : map2.values()) {
+      merger.onlySecond(v2);
+    }
+  }
+
+  private static <B1, B2> void mergeBreakpoints(final Merger<B1, B2> perBreakpointMerger,
+      SortedBreakpoints<B1> side1, SortedBreakpoints<B2> side2) {
+    Merger<Map<Long, B1>, Map<Long, B2>> perScriptMerger =
+        new Merger<Map<Long,B1>, Map<Long,B2>>() {
+      @Override
+      void both(Map<Long, B1> v1, Map<Long, B2> v2) {
+        mergeMaps(v1, v2, perBreakpointMerger);
+      }
+
+      @Override
+      void onlyFirst(Map<Long, B1> v1) {
+        mergeMaps(v1, Collections.<Long, B2>emptyMap(), perBreakpointMerger);
+      }
+
+      @Override
+      void onlySecond(Map<Long, B2> v2) {
+        mergeMaps(Collections.<Long, B1>emptyMap(), v2, perBreakpointMerger);
+      }
+    };
+    mergeMaps(side1.data, side2.data, perScriptMerger);
+  }
+
+
+  private static Collection<? extends Breakpoint> readSdkBreakpoints(JavascriptVm javascriptVm) {
+    class CallbackImpl implements JavascriptVm.ListBreakpointsCallback {
+      public void failure(Exception exception) {
+        problem = exception;
+      }
+
+      public void success(Collection<? extends Breakpoint> breakpoints) {
+        result = breakpoints;
+      }
+      Collection<? extends Breakpoint> getResult() {
+        if (problem != null) {
+          throw new RuntimeException("Failed to synchronize breakpoints", problem); //$NON-NLS-1$
+        }
+        return result;
+      }
+      Exception problem = null;
+      Collection<? extends Breakpoint> result = null;
+    }
+
+    CallbackImpl callback = new CallbackImpl();
+    CallbackSemaphore callbackSemaphore = new CallbackSemaphore();
+
+    javascriptVm.listBreakpoints(callback, callbackSemaphore);
+    boolean res = callbackSemaphore.tryAcquireDefault();
+    if (!res) {
+      throw new RuntimeException("Timeout"); //$NON-NLS-1$
+    }
+
+    return callback.getResult();
+  }
+
+  // We need this method to return Set for future purposes.
+  private Set<ChromiumLineBreakpoint> getUiBreakpoints() {
+    IBreakpointManager breakpointManager = DebugPlugin.getDefault().getBreakpointManager();
+    Set<ChromiumLineBreakpoint> result = new HashSet<ChromiumLineBreakpoint>();
+
+    for (IBreakpoint breakpoint: breakpointManager.getBreakpoints(debugModelId)) {
+      if (breakpoint instanceof ChromiumLineBreakpoint == false) {
+        continue;
+      }
+      ChromiumLineBreakpoint chromiumLineBreakpoint = (ChromiumLineBreakpoint) breakpoint;
+      result.add(chromiumLineBreakpoint);
+    }
+    return result;
+  }
+
+  public static class ProtocolNotSupportedOnRemote extends Exception {
+    ProtocolNotSupportedOnRemote() {
+    }
+    ProtocolNotSupportedOnRemote(String message, Throwable cause) {
+      super(message, cause);
+    }
+    ProtocolNotSupportedOnRemote(String message) {
+      super(message);
+    }
+    ProtocolNotSupportedOnRemote(Throwable cause) {
+      super(cause);
+    }
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/ChromiumLineBreakpoint.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/ChromiumLineBreakpoint.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/ChromiumLineBreakpoint.java	Tue Jun 08 16:12:51 2010 -0700
@@ -4,13 +4,21 @@
 
 package org.chromium.debug.core.model;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.chromium.debug.core.ChromiumDebugPlugin;
 import org.chromium.sdk.Breakpoint;
+import org.chromium.sdk.JavascriptVm;
+import org.chromium.sdk.SyncCallback;
+import org.chromium.sdk.JavascriptVm.BreakpointCallback;
+import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspaceRunnable;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.debug.core.IBreakpointManager;
 import org.eclipse.debug.core.model.IBreakpoint;
 import org.eclipse.debug.core.model.LineBreakpoint;
 import org.eclipse.osgi.util.NLS;
@@ -26,25 +34,14 @@
   /** Condition */
   private static final String CONDITION_ATTR = ChromiumDebugPlugin.PLUGIN_ID + ".condition"; //$NON-NLS-1$
 
-  private Breakpoint browserBreakpoint;
-
   /**
    * Default constructor is required for the breakpoint manager to re-create
    * persisted breakpoints. After instantiating a breakpoint, the setMarker
    * method is called to restore this breakpoint's attributes.
    */
-  // FIXME(apavlov): now this does not restore the browserBreakpoint value
   public ChromiumLineBreakpoint() {
   }
 
-  public void setBreakpoint(Breakpoint breakpoint) {
-    this.browserBreakpoint = breakpoint;
-  }
-
-  public Breakpoint getBrowserBreakpoint() {
-    return browserBreakpoint;
-  }
-
   /**
    * Constructs a line breakpoint on the given resource at the given line number
    * (line number is 1-based).
@@ -53,15 +50,15 @@
    * @param lineNumber 1-based line number of the breakpoint
    * @throws CoreException if unable to create the breakpoint
    */
-  public ChromiumLineBreakpoint(final IResource resource, final int lineNumber)
-      throws CoreException {
+  public ChromiumLineBreakpoint(final IResource resource, final int lineNumber,
+      final String modelId) throws CoreException {
     IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
       public void run(IProgressMonitor monitor) throws CoreException {
         IMarker marker = resource.createMarker(ChromiumDebugPlugin.BP_MARKER);
         setMarker(marker);
         marker.setAttribute(IBreakpoint.ENABLED, Boolean.TRUE);
         marker.setAttribute(IMarker.LINE_NUMBER, lineNumber);
-        marker.setAttribute(IBreakpoint.ID, getModelIdentifier());
+        marker.setAttribute(IBreakpoint.ID, modelId);
         marker.setAttribute(IMarker.MESSAGE, NLS.bind(
             Messages.JsLineBreakpoint_MessageMarkerFormat, resource.getName(), lineNumber));
       }
@@ -104,21 +101,100 @@
   }
 
   public String getModelIdentifier() {
-    return VProjectWorkspaceBridge.DEBUG_MODEL_ID;
+    return getMarker().getAttribute(IBreakpoint.ID, "");
   }
 
-  public void changed() {
-    if (browserBreakpoint != null) {
-      browserBreakpoint.setCondition(getCondition());
-      browserBreakpoint.setEnabled(isEnabled());
-      browserBreakpoint.setIgnoreCount(getIgnoreCount());
-      browserBreakpoint.flush(null);
+  /**
+   * A helper that propagates changes in Eclipse Debugger breakpoints (i.e.
+   * {@link ChromiumLineBreakpoint}) to ChromeDevTools SDK breakpoints. Note that
+   * {@link ChromiumLineBreakpoint} can't do it itself, because it may correspond to several
+   * SDK {@link JavascriptVm}'s simultaneously.
+   */
+  public static class Helper {
+    public interface CreateOnRemoveCallback {
+      void success(Breakpoint breakpoint);
+      void failure(String errorMessage);
+    }
+
+    public static void createOnRemote(ChromiumLineBreakpoint uiBreakpoint,
+        VmResourceId scriptId, DebugTargetImpl debugTarget,
+        final CreateOnRemoveCallback createOnRemoveCallback,
+        SyncCallback syncCallback) throws CoreException {
+      JavascriptVm javascriptVm = debugTarget.getJavascriptEmbedder().getJavascriptVm();
+
+      // ILineBreakpoint lines are 1-based while V8 lines are 0-based
+      final int line = (uiBreakpoint.getLineNumber() - 1);
+      BreakpointCallback callback = new BreakpointCallback() {
+        public void success(Breakpoint sdkBreakpoint) {
+          createOnRemoveCallback.success(sdkBreakpoint);
+        }
+        public void failure(String errorMessage) {
+          createOnRemoveCallback.failure(errorMessage);
+        }
+      };
+
+      javascriptVm.setBreakpoint(scriptId.getTypeForBreakpoint(),
+          scriptId.getTargetForBreakpoint(),
+          line,
+          Breakpoint.EMPTY_VALUE,
+          uiBreakpoint.isEnabled(),
+          uiBreakpoint.getCondition(),
+          uiBreakpoint.getIgnoreCount(),
+          callback, syncCallback);
+    }
+
+    public static void updateOnRemote(Breakpoint sdkBreakpoint,
+        ChromiumLineBreakpoint uiBreakpoint) {
+      sdkBreakpoint.setCondition(uiBreakpoint.getCondition());
+      sdkBreakpoint.setEnabled(uiBreakpoint.isEnabled());
+      sdkBreakpoint.setIgnoreCount(uiBreakpoint.getIgnoreCount());
+      sdkBreakpoint.flush(null, null);
+    }
+
+    public static ChromiumLineBreakpoint createLocal(Breakpoint sdkBreakpoint,
+        IBreakpointManager breakpointManager, IFile resource, int script_line_offset,
+        String debugModelId) throws CoreException {
+      ChromiumLineBreakpoint uiBreakpoint = new ChromiumLineBreakpoint(resource,
+          (int) sdkBreakpoint.getLineNumber() + 1 + script_line_offset,
+          debugModelId);
+      uiBreakpoint.setCondition(sdkBreakpoint.getCondition());
+      uiBreakpoint.setEnabled(sdkBreakpoint.isEnabled());
+      uiBreakpoint.setIgnoreCount(sdkBreakpoint.getIgnoreCount());
+      ignoreList.add(uiBreakpoint);
+      try {
+        breakpointManager.addBreakpoint(uiBreakpoint);
+      } finally {
+        ignoreList.remove(uiBreakpoint);
+      }
+      return uiBreakpoint;
     }
   }
 
-  public void clear() {
-    if (browserBreakpoint != null) {
-      browserBreakpoint.clear(null);
+  private static final BreakpointIgnoreList ignoreList = new BreakpointIgnoreList();
+
+  public static BreakpointIgnoreList getIgnoreList() {
+    return ignoreList;
+  }
+
+  public static class BreakpointIgnoreList {
+    private final List<ChromiumLineBreakpoint> list = new ArrayList<ChromiumLineBreakpoint>(1);
+
+    public boolean contains(IBreakpoint breakpoint) {
+      return list.contains(breakpoint);
+    }
+
+    public void remove(ChromiumLineBreakpoint lineBreakpoint) {
+      boolean res = list.remove(lineBreakpoint);
+      if (!res) {
+        throw new IllegalStateException();
+      }
+    }
+
+    public void add(ChromiumLineBreakpoint lineBreakpoint) {
+      if (list.contains(lineBreakpoint)) {
+        throw new IllegalStateException();
+      }
+      list.add(lineBreakpoint);
     }
   }
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/DebugTargetImpl.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/DebugTargetImpl.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/DebugTargetImpl.java	Tue Jun 08 16:12:51 2010 -0700
@@ -4,6 +4,7 @@
 
 package org.chromium.debug.core.model;
 
+import java.util.ArrayList;
 import java.util.List;
 
 import org.chromium.debug.core.ChromiumDebugPlugin;
@@ -12,7 +13,9 @@
 import org.chromium.sdk.DebugEventListener;
 import org.chromium.sdk.ExceptionData;
 import org.chromium.sdk.JavascriptVm;
+import org.chromium.sdk.LiveEditDebugEventListener;
 import org.chromium.sdk.Script;
+import org.chromium.sdk.UpdatableScript;
 import org.chromium.sdk.DebugContext.State;
 import org.chromium.sdk.DebugContext.StepAction;
 import org.eclipse.core.resources.IFile;
@@ -338,8 +341,8 @@
     return super.getAdapter(adapter);
   }
 
-  public IFile getScriptResource(Script script) {
-    return workspaceRelations.getScriptResource(script);
+  public VmResource getVmResource(IFile resource) throws CoreException {
+    return workspaceRelations.findVmResourceFromWorkspaceFile(resource);
   }
 
   public JavascriptThread getThread() {
@@ -361,7 +364,7 @@
 
   private final DebugEventListenerImpl debugEventListener = new DebugEventListenerImpl();
 
-  class DebugEventListenerImpl implements DebugEventListener {
+  class DebugEventListenerImpl implements DebugEventListener, LiveEditDebugEventListener {
     // Synchronizes calls from ReaderThread of Connection and one call from some worker thread
     private final Object suspendResumeMonitor = new Object();
     private boolean alreadyResumedOrSuspended = false;
@@ -396,6 +399,11 @@
       workspaceRelations.scriptLoaded(newScript);
     }
 
+    public void scriptContentChanged(UpdatableScript newScript) {
+      listenerBlock.waitUntilReady();
+      workspaceRelations.reloadScript(newScript);
+    }
+
     public void suspended(DebugContext context) {
       listenerBlock.waitUntilReady();
       synchronized (suspendResumeMonitor) {
@@ -419,6 +427,12 @@
     }
   }
 
+  public void synchronizeBreakpoints(BreakpointSynchronizer.Direction direction,
+      BreakpointSynchronizer.Callback callback) {
+    workspaceRelations.synchronizeBreakpoints(direction, callback);
+  }
+
+
   private void logExceptionFromContext(DebugContext context) {
     ExceptionData exceptionData = context.getExceptionData();
     List<? extends CallFrame> callFrames = context.getCallFrames();
@@ -491,9 +505,18 @@
   public WorkspaceBridge.JsLabelProvider getLabelProvider() {
     return workspaceBridgeFactory.getLabelProvider();
   }
-  
-  public int getLineNumber(CallFrame stackFrame) {
-    return workspaceRelations.getLineNumber(stackFrame);
+
+  public static List<DebugTargetImpl> getAllDebugTargetImpls() {
+    IDebugTarget[] array = DebugPlugin.getDefault().getLaunchManager().getDebugTargets();
+    List<DebugTargetImpl> result = new ArrayList<DebugTargetImpl>(array.length);
+    for (IDebugTarget target : array) {
+      if (target instanceof DebugTargetImpl == false) {
+        continue;
+      }
+      DebugTargetImpl debugTargetImpl = (DebugTargetImpl) target;
+      result.add(debugTargetImpl);
+    }
+    return result;
   }
 
   private static class ListenerBlock {
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/LineBreakpointAdapter.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/LineBreakpointAdapter.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/LineBreakpointAdapter.java	Tue Jun 08 16:12:51 2010 -0700
@@ -28,7 +28,7 @@
         ITextEditor editorPart = (ITextEditor) part;
         IResource resource = (IResource) editorPart.getEditorInput().getAdapter(IResource.class);
         if (resource != null &&
-            ChromiumDebugPluginUtil.CHROMIUM_EXTENSION.equals(resource.getFileExtension())) {
+            ChromiumDebugPluginUtil.SUPPORTED_EXTENSIONS.contains(resource.getFileExtension())) {
           return editorPart;
         }
       }
@@ -62,7 +62,8 @@
       }
 
       // Line numbers start with 0 in V8, with 1 in Eclipse.
-      ChromiumLineBreakpoint lineBreakpoint = new ChromiumLineBreakpoint(resource, lineNumber + 1);
+      ChromiumLineBreakpoint lineBreakpoint = new ChromiumLineBreakpoint(resource, lineNumber + 1,
+          getDebugModelId());
       DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(lineBreakpoint);
     }
   }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/Messages.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/Messages.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/Messages.java	Tue Jun 08 16:12:51 2010 -0700
@@ -59,6 +59,12 @@
 
   public static String JsThread_ThreadLabelSuspendedExceptionFormat;
 
+  public static String MockUpResourceWriter_NOT_A_JAVASCRIPT;
+
+  public static String MockUpResourceWriter_SCRIPT_WITHOUT_TEXT;
+
+  public static String MockUpResourceWriter_SCRIPTS_OVERLAPPED;
+
   public static String ResourceManager_UnnamedScriptName;
 
   public static String StackFrame_NameFormat;
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/MockUpResourceWriter.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/MockUpResourceWriter.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,140 @@
+// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.core.model;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.chromium.sdk.Script;
+import org.eclipse.osgi.util.NLS;
+
+/**
+ * Creates from a set of scripts a mock-up of full resource (scripts are positioned according
+ * to their line numbers and the whitespace is filled with text pattern).
+ */
+class MockUpResourceWriter {
+  static String writeScriptSource(List<Script> scripts) {
+    ArrayList<Script> sortedScriptsArrayList = new ArrayList<Script>(scripts);
+    Collections.sort(sortedScriptsArrayList, scriptPositionComparator);
+    MockUpResourceWriter writer = new MockUpResourceWriter();
+    for (Script script : sortedScriptsArrayList) {
+      writer.writeSript(script);
+    }
+    return writer.getResult();
+  }
+
+
+  private int line = 0;
+  private int col = 0;
+  private final StringBuilder builder = new StringBuilder();
+
+  private void writeSript(Script script) {
+    int scriptLine = script.getStartLine();
+    if (scriptLine > line) {
+      fillLines(scriptLine - line);
+      line = scriptLine;
+    } else if (scriptLine < line) {
+      writeLineMissMessage(scriptLine);
+    } else {
+      int scriptCol = script.getStartColumn();
+      if (col < scriptCol) {
+        fillColumns(scriptCol - col);
+      } else if (col > scriptCol) {
+        final boolean expectCorrectStartColumn = false;
+        if (expectCorrectStartColumn) {
+          writeln(""); //$NON-NLS-1$
+          writeLineMissMessage(scriptLine);
+        } else {
+          // Ignore.
+        }
+      }
+    }
+
+    if (script.hasSource()) {
+      writeText(script.getSource());
+    } else {
+      writeln(Messages.MockUpResourceWriter_SCRIPT_WITHOUT_TEXT);
+    }
+  }
+
+  private void writeLineMissMessage(int scriptLine) {
+    writeln(NLS.bind(Messages.MockUpResourceWriter_SCRIPTS_OVERLAPPED,
+        line + 1 - scriptLine, scriptLine + 1));
+  }
+
+  private void writeText(String text) {
+    int pos = 0;
+    while (true) {
+      int nlPos = text.indexOf('\n', pos);
+      if (nlPos == -1) {
+        String rest = text.substring(pos);
+        builder.append(rest);
+        col += rest.length();
+        break;
+      }
+      writeln(text.substring(pos, nlPos));
+      pos = nlPos + 1;
+    }
+  }
+
+  private void writeln(String str) {
+    builder.append(str).append('\n');
+    line++;
+    col = 0;
+  }
+
+  private void fillLines(int lines) {
+    if (col != 0) {
+      builder.append('\n');
+      line++;
+    }
+    for (int i = 0; i < lines; i++) {
+      builder.append(NOT_A_JAVASCRIPT_FILLER).append('\n');
+    }
+    line += lines;
+    col = 0;
+  }
+
+  private void fillColumns(int number) {
+    if (number < NOT_A_JAVASCRIPT_FILLER.length()) {
+      if (number < 1) {
+        // Nothing.
+      } else if (number == 1) {
+        builder.append('*');
+        col += 1;
+      } else {
+        builder.append('{');
+        for (int i = 2; i < number; i++) {
+          builder.append('*');
+        }
+        builder.append('}');
+        col += number;
+      }
+    }
+  }
+
+  private String getResult() {
+    return builder.toString();
+  }
+
+  private static final String NOT_A_JAVASCRIPT_FILLER =
+      Messages.MockUpResourceWriter_NOT_A_JAVASCRIPT;
+
+  private static final Comparator<Script> scriptPositionComparator = new Comparator<Script>() {
+    public int compare(Script o1, Script o2) {
+      int line1 = o1.getStartLine();
+      int line2 = o2.getStartLine();
+      if (line1 < line2) {
+        return -1;
+      } else if (line1 == line2) {
+        return 0;
+      } else {
+        return 1;
+      }
+    }
+  };
+}
\ No newline at end of file
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/ResourceManager.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/ResourceManager.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/ResourceManager.java	Tue Jun 08 16:12:51 2010 -0700
@@ -1,134 +1,154 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.debug.core.model;
 
+import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
 import org.chromium.debug.core.ChromiumDebugPlugin;
-import org.chromium.debug.core.model.BreakpointRegistry.BreakpointEntry;
-import org.chromium.debug.core.model.BreakpointRegistry.ScriptIdentifier;
 import org.chromium.debug.core.util.ChromiumDebugPluginUtil;
 import org.chromium.sdk.Script;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
-import org.eclipse.debug.core.DebugPlugin;
 
 /**
  * This object handles the mapping between {@link Script}s and their corresponding resources
  * inside Eclipse.
  */
 public class ResourceManager {
-  private final Map<IFile, Script> resourceToScript = new HashMap<IFile, Script>();
-  private final Map<ScriptIdentifier, IFile> scriptIdToResource =
-      new HashMap<ScriptIdentifier, IFile>();
   private final IProject debugProject;
-  private final BreakpointRegistry breakpointRegistry;
-  private Object fileBeingAdded;
+
+  private final Map<VmResourceId, VmResourceInfo> vmResourceId2Info =
+      new HashMap<VmResourceId, VmResourceInfo>();
+  private final Map<IFile, VmResourceInfo> file2Info = new HashMap<IFile, VmResourceInfo>();
+
+  public ResourceManager(IProject debugProject) {
+    this.debugProject = debugProject;
+  }
 
-  public ResourceManager(IProject debugProject, BreakpointRegistry breakpointRegistry) {
-    this.debugProject = debugProject;
-    this.breakpointRegistry = breakpointRegistry;
+  public synchronized VmResource getVmResource(VmResourceId id) {
+    VmResourceInfo info = vmResourceId2Info.get(id);
+    if (info == null) {
+      return null;
+    }
+    return info.vmResourceImpl;
+  }
+
+  /**
+   * @param eclipseSourceName eclipse source file name
+   *   (what {@link VmResourceId#getEclipseSourceName()} returns)
+   */
+  public IFile getFile(String eclipseSourceName) {
+    VmResourceId id = VmResourceId.parseString(eclipseSourceName);
+    VmResourceInfo info = vmResourceId2Info.get(id);
+    if (info == null) {
+      return null;
+    }
+    return info.file;
   }
 
-  public synchronized void putScript(Script script, IFile resource) {
-    ScriptIdentifier scriptId = ScriptIdentifier.forScript(script);
-    resourceToScript.put(resource, script);
-    scriptIdToResource.put(scriptId, resource);
+  public synchronized VmResourceId getResourceId(IFile resource) {
+    VmResourceInfo info = file2Info.get(resource);
+    if (info == null) {
+      return null;
+    }
+    return info.id;
   }
 
-  public synchronized Script getScript(IFile resource) {
-    return resourceToScript.get(resource);
+  public synchronized void addScript(Script newScript) {
+    VmResourceId id = VmResourceId.forScript(newScript);
+    VmResourceInfo info = vmResourceId2Info.get(id);
+    if (info == null) {
+      String fileNameTemplate = createFileNameTemplate(id, newScript);
+      IFile scriptFile = ChromiumDebugPluginUtil.createFile(debugProject, fileNameTemplate);
+      info = new VmResourceInfo(scriptFile, id);
+      vmResourceId2Info.put(id, info);
+      file2Info.put(scriptFile, info);
+
+      info.scripts.add(newScript);
+      writeScriptSource(info.scripts, info.file);
+    } else {
+      // TODO(peter.rybin): support adding scripts to one resource at once not to rewrite file
+      // every time.
+      info.scripts.add(newScript);
+      writeScriptSource(info.scripts, info.file);
+    }
   }
 
-  public synchronized IFile getResource(Script script) {
-    return scriptIdToResource.get(ScriptIdentifier.forScript(script));
-  }
-
-  public synchronized boolean scriptHasResource(Script script) {
-    return getResource(script) != null;
+  public synchronized void reloadScript(Script script) {
+    VmResourceId id = VmResourceId.forScript(script);
+    VmResourceInfo info = vmResourceId2Info.get(id);
+    if (info == null) {
+      throw new RuntimeException("Script file not found"); //$NON-NLS-1$
+    }
+    if (!info.scripts.contains(script)) {
+      throw new RuntimeException("Script not found in internal list"); //$NON-NLS-1$
+    }
+    writeScriptSource(info.scripts, info.file);
   }
 
   public synchronized void clear() {
     deleteAllScriptFiles();
-    resourceToScript.clear();
-    scriptIdToResource.clear();
+
+    vmResourceId2Info.clear();
+    file2Info.clear();
   }
 
   private void deleteAllScriptFiles() {
-    if (!resourceToScript.isEmpty()) {
-      try {
-        ResourcesPlugin.getWorkspace().delete(
-            resourceToScript.keySet().toArray(new IFile[resourceToScript.size()]), true, null);
-      } catch (CoreException e) {
-        ChromiumDebugPlugin.log(e);
-      }
+    try {
+      ResourcesPlugin.getWorkspace().delete(
+          file2Info.keySet().toArray(new IFile[file2Info.size()]), true, null);
+    } catch (CoreException e) {
+      ChromiumDebugPlugin.log(e);
+    }
+  }
+
+  private String createFileNameTemplate(VmResourceId id, Script newScript) {
+    return id.createFileNameTemplate(true);
+  }
+
+  private static void writeScriptSource(List<Script> scripts, IFile file) {
+    String fileSource = MockUpResourceWriter.writeScriptSource(scripts);
+
+    try {
+      ChromiumDebugPluginUtil.writeFile(file, fileSource);
+    } catch (final CoreException e) {
+      ChromiumDebugPlugin.log(e);
     }
   }
 
-  public synchronized void addScript(Script script) {
-    IFile scriptFile = getResource(script);
-    if (scriptFile == null) {
-      scriptFile = ChromiumDebugPluginUtil.createFile(debugProject, getScriptResourceName(script));
-      fileBeingAdded = scriptFile;
-      try {
-        putScript(script, scriptFile);
-        writeScriptSource(script, scriptFile);
-        // Perhaps restore breakpoints for the reloaded script
-        List<ChromiumLineBreakpoint> breakpoints = new LinkedList<ChromiumLineBreakpoint>();
-        for (BreakpointEntry entry : breakpointRegistry.getBreakpointEntries(script)) {
-          ChromiumLineBreakpoint lineBreakpoint;
-          try {
-            lineBreakpoint = new ChromiumLineBreakpoint(scriptFile, entry.line + 1);
-          } catch (CoreException e) {
-            ChromiumDebugPlugin.log(e);
-            continue;
+  private class VmResourceInfo {
+    final IFile file;
+    final VmResourceId id;
+    final ArrayList<Script> scripts = new ArrayList<Script>(1);
+    VmResourceInfo(IFile file, VmResourceId id) {
+      this.file = file;
+      this.id = id;
+    }
+
+    final VmResource vmResourceImpl = new VmResource() {
+      public VmResourceId getId() {
+        return id;
+      }
+
+      public Script getScript() {
+        synchronized (ResourceManager.this) {
+          if (scripts.size() != 1) {
+            throw new UnsupportedOperationException(
+                "Not supported for complex resources"); //$NON-NLS-1$
           }
-          lineBreakpoint.setBreakpoint(entry.breakpoint);
-          breakpoints.add(lineBreakpoint);
-        }
-        if (!breakpoints.isEmpty()) {
-          try {
-            DebugPlugin.getDefault().getBreakpointManager().addBreakpoints(
-                breakpoints.toArray(new ChromiumLineBreakpoint[breakpoints.size()]));
-          } catch (CoreException e) {
-            ChromiumDebugPlugin.log(e);
-          }
+          return scripts.get(0);
         }
-      } finally {
-        fileBeingAdded = null;
       }
-    }
-  }
-
-  private String getScriptResourceName(Script script) {
-    String name = script.getName();
-    if (name == null) {
-      name = Messages.ResourceManager_UnnamedScriptName;
-    }
-    return name;
-  }
-
-  private static void writeScriptSource(Script script, IFile file) {
-    if (script.hasSource()) {
-      try {
-        ChromiumDebugPluginUtil.writeFile(file, script.getSource());
-      } catch (final CoreException e) {
-        ChromiumDebugPlugin.log(e);
+      public String getFileName() {
+        return file.getName();
       }
-    }
-  }
-
-  /**
-   * @return whether the given file is being added to the target project
-   */
-  public boolean isAddingFile(IFile file) {
-    return file.equals(fileBeingAdded);
+    };
   }
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/StackFrame.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/StackFrame.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/StackFrame.java	Tue Jun 08 16:12:51 2010 -0700
@@ -201,7 +201,14 @@
   }
 
   public int getLineNumber() throws DebugException {
-    return getDebugTarget().getLineNumber(stackFrame);
+    // convert 0-based to 1-based
+    int inScriptLine = stackFrame.getLineNumber() + 1;
+    Script script = stackFrame.getScript();
+    if (script != null) {
+      return inScriptLine + script.getStartLine();
+    } else {
+      return inScriptLine;
+    }
   }
 
   public int getCharStart() throws DebugException {
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/VProjectWorkspaceBridge.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/VProjectWorkspaceBridge.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/VProjectWorkspaceBridge.java	Tue Jun 08 16:12:51 2010 -0700
@@ -7,6 +7,8 @@
 import java.util.Collection;
 
 import org.chromium.debug.core.ChromiumDebugPlugin;
+import org.chromium.debug.core.ChromiumSourceDirector;
+import org.chromium.debug.core.model.BreakpointSynchronizer.Callback;
 import org.chromium.debug.core.util.ChromiumDebugPluginUtil;
 import org.chromium.sdk.Breakpoint;
 import org.chromium.sdk.CallFrame;
@@ -14,19 +16,15 @@
 import org.chromium.sdk.ExceptionData;
 import org.chromium.sdk.JavascriptVm;
 import org.chromium.sdk.Script;
-import org.chromium.sdk.JavascriptVm.BreakpointCallback;
+import org.chromium.sdk.SyncCallback;
 import org.chromium.sdk.JavascriptVm.ScriptsCallback;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IMarkerDelta;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.debug.core.DebugException;
-import org.eclipse.debug.core.DebugPlugin;
-import org.eclipse.debug.core.IBreakpointManager;
 import org.eclipse.debug.core.ILaunch;
 import org.eclipse.debug.core.model.IBreakpoint;
-import org.eclipse.debug.core.model.ISourceLocator;
-import org.eclipse.debug.core.model.IStackFrame;
 import org.eclipse.osgi.util.NLS;
 
 /**
@@ -61,17 +59,28 @@
   private final IProject debugProject;
   private final JavascriptVm javascriptVm;
   private final ResourceManager resourceManager;
-  private final BreakpointRegistry breakpointRegistry = new BreakpointRegistry();
   private final DebugTargetImpl debugTargetImpl;
+  private final BreakpointMap.InTargetMap breakpointInTargetMap = new BreakpointMap.InTargetMap();
+  private final ChromiumSourceDirector sourceDirector;
 
   public VProjectWorkspaceBridge(String projectName, DebugTargetImpl debugTargetImpl,
       JavascriptVm javascriptVm) {
     this.debugTargetImpl = debugTargetImpl;
     this.javascriptVm = javascriptVm;
     this.debugProject = ChromiumDebugPluginUtil.createEmptyProject(projectName);
-    this.resourceManager = new ResourceManager(debugProject, breakpointRegistry);
+    this.resourceManager = new ResourceManager(debugProject);
+
     ILaunch launch = debugTargetImpl.getLaunch();
-    launch.setSourceLocator(sourceLocator);
+
+    sourceDirector = (ChromiumSourceDirector) launch.getSourceLocator();
+    sourceDirector.initializeVProjectContainers(debugProject, resourceManager);
+  }
+
+  public void synchronizeBreakpoints(BreakpointSynchronizer.Direction direction,
+      Callback callback) {
+    BreakpointSynchronizer synchronizer = new BreakpointSynchronizer(javascriptVm,
+        breakpointInTargetMap, sourceDirector, breakpointHandler, DEBUG_MODEL_ID);
+    synchronizer.syncBreakpoints(direction, callback);
   }
 
   public void launchRemoved() {
@@ -81,21 +90,6 @@
   }
 
   public void beforeDetach() {
-    IBreakpointManager breakpointManager = DebugPlugin.getDefault().getBreakpointManager();
-    IBreakpoint[] breakpoints =
-        breakpointManager.getBreakpoints(DEBUG_MODEL_ID);
-    for (IBreakpoint bp : breakpoints) {
-      ChromiumLineBreakpoint clb = (ChromiumLineBreakpoint) bp;
-      if (clb.getBrowserBreakpoint() != null &&
-          clb.getBrowserBreakpoint().getId() != Breakpoint.INVALID_ID) {
-        clb.getBrowserBreakpoint().clear(null);
-      }
-    }
-    try {
-      breakpointManager.removeBreakpoints(breakpoints, true);
-    } catch (CoreException e) {
-      ChromiumDebugPlugin.log(e);
-    }
   }
 
   public void handleVmResetEvent() {
@@ -123,139 +117,183 @@
     });
   }
 
-  public IFile getScriptResource(Script script) {
-    return resourceManager.getResource(script);
+  public VmResource findVmResourceFromWorkspaceFile(IFile resource) throws CoreException {
+    VmResourceId id = findVmResourceIdFromWorkspaceFile(resource);
+    if (id == null) {
+      return null;
+    }
+    return resourceManager.getVmResource(id);
+  }
+
+  private VmResourceId findVmResourceIdFromWorkspaceFile(IFile resource) throws CoreException {
+    return sourceDirector.getReverseSourceLookup().findVmResource(resource);
+  }
+
+  public void reloadScript(Script script) {
+    resourceManager.reloadScript(script);
   }
 
   public BreakpointHandler getBreakpointHandler() {
     return breakpointHandler;
   }
 
-  private final BreakpointHandler breakpointHandler = new BreakpointHandler() {
+  private final BreakpointHandlerImpl breakpointHandler = new BreakpointHandlerImpl();
+
+  private class BreakpointHandlerImpl implements BreakpointHandler,
+      BreakpointSynchronizer.BreakpointHelper {
     public boolean supportsBreakpoint(IBreakpoint breakpoint) {
       return DEBUG_MODEL_ID.equals(breakpoint.getModelIdentifier()) &&
           !debugTargetImpl.isDisconnected();
     }
+
+    public ChromiumLineBreakpoint tryCastBreakpoint(IBreakpoint breakpoint) {
+      if (!supportsBreakpoint(breakpoint)) {
+        return null;
+      }
+      if (breakpoint instanceof ChromiumLineBreakpoint == false) {
+        return null;
+      }
+      return (ChromiumLineBreakpoint) breakpoint;
+    }
+
     public void breakpointAdded(IBreakpoint breakpoint) {
-      if (!supportsBreakpoint(breakpoint)) {
+      ChromiumLineBreakpoint lineBreakpoint = tryCastBreakpoint(breakpoint);
+      if (lineBreakpoint == null) {
+        return;
+      }
+      if (ChromiumLineBreakpoint.getIgnoreList().contains(breakpoint)) {
+        return;
+      }
+      if (!lineBreakpoint.isEnabled()) {
+        return;
+      }
+      IFile file = (IFile) lineBreakpoint.getMarker().getResource();
+      VmResourceId vmResourceId;
+      try {
+        vmResourceId = findVmResourceIdFromWorkspaceFile(file);
+      } catch (CoreException e) {
+        ChromiumDebugPlugin.log(
+            new Exception("Failed to resolve script for the file " + file, e)); //$NON-NLS-1$
         return;
       }
+      if (vmResourceId == null) {
+        // Might be a script from a different debug target
+        return;
+      }
+
+      createBreakpointOnRemote(lineBreakpoint, vmResourceId, null, null);
+    }
+
+    public void createBreakpointOnRemote(final ChromiumLineBreakpoint lineBreakpoint,
+        final VmResourceId vmResourceId,
+        final CreateCallback createCallback, SyncCallback syncCallback) {
       try {
-        if (breakpoint.isEnabled()) {
-          // Class cast is ensured by the supportsBreakpoint implementation
-          final ChromiumLineBreakpoint lineBreakpoint = (ChromiumLineBreakpoint) breakpoint;
-          IFile file = (IFile) breakpoint.getMarker().getResource();
-          if (resourceManager.isAddingFile(file)) {
-            return; // restoring breakpoints in progress
-          }
-          final Script script = resourceManager.getScript(file);
-          if (script == null) {
-            // Might be a script from a different debug target
-            return;
-          }
-          // ILineBreakpoint lines are 1-based while V8 lines are 0-based
-          final int line = (lineBreakpoint.getLineNumber() - 1) + script.getStartLine();
-          BreakpointCallback callback = new BreakpointCallback() {
-            public void success(Breakpoint breakpoint) {
-              lineBreakpoint.setBreakpoint(breakpoint);
-              breakpointRegistry.add(script, line, breakpoint);
-            }
-
-            public void failure(String errorMessage) {
-              ChromiumDebugPlugin.logError(errorMessage);
+        ChromiumLineBreakpoint.Helper.CreateOnRemoveCallback callback =
+            new ChromiumLineBreakpoint.Helper.CreateOnRemoveCallback() {
+          public void success(Breakpoint breakpoint) {
+            breakpointInTargetMap.add(breakpoint, lineBreakpoint);
+            if (createCallback != null) {
+              createCallback.success();
             }
-          };
-          if (script.getName() != null) {
-            javascriptVm.setBreakpoint(Breakpoint.Type.SCRIPT_NAME,
-                script.getName(),
-                line,
-                Breakpoint.EMPTY_VALUE,
-                breakpoint.isEnabled(),
-                lineBreakpoint.getCondition(),
-                lineBreakpoint.getIgnoreCount(),
-                callback);
-          } else {
-            javascriptVm.setBreakpoint(Breakpoint.Type.SCRIPT_ID,
-                String.valueOf(script.getId()),
-                line,
-                Breakpoint.EMPTY_VALUE,
-                breakpoint.isEnabled(),
-                lineBreakpoint.getCondition(),
-                lineBreakpoint.getIgnoreCount(),
-                callback);
+          }
+          public void failure(String errorMessage) {
+            if (createCallback == null) {
+              ChromiumDebugPlugin.logError(errorMessage);
+            } else {
+              createCallback.failure(new Exception(errorMessage));
+            }
           }
-        }
+        };
+
+        ChromiumLineBreakpoint.Helper.createOnRemote(lineBreakpoint, vmResourceId, debugTargetImpl,
+            callback, syncCallback);
       } catch (CoreException e) {
-        ChromiumDebugPlugin.log(e);
+        ChromiumDebugPlugin.log(new Exception("Failed to create breakpoint in " + //$NON-NLS-1$
+            getTargetNameSafe(), e));
       }
     }
 
     public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
-      if (!supportsBreakpoint(breakpoint)) {
+      ChromiumLineBreakpoint lineBreakpoint = tryCastBreakpoint(breakpoint);
+      if (lineBreakpoint == null) {
+        return;
+      }
+      if (ChromiumLineBreakpoint.getIgnoreList().contains(lineBreakpoint)) {
         return;
       }
-      // Class cast is ensured by the supportsBreakpoint implementation
-      ((ChromiumLineBreakpoint) breakpoint).changed();
+      Breakpoint sdkBreakpoint = breakpointInTargetMap.getSdkBreakpoint(lineBreakpoint);
+      if (sdkBreakpoint == null) {
+        return;
+      }
+
+      try {
+        ChromiumLineBreakpoint.Helper.updateOnRemote(sdkBreakpoint, lineBreakpoint);
+      } catch (RuntimeException e) {
+        ChromiumDebugPlugin.log(new Exception("Failed to change breakpoint in " + //$NON-NLS-1$
+            getTargetNameSafe(), e));
+      }
+
     }
 
     public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
-      if (!supportsBreakpoint(breakpoint)) {
+      ChromiumLineBreakpoint lineBreakpoint = tryCastBreakpoint(breakpoint);
+      if (lineBreakpoint == null) {
+        return;
+      }
+      if (ChromiumLineBreakpoint.getIgnoreList().contains(lineBreakpoint)) {
         return;
       }
+
+      Breakpoint sdkBreakpoint = breakpointInTargetMap.getSdkBreakpoint(lineBreakpoint);
+      if (sdkBreakpoint == null) {
+        return;
+      }
+
       try {
-        if (breakpoint.isEnabled()) {
-          // Class cast is ensured by the supportsBreakpoint implementation
-          ChromiumLineBreakpoint lineBreakpoint = (ChromiumLineBreakpoint) breakpoint;
-          lineBreakpoint.clear();
-          breakpointRegistry.remove(
-              resourceManager.getScript((IFile) breakpoint.getMarker().getResource()),
-              lineBreakpoint.getLineNumber() - 1,
-              lineBreakpoint.getBrowserBreakpoint());
+        if (!breakpoint.isEnabled()) {
+          return;
         }
       } catch (CoreException e) {
         ChromiumDebugPlugin.log(e);
+        return;
       }
+      JavascriptVm.BreakpointCallback callback = new JavascriptVm.BreakpointCallback() {
+        public void failure(String errorMessage) {
+          ChromiumDebugPlugin.log(new Exception("Failed to remove breakpoint in " + //$NON-NLS-1$
+              getTargetNameSafe() + ": " + errorMessage)); //$NON-NLS-1$
+        }
+        public void success(Breakpoint breakpoint) {
+        }
+      };
+      try {
+        sdkBreakpoint.clear(callback, null);
+      } catch (RuntimeException e) {
+        ChromiumDebugPlugin.log(new Exception("Failed to remove breakpoint in " + //$NON-NLS-1$
+            getTargetNameSafe(), e));
+      }
+      breakpointInTargetMap.remove(lineBreakpoint);
     }
 
     public void breakpointsHit(Collection<? extends Breakpoint> breakpointsHit) {
       if (breakpointsHit.isEmpty()) {
         return;
       }
-      IBreakpoint[] breakpoints =
-          DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(DEBUG_MODEL_ID);
-      for (IBreakpoint breakpoint : breakpoints) {
-        ChromiumLineBreakpoint jsBreakpoint = (ChromiumLineBreakpoint) breakpoint;
-        if (breakpointsHit.contains(jsBreakpoint.getBrowserBreakpoint())) {
-          jsBreakpoint.setIgnoreCount(-1); // reset ignore count as we've hit it
+
+      for (Breakpoint sdkBreakpoint : breakpointsHit) {
+        ChromiumLineBreakpoint uiBreakpoint = breakpointInTargetMap.getUiBreakpoint(sdkBreakpoint);
+        if (uiBreakpoint != null) {
+          uiBreakpoint.setIgnoreCount(-1); // reset ignore count as we've hit it
         }
       }
     }
-  };
-
-  public int getLineNumber(CallFrame stackFrame) {
-    // convert 0-based to 1-based
-    return stackFrame.getLineNumber() + 1;
+    private String getTargetNameSafe() {
+      try {
+        return debugTargetImpl.getLaunch().getLaunchConfiguration().getName();
+      } catch (RuntimeException e) {
+        return "<unknown>"; //$NON-NLS-1$
+      }
+    }
   }
-  
-  /**
-   * This very simple source locator works because we provide our own source files.
-   * We'll have to try harder, once we link with resource js files.
-   */
-  private final ISourceLocator sourceLocator = new ISourceLocator() {
-    public Object getSourceElement(IStackFrame stackFrame) {
-      if (stackFrame instanceof StackFrame == false) {
-        return null;
-      }
-      StackFrame jsStackFrame = (StackFrame) stackFrame;
-
-      Script script = jsStackFrame.getCallFrame().getScript();
-      if (script == null) {
-        return null;
-      }
-
-      return resourceManager.getResource(script);
-    }
-  };
 
   private final static JsLabelProvider LABEL_PROVIDER = new JsLabelProvider() {
     public String getTargetLabel(DebugTargetImpl debugTarget) {
@@ -298,16 +336,18 @@
       CallFrame callFrame = stackFrame.getCallFrame();
       String name = callFrame.getFunctionName();
       Script script = callFrame.getScript();
+      String scriptName;
       if (script == null) {
-        return Messages.StackFrame_UnknownScriptName;
+        scriptName = Messages.StackFrame_UnknownScriptName;
+      } else {
+        scriptName = VmResourceId.forScript(script).getEclipseSourceName();
       }
-      int line = script.getStartLine() + stackFrame.getLineNumber();
+      int line = stackFrame.getLineNumber();
       if (line != -1) {
         name = NLS.bind(Messages.StackFrame_NameFormat,
-            new Object[] {name, script.getName(), line});
+            new Object[] {name, scriptName, line});
       }
       return name;
     }
   };
-
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/VmResource.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/VmResource.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,25 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.core.model;
+
+import org.chromium.sdk.Script;
+
+/**
+ * A representation of V8 VM resource. The exact nature of the resource is unspecified, we
+ * only know it may contain one or more {@link Script}s. Typically resource is .js or .html file.
+ */
+
+public interface VmResource {
+  VmResourceId getId();
+
+  /**
+   * @return script if this resource entirely consists of 1 script, otherwise throws exception
+   * @throws UnsupportedOperationException if this resource does not entirely consists of 1 script
+   * TODO(peter.rybin): redesign this method to normally work with html resources.
+   */
+  Script getScript();
+
+  String getFileName();
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/VmResourceId.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/VmResourceId.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,118 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.core.model;
+
+import org.chromium.sdk.Breakpoint;
+import org.chromium.sdk.JavascriptVm;
+import org.chromium.sdk.Script;
+
+/**
+ * Id of resources loaded in V8 VM. We only know that they may have name (typically filename or
+ * URL) or numerical id instead. This class reflects this.
+ * The class also contains several utility methods that probably should be separated in the future.
+ */
+public class VmResourceId {
+
+  public static VmResourceId forName(String scriptName) {
+    return new VmResourceId(scriptName);
+  }
+
+  public static VmResourceId forId(long scriptId) {
+    return new VmResourceId(Long.valueOf(scriptId));
+  }
+
+  public static VmResourceId forScript(Script script) {
+    if (script.getName() != null) {
+      return forName(script.getName());
+    } else {
+      return forId(script.getId());
+    }
+  }
+
+  private final Object value;
+
+  private VmResourceId(Object value) {
+    if (value == null) {
+      throw new IllegalArgumentException("Null id value"); //$NON-NLS-1$
+    }
+    this.value = value;
+  }
+
+  @Override
+  public int hashCode() {
+    return value.hashCode();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (obj instanceof VmResourceId == false) {
+      return false;
+    }
+    VmResourceId other = (VmResourceId) obj;
+    return this.value.equals(other.value);
+  }
+
+  /**
+   * @return parameter for {@link JavascriptVm#setBreakpoint} method.
+   */
+  public Breakpoint.Type getTypeForBreakpoint() {
+    if (value instanceof String) {
+      return Breakpoint.Type.SCRIPT_NAME;
+    } else {
+      return Breakpoint.Type.SCRIPT_ID;
+    }
+  }
+
+  /**
+   * @return parameter for {@link JavascriptVm#setBreakpoint} method.
+   */
+  public String getTargetForBreakpoint() {
+    return value.toString();
+  }
+
+  String createFileNameTemplate(boolean isEval) {
+    if (value instanceof String) {
+      return value.toString();
+    } else {
+      if (isEval) {
+        return "<eval #" + value + ">"; //$NON-NLS-1$ //$NON-NLS-2$
+      } else {
+        return "<no name #" + value + ">"; //$NON-NLS-1$ //$NON-NLS-2$
+      }
+    }
+
+  }
+
+  @Override
+  public String toString() {
+    return getEclipseSourceName();
+  }
+
+  /**
+   * @return source name that is suitable for Eclipse debug source lookup.
+   */
+  public String getEclipseSourceName() {
+    if (value instanceof String) {
+      String stringValue = (String) value;
+      if (stringValue.startsWith("#")) {
+        // Quote it.
+        stringValue = "#" + stringValue;
+      }
+      return stringValue;
+    } else {
+      return "#" + value;
+    }
+  }
+
+  public static VmResourceId parseString(String name) {
+    if (name.startsWith("##")) {
+      return VmResourceId.forName(name.substring(1));
+    } else if (name.startsWith("#")) {
+      return VmResourceId.forId(Long.parseLong(name.substring(1)));
+    } else {
+      return VmResourceId.forName(name);
+    }
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/WorkspaceBridge.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/WorkspaceBridge.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/WorkspaceBridge.java	Tue Jun 08 16:12:51 2010 -0700
@@ -7,10 +7,10 @@
 import java.util.Collection;
 
 import org.chromium.sdk.Breakpoint;
-import org.chromium.sdk.CallFrame;
 import org.chromium.sdk.JavascriptVm;
 import org.chromium.sdk.Script;
 import org.eclipse.core.resources.IFile;
+import org.eclipse.core.runtime.CoreException;
 import org.eclipse.debug.core.DebugException;
 import org.eclipse.debug.core.IBreakpointListener;
 import org.eclipse.debug.core.model.IBreakpoint;
@@ -48,10 +48,12 @@
     JsLabelProvider getLabelProvider();
   }
 
+  VmResource findVmResourceFromWorkspaceFile(IFile resource) throws CoreException;
+
   /**
-   * Helps UI actions to map from script to resource.
+   * Initiates script reloading from remote VM.
    */
-  IFile getScriptResource(Script script);
+  void reloadScript(Script script);
 
   /**
    * Called at starting period of time, requires all scripts to be (re)loaded.
@@ -87,12 +89,6 @@
   BreakpointHandler getBreakpointHandler();
 
   /**
-   * Returns editor line number for the provided call stack frame applying all required 
-   * editor-specific translations.
-   */
-  int getLineNumber(CallFrame stackFrame);
-
-  /**
    * Breakpoint-related aspect of {@link WorkspaceBridge} interface.
    */
   interface BreakpointHandler extends IBreakpointListener {
@@ -119,4 +115,12 @@
      */
     String getStackFrameLabel(StackFrame stackFrame) throws DebugException;
   }
+
+  /**
+   * Performs breakpoint synchronization between remote VM and Eclipse IDE. This operation is
+   * partially asynchronous: it blocks for reading breakpoints, but returns before all remote
+   * changes are performed. When operations is fully complete, callback gets invoked.
+   */
+  void synchronizeBreakpoints(BreakpointSynchronizer.Direction direction,
+      BreakpointSynchronizer.Callback callback);
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/model/messages.properties
--- a/org.chromium.debug.core/src/org/chromium/debug/core/model/messages.properties	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/model/messages.properties	Tue Jun 08 16:12:51 2010 -0700
@@ -25,6 +25,9 @@
 JsThread_ThreadLabelRunning=Running
 JsThread_ThreadLabelSuspended=Suspended
 JsThread_ThreadLabelSuspendedExceptionFormat=Suspended (exception "{0}")
+MockUpResourceWriter_NOT_A_JAVASCRIPT={not a JavaScript}
+MockUpResourceWriter_SCRIPT_WITHOUT_TEXT={ JavaScript script without text }
+MockUpResourceWriter_SCRIPTS_OVERLAPPED={ scripts overlapped. the following script must be {0} line(s) upper (at line {1}) }
 ResourceManager_UnnamedScriptName=(program)
 StackFrame_NameFormat={0} [{1}:{2}]
 StackFrame_UnknownScriptName=<unknown>
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.core/src/org/chromium/debug/core/util/ChromiumDebugPluginUtil.java
--- a/org.chromium.debug.core/src/org/chromium/debug/core/util/ChromiumDebugPluginUtil.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.core/src/org/chromium/debug/core/util/ChromiumDebugPluginUtil.java	Tue Jun 08 16:12:51 2010 -0700
@@ -7,6 +7,11 @@
 import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 import org.chromium.debug.core.ChromiumDebugPlugin;
 import org.chromium.debug.core.efs.ChromiumScriptFileSystem;
@@ -36,7 +41,19 @@
  */
 public class ChromiumDebugPluginUtil {
 
-  public static final String CHROMIUM_EXTENSION = "chromium"; //$NON-NLS-1$
+  private static final String CHROMIUM_EXTENSION = "chromium"; //$NON-NLS-1$
+
+  public static final Set<String> SUPPORTED_EXTENSIONS =
+      new HashSet<String>(Arrays.asList(CHROMIUM_EXTENSION, "js", //$NON-NLS-1$
+          "html", "htm")); //$NON-NLS-1$ //$NON-NLS-2$
+
+  public static final List<String> SUPPORTED_EXTENSIONS_SUFFIX_LIST;
+  static {
+    SUPPORTED_EXTENSIONS_SUFFIX_LIST = new ArrayList<String>(SUPPORTED_EXTENSIONS.size());
+    for (String extension : SUPPORTED_EXTENSIONS) {
+      SUPPORTED_EXTENSIONS_SUFFIX_LIST.add("." + extension); //$NON-NLS-1$
+    }
+  }
 
   public static final String JS_DEBUG_PROJECT_NATURE = "org.chromium.debug.core.jsnature"; //$NON-NLS-1$
 
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/META-INF/MANIFEST.MF
--- a/org.chromium.debug.ui/META-INF/MANIFEST.MF	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.ui/META-INF/MANIFEST.MF	Tue Jun 08 16:12:51 2010 -0700
@@ -14,6 +14,7 @@
  org.eclipse.core.variables;bundle-version="3.2.100",
  org.eclipse.ui.ide;bundle-version="3.4.1",
  org.chromium.debug.core;bundle-version="0.1.5",
- org.chromium.sdk;bundle-version="0.1.5"
+ org.chromium.sdk;bundle-version="0.1.5",
+ org.eclipse.compare;bundle-version="3.5.0"
 Bundle-ActivationPolicy: lazy
 Bundle-RequiredExecutionEnvironment: J2SE-1.5
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/plugin.xml
--- a/org.chromium.debug.ui/plugin.xml	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.ui/plugin.xml	Tue Jun 08 16:12:51 2010 -0700
@@ -29,7 +29,9 @@
         modes="debug"
         name="%chromiumLaunchName"
         delegateName="Debug Chromium JavaScript"
-        delegateDescription="JavaScript debugger for Chromium">
+        delegateDescription="JavaScript debugger for Chromium"
+        sourceLocatorId="org.chromium.debug.core.ChromiumSourceDirector"
+        sourcePathComputerId="org.chromium.debug.core.ChromiumSourceComputer">
     </launchConfigurationType>
     <launchConfigurationType
         id="org.chromium.debug.ui.LaunchType$StandaloneV8"
@@ -37,7 +39,9 @@
         modes="debug"
         name="%standaloneV8LaunchName"
         delegateName="Debug Standalone V8 JavaScript"
-        delegateDescription="JavaScript debugger for Standalone V8">
+        delegateDescription="JavaScript debugger for Standalone V8"
+        sourceLocatorId="org.chromium.debug.core.ChromiumSourceDirector"
+        sourcePathComputerId="org.chromium.debug.core.ChromiumSourceComputer">
     </launchConfigurationType>
     <launchConfigurationType
         id="org.chromium.debug.ui.ConsolePseudoConfigurationType"
@@ -185,9 +189,9 @@
             id="org.chromium.debug.ui.actions.EnableDisableBreakpointAction"/>
         <action
             label="Breakpoint Properties..."
-            class="org.chromium.debug.ui.actions.JsBreakpointPropertiesRulerActionDelegate"
+            class="org.chromium.debug.ui.actions.JsBreakpointPropertiesRulerAction$Delegate"
             menubarPath="group.properties"
-            id="org.chromium.debug.ui.actions.JavaBreakpointPropertiesRulerActionDelegate">
+            id="org.chromium.debug.ui.actions.JavaBreakpointPropertiesRulerAction$Delegate">
         </action>
         <action
             label="Toggle Enablement"
@@ -200,17 +204,111 @@
   <extension
          point="org.eclipse.ui.popupMenus">
       <objectContribution
+            objectClass="org.chromium.debug.core.model.ChromiumLineBreakpoint"
+            id="org.chromium.debug.core.model.ChromiumLineBreakpoint.object_actions">
+        <action
+            label="Breakpoint Properties..."
+            class="org.chromium.debug.ui.actions.JsBreakpointPropertiesAction"
+            menubarPath="group.properties"
+            id="org.chromium.debug.ui.actions.JsBreakpointPropertiesAction">
+        </action>
+      </objectContribution>
+         
+      <objectContribution
             objectClass="org.chromium.debug.core.model.Variable"
             id="org.chromium.debug.ui.ChromiumVariableActions">
          <action
                label="%OpenFunctionAction.label"
-               class="org.chromium.debug.ui.actions.OpenFunctionAction"
+               class="org.chromium.debug.ui.actions.OpenFunctionAction$ForVariable"
+               menubarPath="emptyNavigationGroup"
+               enablesFor="1"
+               id="org.chromium.debug.ui.actions.OpenFunctionAction$ForVariable">
+         </action>
+      </objectContribution>
+      <objectContribution
+            objectClass="org.eclipse.debug.core.model.IWatchExpression"
+            id="org.chromium.debug.ui.ChromiumExpressionActions">
+         <action
+               label="%OpenFunctionAction.label"
+               class="org.chromium.debug.ui.actions.OpenFunctionAction$ForExpression"
                menubarPath="emptyNavigationGroup"
                enablesFor="1"
-               id="org.chromium.debug.ui.actions.OpenFunctionAction">
+               id="org.chromium.debug.ui.actions.OpenFunctionAction$ForExpression">
+         </action>
+      </objectContribution>
+      <!-- Experimental actions, temporary disabled. -->
+      <objectContribution
+            objectClass="org.eclipse.core.resources.mapping.ResourceMapping"
+            adaptable="true"
+            id="org.chromium.debug.ui.ChromiumSourceFileActionsId">
+         <menu id="org.chromium.debug.ui.ChromiumSourceFileActionsId.MenuId"
+               label="V8 Debugging"
+         >
+            <separator
+                  name="group0">
+            </separator>
+         </menu>
+         <action
+               label="Compare with VM Source"
+               class="org.chromium.debug.ui.actions.CompareChangesAction"
+               menubarPath="org.chromium.debug.ui.ChromiumSourceFileActionsId.MenuId/group0"
+               enablesFor="1"
+               id="org.chromium.debug.ui.actions.CompareChangesAction">
+         </action>
+         <action
+               label="Push Changes to VM"
+               class="org.chromium.debug.ui.actions.PushChangesAction"
+               menubarPath="org.chromium.debug.ui.ChromiumSourceFileActionsId.MenuId/group0"
+               enablesFor="1"
+               id="org.chromium.debug.ui.actions.PushChangesAction">
          </action>
       </objectContribution>
   </extension>
+
+   <extension
+         point="org.eclipse.ui.perspectiveExtensions">
+      <perspectiveExtension
+            targetID="org.eclipse.debug.ui.DebugPerspective">
+         <actionSet
+               id="org.chromium.debug.ui.ChromiumDebugActionSet">
+         </actionSet>
+      </perspectiveExtension>
+  </extension>
+
+  <extension
+         point="org.eclipse.ui.popupMenus">
+      <objectContribution
+            objectClass="org.eclipse.debug.core.ILaunch"
+            id="org.chromium.debug.ui.actions.actions-for-launch">
+         <menu id="org.chromium.debug.ui.actions.SynchronizeBreakpoints.MenuId"
+               label="Synchronize JavaScript Breakpoints"
+               path="launchGroup"
+         >
+            <separator
+                  name="group0">
+            </separator>
+         </menu>
+         <action
+               label="Reset on Remote"
+               class="org.chromium.debug.ui.actions.SynchronizeBreakpoints$ResetRemote"
+               menubarPath="org.chromium.debug.ui.actions.SynchronizeBreakpoints.MenuId/group0"
+               id="org.chromium.debug.ui.actions.SynchronizeBreakpoints$ResetRemote.forLaunch">
+         </action>
+         <action
+               label="Reset on Local"
+               class="org.chromium.debug.ui.actions.SynchronizeBreakpoints$ResetLocal"
+               menubarPath="org.chromium.debug.ui.actions.SynchronizeBreakpoints.MenuId/group0"
+               id="org.chromium.debug.ui.actions.SynchronizeBreakpoints$ResetLocal.forLaunch">
+         </action>
+         <action
+               label="Merge Remote and Local"
+               class="org.chromium.debug.ui.actions.SynchronizeBreakpoints$Merge"
+               menubarPath="org.chromium.debug.ui.actions.SynchronizeBreakpoints.MenuId/group0"
+               id="org.chromium.debug.ui.actions.SynchronizeBreakpoints$Merge.forLaunch">
+         </action>
+      </objectContribution>
+  </extension>
+
   <extension
          point="org.eclipse.ui.propertyPages">
     <page
@@ -229,4 +327,14 @@
       </enabledWhen>
     </page>
   </extension>
+  
+
+  <extension point="org.eclipse.debug.ui.sourceContainerPresentations">
+      <sourceContainerPresentation
+            browserClass="org.chromium.debug.ui.source.SourceNameMapperContainerPresentation"
+            containerTypeID="org.chromium.debug.core.SourceNameMapperContainer.type"
+            icon="res/standalone_v8_16.png"
+            id="org.chromium.debug.ui.SourceNameMapperContainerPresentation">
+      </sourceContainerPresentation>
+  </extension>
 </plugin>
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/DialogUtils.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/DialogUtils.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,404 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.ui;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.jface.dialogs.IMessageProvider;
+import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Shell;
+
+/**
+ * A small set of utility classes that help programming dialog window logic.
+ */
+public class DialogUtils {
+  /*
+   * Part 1. Update graph.
+   *
+   * All logical elements of dialog and dependencies between them are modeled as DAG.
+   * The data flows from vertices that corresponds to various input fields through
+   * some transformations to the terminal vertices that are in-dialog helper messages and OK button.
+   *
+   * A linear data flow (no forks, no merges) is suitable for data transformation and
+   * is programmed manually. Forks and merges are hard to dispatch manually and are managed by
+   * class Updater.
+   *
+   * Updater knows about "source" vertices that may have several outgoing edges and about
+   * "consumer" vertices that may have several incoming edges. Based on source vertex changes
+   * updater updates consumer vertices in topological order.
+   */
+
+  /**
+   * Represents source vertex for Updater. Technically updater uses this interface only as a flag
+   * interface, because the only methods it uses are {@link Object#equals}/Object{@link #hashCode}.
+   */
+  public interface ValueSource<T> {
+    /**
+     * Method is not used by updater, for convenience only.
+     * @return current value of the vertex
+     */
+    T getValue();
+  }
+
+  /**
+   * Represents consumer vertex for Updater. Each instance should be explicitly registered in
+   * Updater.
+   */
+  public interface ValueConsumer {
+    /**
+     * Called by updater when some linked sources have changed and it's time this vertex
+     * got updated. {@link Updater#reportChanged} may be called if some {@line ValueSource}s have
+     * changed during this update (but this should not break topological order of the graph).
+     */
+    void update(Updater updater);
+  }
+
+  /**
+   * Helps to conduct update for vertices in a value graph.
+   * Technically Updater does not see a real graph, because it doesn't support vertices
+   * that are simultaneously source and consumer. Programmer helps manage other edges manually by
+   * calling {@link #reportChanged} method.
+   */
+  public static class Updater {
+    private final LinkedHashMap<ValueConsumer, Boolean> needsUpdateMap =
+        new LinkedHashMap<ValueConsumer, Boolean>();
+    private final Map<ValueSource<?>, List<ValueConsumer>> reversedDependenciesMap =
+        new HashMap<ValueSource<?>, List<ValueConsumer>>();
+    private boolean alreadyUpdating = false;
+
+    public void addConsumer(ValueConsumer value, ValueSource<?> ... dependencies) {
+      addConsumer(value, Arrays.asList(dependencies));
+    }
+
+    /**
+     * Registers a consumer vertex with all its dependencies.
+     */
+    public void addConsumer(ValueConsumer value, List<? extends ValueSource<?>> dependencies) {
+      Boolean res = needsUpdateMap.put(value, Boolean.FALSE);
+      if (res != null) {
+        throw new IllegalArgumentException("Already added"); //$NON-NLS-1$
+      }
+      for (ValueSource<?> dep : dependencies) {
+        List<ValueConsumer> reversedDeps = reversedDependenciesMap.get(dep);
+        if (reversedDeps == null) {
+          reversedDeps = new ArrayList<ValueConsumer>(2);
+          reversedDependenciesMap.put(dep, reversedDeps);
+        }
+        reversedDeps.add(value);
+      }
+    }
+
+    /**
+     * Reports about sources that have been changed and plans future update of consumers. This
+     * method may be called at any time (it is not thread-safe though).
+     */
+    public void reportChanged(ValueSource<?> source) {
+      List<ValueConsumer> reversedDeps = reversedDependenciesMap.get(source);
+      if (reversedDeps != null) {
+        for (ValueConsumer consumer : reversedDeps) {
+          needsUpdateMap.put(consumer, Boolean.TRUE);
+        }
+      }
+    }
+
+    /**
+     * Performs update of all vertices that need it. If some sources are reported changed
+     * during the run of this method, their consumers are also updated.
+     */
+    public void update() {
+      if (alreadyUpdating) {
+        return;
+      }
+      alreadyUpdating = true;
+      try {
+        updateImpl();
+      } finally {
+        alreadyUpdating = false;
+      }
+    }
+
+    private void updateImpl() {
+      boolean hasChanges = true;
+      while (hasChanges) {
+        hasChanges = false;
+        for (Map.Entry<ValueConsumer, Boolean> en : needsUpdateMap.entrySet()) {
+          if (en.getValue() == Boolean.TRUE) {
+            en.setValue(Boolean.FALSE);
+            ValueConsumer currentValue = en.getKey();
+            currentValue.update(this);
+          }
+        }
+      }
+    }
+
+    /**
+     * Updates all consumer vertices in graph.
+     */
+    public void updateAll() {
+      for (Map.Entry<?, Boolean> en : needsUpdateMap.entrySet()) {
+        en.setValue(Boolean.TRUE);
+      }
+      update();
+    }
+  }
+
+  /**
+   * A basic implementation of object that is both consumer and source. Updater will treat
+   * as 2 separate objects.
+   */
+  public static abstract class ValueProcessor<T> implements ValueConsumer, ValueSource<T> {
+    private T currentValue = null;
+    public T getValue() {
+      return currentValue;
+    }
+    protected void setCurrentValue(T currentValue) {
+      this.currentValue = currentValue;
+    }
+  }
+
+  /*
+   * Part 2. Optional data type etc
+   *
+   * Since dialog should deal with error user entry, the typical data type is either value or error.
+   * This is implemented as Optional interface. Most of data transformations should work only
+   * when all inputs are non-error and generate error in return otherwise. This is implemented in
+   * ExpressionProcessor.
+   */
+
+
+  /**
+   * A primitive approach to "optional" algebraic type. This type is T + Set<Message>.
+   */
+  public interface Optional<V> {
+    V getNormal();
+    boolean isNormal();
+    Set<? extends Message> errorMessages();
+  }
+
+  public static <V> Optional<V> createOptional(final V value) {
+    return new Optional<V>() {
+      public Set<Message> errorMessages() {
+        return Collections.emptySet();
+      }
+      public V getNormal() {
+        return value;
+      }
+      public boolean isNormal() {
+        return true;
+      }
+    };
+  }
+
+  public static <V> Optional<V> createErrorOptional(Message message) {
+    return createErrorOptional(Collections.singleton(message));
+  }
+
+  public static <V> Optional<V> createErrorOptional(final Set<? extends Message> messages) {
+    return new Optional<V>() {
+      public Set<? extends Message> errorMessages() {
+        return messages;
+      }
+      public V getNormal() {
+        throw new UnsupportedOperationException();
+      }
+      public boolean isNormal() {
+        return false;
+      }
+    };
+  }
+
+  /**
+   * A user interface message for dialog window. It has text and priority that helps choosing
+   * the most important message it there are many of them.
+   */
+  public static class Message {
+    private final String text;
+    private final MessagePriority priority;
+    public Message(String text, MessagePriority priority) {
+      this.text = text;
+      this.priority = priority;
+    }
+    public String getText() {
+      return text;
+    }
+    public MessagePriority getPriority() {
+      return priority;
+    }
+  }
+
+  /**
+   * Priority of a user interface message.
+   * Constants are listed from most important to least important.
+   */
+  public enum MessagePriority {
+    BLOCKING_PROBLEM(IMessageProvider.ERROR),
+    BLOCKING_INFO(IMessageProvider.NONE),
+    WARNING(IMessageProvider.WARNING);
+
+    private final int messageProviderType;
+    private MessagePriority(int messageProviderType) {
+      this.messageProviderType = messageProviderType;
+    }
+    public int getMessageProviderType() {
+      return messageProviderType;
+    }
+  }
+
+  /**
+   * A base class for the source-consumer pair that accepts several values as a consumer,
+   * performs a calculation over them and gives it away the result via source interface.
+   * Some sources may be of Optional type. If some of sources have error value the corresponding
+   * error value is returned automatically.
+   * <p>
+   * The implementation should override a single method {@link #calculateNormal}.
+   */
+  public static abstract class ExpressionProcessor<T> extends ValueProcessor<Optional<T>> {
+    private final List<ValueSource<? extends Optional<?>>> optionalSources;
+    public ExpressionProcessor(List<ValueSource<? extends Optional<?>>> optionalSources) {
+      this.optionalSources = optionalSources;
+    }
+
+    protected abstract Optional<T> calculateNormal();
+
+    private Optional<T> calculateNewValue() {
+      Set<Message> errors = new LinkedHashSet<Message>(0);
+      for (ValueSource<? extends Optional<?>> source : optionalSources) {
+        if (!source.getValue().isNormal()) {
+          errors.addAll(source.getValue().errorMessages());
+        }
+      }
+      if (errors.isEmpty()) {
+        return calculateNormal();
+      } else {
+        return createErrorOptional(errors);
+      }
+    }
+    public void update(Updater updater) {
+      Optional<T> result = calculateNewValue();
+      Optional<T> oldValue = getValue();
+      setCurrentValue(result);
+      if (!result.equals(oldValue)) {
+        updater.reportChanged(this);
+      }
+    }
+  }
+
+  /*
+   * Part 3. Various utils.
+   */
+
+  /**
+   * A general-purpose implementation of OK button vertex. It works as a consumer of
+   * 1 result value and several warning sources. From its sources it decides whether
+   * OK button should be enabled and also provides dialog messages (errors, warnings, infos).
+   */
+  public static class OkButtonControl implements ValueConsumer {
+    private final ValueSource<? extends Optional<?>> resultSource;
+    private final List<? extends ValueSource<String>> warningSources;
+    private final DialogElements dialogElements;
+
+    public OkButtonControl(ValueSource<? extends Optional<?>> resultSource,
+        List<? extends ValueSource<String>> warningSources, DialogElements dialogElements) {
+      this.resultSource = resultSource;
+      this.warningSources = warningSources;
+      this.dialogElements = dialogElements;
+    }
+
+    /**
+     * Returns a list of dependencies for updater -- a convenience method.
+     */
+    public List<? extends ValueSource<?>> getDependencies() {
+      ArrayList<ValueSource<?>> result = new ArrayList<ValueSource<?>>();
+      result.add(resultSource);
+      result.addAll(warningSources);
+      return result;
+    }
+
+    public void update(Updater updater) {
+      Optional<?> result = resultSource.getValue();
+      List<Message> messages = new ArrayList<Message>();
+      for (ValueSource<String> warningSource : warningSources) {
+        if (warningSource.getValue() != null) {
+          messages.add(new Message(warningSource.getValue(), MessagePriority.WARNING));
+        }
+      }
+      boolean enabled;
+      if (result.isNormal()) {
+        enabled = true;
+      } else {
+        enabled = false;
+        messages.addAll(result.errorMessages());
+      }
+      dialogElements.getOkButton().setEnabled(enabled);
+      String errorMessage;
+      int type;
+      if (messages.isEmpty()) {
+        errorMessage = null;
+        type = IMessageProvider.NONE;
+      } else {
+        Message visibleMessage = Collections.max(messages, messageComparatorBySeverity);
+        errorMessage = visibleMessage.getText();
+        type = visibleMessage.getPriority().getMessageProviderType();
+      }
+      dialogElements.setMessage(errorMessage, type);
+    }
+
+    private static final Comparator<Message> messageComparatorBySeverity =
+        new Comparator<Message>() {
+      public int compare(Message o1, Message o2) {
+        int ordinal1 = o1.getPriority().ordinal();
+        int ordinal2 = o2.getPriority().ordinal();
+        if (ordinal1 < ordinal2) {
+          return +1;
+        } else if (ordinal1 == ordinal2) {
+          return 0;
+        } else {
+          return -1;
+        }
+      }
+    };
+  }
+
+  /**
+   * A basic interface to elements of the dialog window from dialog logic part. The user may extend
+   * this interface with more elements.
+   */
+  public interface DialogElements {
+    Shell getShell();
+    Button getOkButton();
+    void setMessage(String message, int type);
+  }
+
+  /**
+   * A wrapper around Combo that provides logic-level data-oriented access to the control.
+   * This is not a simply convenience wrapper, because Combo itself does not keep a real data,
+   * but only its string representation.
+   */
+  public static abstract class ComboWrapper<E> {
+    private final Combo combo;
+    public ComboWrapper(Combo combo) {
+      this.combo = combo;
+    }
+    public Combo getCombo() {
+      return combo;
+    }
+    public void addSelectionListener(SelectionListener listener) {
+      combo.addSelectionListener(listener);
+    }
+    public abstract E getSelected();
+    public abstract void setSelected(E element);
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/actions/CompareChangesAction.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/CompareChangesAction.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,86 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.ui.actions;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.lang.reflect.InvocationTargetException;
+
+import org.chromium.debug.core.model.VmResource;
+import org.eclipse.compare.CompareConfiguration;
+import org.eclipse.compare.CompareEditorInput;
+import org.eclipse.compare.CompareUI;
+import org.eclipse.compare.IModificationDate;
+import org.eclipse.compare.IStreamContentAccessor;
+import org.eclipse.compare.ITypedElement;
+import org.eclipse.compare.structuremergeviewer.DiffNode;
+import org.eclipse.compare.structuremergeviewer.Differencer;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.swt.graphics.Image;
+
+/**
+ * A very preliminary implementation of action that should let user compare his script with
+ * its current state on remote VM.
+ */
+public class CompareChangesAction extends V8ScriptAction {
+  @Override
+  protected void execute(FilePair filePair) {
+    LiveEditCompareInput input = new LiveEditCompareInput(filePair.getFile(), filePair.getVmResource());
+    CompareUI.openCompareEditor(input);
+  }
+
+  private static class LiveEditCompareInput extends CompareEditorInput {
+    private final IFile file;
+    private final VmResource script;
+
+    LiveEditCompareInput(IFile file, VmResource vmResource) {
+      super(createCompareConfiguration());
+      this.file = file;
+      this.script = vmResource;
+    }
+
+    private static CompareConfiguration createCompareConfiguration() {
+      return new CompareConfiguration();
+    }
+
+    @Override
+    protected Object prepareInput(IProgressMonitor monitor) throws InvocationTargetException,
+        InterruptedException {
+
+      abstract class CompareItem implements ITypedElement, IStreamContentAccessor,
+          IModificationDate {
+        public Image getImage() {
+          return null;
+        }
+        public String getType() {
+          return TEXT_TYPE;
+        }
+        public long getModificationDate() {
+          return 0;
+        }
+      }
+      CompareItem left = new CompareItem() {
+        public String getName() {
+          return "Local file " + file.getName(); //$NON-NLS-1$
+        }
+        public InputStream getContents() throws CoreException {
+          return file.getContents();
+        }
+      };
+      CompareItem right = new CompareItem() {
+        public String getName() {
+          return "File in VM " + script.getFileName(); //$NON-NLS-1$
+        }
+        public InputStream getContents() throws CoreException {
+          return new ByteArrayInputStream(script.getScript().getSource().getBytes());
+        }
+      };
+      DiffNode diffNode = new DiffNode(null, Differencer.PSEUDO_CONFLICT, null, left, right);
+      return diffNode;
+    }
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/actions/JsBreakpointPropertiesAction.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/JsBreakpointPropertiesAction.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,83 @@
+// Copyright (c) 20109 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.ui.actions;
+
+import org.chromium.debug.core.model.ChromiumLineBreakpoint;
+import org.eclipse.debug.core.model.IBreakpoint;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.ISelectionProvider;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jface.window.IShellProvider;
+import org.eclipse.ui.IObjectActionDelegate;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.IWorkbenchPartSite;
+import org.eclipse.ui.dialogs.PropertyDialogAction;
+
+/**
+ * Action to bring up the breakpoint properties dialog.
+ */
+public class JsBreakpointPropertiesAction implements IObjectActionDelegate {
+
+  private Runnable currentRunnable;
+  private IWorkbenchPartSite site = null;
+
+  public void setActivePart(IAction action, IWorkbenchPart targetPart) {
+    site = targetPart.getSite();
+  }
+
+  public void run(IAction action) {
+    currentRunnable.run();
+  }
+
+  public void selectionChanged(IAction action, ISelection selection) {
+    currentRunnable = createRunnable(selection);
+    action.setEnabled(currentRunnable != null);
+  }
+
+
+  private Runnable createRunnable(ISelection selection) {
+    if (selection instanceof IStructuredSelection == false) {
+      return null;
+    }
+    IStructuredSelection structuredSelection = (IStructuredSelection) selection;
+    if (structuredSelection.size() != 1) {
+      return null;
+    }
+    Object element = structuredSelection.getFirstElement();
+    if (element instanceof ChromiumLineBreakpoint == false) {
+      return null;
+    }
+    final ChromiumLineBreakpoint breakpoint = (ChromiumLineBreakpoint) element;
+
+    return new Runnable() {
+      public void run() {
+        runAction(breakpoint, site);
+      }
+    };
+  }
+
+  protected static void runAction(final IBreakpoint breakpoint, IShellProvider shell) {
+    PropertyDialogAction action =
+      new PropertyDialogAction(shell,
+          new ISelectionProvider() {
+            public void addSelectionChangedListener(ISelectionChangedListener listener) {
+            }
+
+            public ISelection getSelection() {
+              return new StructuredSelection(breakpoint);
+            }
+
+            public void removeSelectionChangedListener(ISelectionChangedListener listener) {
+            }
+
+            public void setSelection(ISelection selection) {
+            }
+          });
+    action.run();
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/actions/JsBreakpointPropertiesRulerAction.java
--- a/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/JsBreakpointPropertiesRulerAction.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/JsBreakpointPropertiesRulerAction.java	Tue Jun 08 16:12:51 2010 -0700
@@ -7,12 +7,9 @@
 import org.chromium.debug.core.model.ChromiumLineBreakpoint;
 import org.eclipse.debug.core.model.IBreakpoint;
 import org.eclipse.debug.ui.actions.RulerBreakpointAction;
+import org.eclipse.jface.action.IAction;
 import org.eclipse.jface.text.source.IVerticalRulerInfo;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.ISelectionChangedListener;
-import org.eclipse.jface.viewers.ISelectionProvider;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.ui.dialogs.PropertyDialogAction;
+import org.eclipse.ui.texteditor.AbstractRulerActionDelegate;
 import org.eclipse.ui.texteditor.ITextEditor;
 import org.eclipse.ui.texteditor.IUpdate;
 
@@ -31,23 +28,7 @@
   @Override
   public void run() {
     if (getBreakpoint() != null) {
-      PropertyDialogAction action =
-          new PropertyDialogAction(getEditor().getEditorSite(),
-              new ISelectionProvider() {
-                public void addSelectionChangedListener(ISelectionChangedListener listener) {
-                }
-
-                public ISelection getSelection() {
-                  return new StructuredSelection(getBreakpoint());
-                }
-
-                public void removeSelectionChangedListener(ISelectionChangedListener listener) {
-                }
-
-                public void setSelection(ISelection selection) {
-                }
-              });
-      action.run();
+      JsBreakpointPropertiesAction.runAction(getBreakpoint(), getEditor().getEditorSite());
     }
   }
 
@@ -61,4 +42,13 @@
     setEnabled(breakpoint != null);
   }
 
+
+  public static class Delegate extends AbstractRulerActionDelegate {
+
+    @Override
+    protected IAction createAction(ITextEditor editor, IVerticalRulerInfo rulerInfo) {
+      return new JsBreakpointPropertiesRulerAction(editor, rulerInfo);
+    }
+
+  }
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/actions/JsBreakpointPropertiesRulerActionDelegate.java
--- a/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/JsBreakpointPropertiesRulerActionDelegate.java	Tue Jun 08 16:06:40 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package org.chromium.debug.ui.actions;
-
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.text.source.IVerticalRulerInfo;
-import org.eclipse.ui.texteditor.AbstractRulerActionDelegate;
-import org.eclipse.ui.texteditor.ITextEditor;
-
-/**
- * Delegate for JsBreakpointPropertiesRulerAction.
- */
-public class JsBreakpointPropertiesRulerActionDelegate extends AbstractRulerActionDelegate {
-
-  @Override
-  protected IAction createAction(ITextEditor editor, IVerticalRulerInfo rulerInfo) {
-    return new JsBreakpointPropertiesRulerAction(editor, rulerInfo);
-  }
-
-}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/actions/Messages.java
--- a/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/Messages.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/Messages.java	Tue Jun 08 16:12:51 2010 -0700
@@ -26,6 +26,8 @@
   public static String ExpressionEvaluator_UnableToEvaluateExpression;
 
   public static String JsBreakpointPropertiesRulerAction_ItemLabel;
+
+  public static String SynchronizeBreakpoints_JOB_TITLE;
   static {
     // initialize resource bundle
     NLS.initializeMessages(BUNDLE_NAME, Messages.class);
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/actions/OpenFunctionAction.java
--- a/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/OpenFunctionAction.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/OpenFunctionAction.java	Tue Jun 08 16:12:51 2010 -0700
@@ -1,5 +1,7 @@
 package org.chromium.debug.ui.actions;
 
+import org.chromium.debug.core.model.DebugTargetImpl;
+import org.chromium.debug.core.model.Value;
 import org.chromium.debug.core.model.Variable;
 import org.chromium.debug.ui.JsDebugModelPresentation;
 import org.chromium.debug.ui.editors.JsEditor;
@@ -9,6 +11,11 @@
 import org.chromium.sdk.JsVariable;
 import org.chromium.sdk.Script;
 import org.eclipse.core.resources.IFile;
+import org.eclipse.debug.core.model.IDebugTarget;
+import org.eclipse.debug.core.model.ISourceLocator;
+import org.eclipse.debug.core.model.IValue;
+import org.eclipse.debug.core.model.IWatchExpression;
+import org.eclipse.debug.core.sourcelookup.ISourceLookupDirector;
 import org.eclipse.jface.action.IAction;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.IStructuredSelection;
@@ -27,7 +34,53 @@
 /**
  * The action for context view in Variable view that opens selected function source text in editor.
  */
-public class OpenFunctionAction implements IObjectActionDelegate, IActionDelegate2 {
+public abstract class OpenFunctionAction<ELEMENT> implements IObjectActionDelegate,
+    IActionDelegate2 {
+  public static class ForVariable extends OpenFunctionAction<Variable> {
+    @Override
+    protected Variable castElement(Object element) {
+      if (element instanceof Variable == false) {
+        return null;
+      }
+      return (Variable) element;
+    }
+    @Override
+    protected JsValue getJsValue(Variable variable) {
+      JsVariable jsVariable = variable.getJsVariable();
+      return jsVariable.getValue();
+    }
+    @Override
+    protected DebugTargetImpl getDebugTarget(Variable variable) {
+      return variable.getDebugTarget();
+    }
+  }
+  public static class ForExpression extends OpenFunctionAction<IWatchExpression> {
+    @Override
+    protected IWatchExpression castElement(Object element) {
+      if (element instanceof IWatchExpression == false) {
+        return null;
+      }
+      return (IWatchExpression) element;
+    }
+    @Override
+    protected DebugTargetImpl getDebugTarget(IWatchExpression expression) {
+      IDebugTarget debugTarget = expression.getDebugTarget();
+      if (debugTarget instanceof DebugTargetImpl == false) {
+        return null;
+      }
+      return (DebugTargetImpl) debugTarget;
+    }
+    @Override
+    protected JsValue getJsValue(IWatchExpression expression) {
+      IValue value = expression.getValue();
+      if (value instanceof Value == false) {
+        return null;
+      }
+      Value chromiumValue = (Value) value;
+      return chromiumValue.getJsValue();
+    }
+  }
+
   private Runnable currentRunnable = null;
 
   public void setActivePart(IAction action, IWorkbenchPart targetPart) {
@@ -41,14 +94,14 @@
   }
 
   public void selectionChanged(IAction action, ISelection selection) {
-    final Variable variable = getVariableFromSelection(selection);
-    final JsFunction jsFunction = getJsFunctionFromVariable(variable);
+    final ELEMENT variable = getElementFromSelection(selection);
+    final JsFunction jsFunction = getJsFunctionFromElement(variable);
 
     currentRunnable = createRunnable(variable, jsFunction);
     action.setEnabled(currentRunnable != null);
   }
 
-  private Runnable createRunnable(final Variable variable, final JsFunction jsFunction) {
+  private Runnable createRunnable(final ELEMENT element, final JsFunction jsFunction) {
     if (jsFunction == null) {
       return null;
     }
@@ -63,7 +116,20 @@
         if (script == null) {
           return;
         }
-        IFile resource = variable.getDebugTarget().getScriptResource(script);
+        DebugTargetImpl debugTarget = getDebugTarget(element);
+        if (debugTarget == null) {
+          return;
+        }
+        ISourceLocator sourceLocator = debugTarget.getLaunch().getSourceLocator();
+        if (sourceLocator instanceof ISourceLookupDirector == false) {
+          return;
+        }
+        ISourceLookupDirector director = (ISourceLookupDirector) sourceLocator;
+        Object sourceObject = director.getSourceElement(script);
+        if (sourceObject instanceof IFile == false) {
+          return;
+        }
+        IFile resource = (IFile) sourceObject;
         IEditorInput input = JsDebugModelPresentation.toEditorInput(resource);
         IEditorPart editor;
         try {
@@ -94,12 +160,14 @@
     currentRunnable.run();
   }
 
-  private JsFunction getJsFunctionFromVariable(Variable variable) {
-    if (variable == null) {
+  private JsFunction getJsFunctionFromElement(ELEMENT element) {
+    if (element == null) {
       return null;
     }
-    JsVariable jsVariable = variable.getJsVariable();
-    JsValue jsValue = jsVariable.getValue();
+    JsValue jsValue = getJsValue(element);
+    if (jsValue == null) {
+      return null;
+    }
     JsObject jsObject = jsValue.asObject();
     if (jsObject == null) {
       return null;
@@ -107,7 +175,7 @@
     return jsObject.asFunction();
   }
 
-  private Variable getVariableFromSelection(ISelection selection) {
+  private ELEMENT getElementFromSelection(ISelection selection) {
     if (selection instanceof IStructuredSelection == false) {
       return null;
     }
@@ -117,9 +185,13 @@
       return null;
     }
     Object element = structuredSelection.getFirstElement();
-    if (element instanceof Variable == false) {
-      return null;
-    }
-    return (Variable) element;
+    ELEMENT typedElement = castElement(element);
+    return typedElement;
   }
+
+  protected abstract ELEMENT castElement(Object element);
+
+  protected abstract JsValue getJsValue(ELEMENT element);
+
+  protected abstract DebugTargetImpl getDebugTarget(ELEMENT element);
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/actions/PushChangesAction.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/PushChangesAction.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,81 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.ui.actions;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.chromium.debug.core.ChromiumDebugPlugin;
+import org.chromium.sdk.LiveEditExtension;
+import org.chromium.sdk.UpdatableScript;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+
+/**
+ * The main action of LiveEdit feature. It gets the current state of a working file and pushes
+ * it into running V8 VM.
+ */
+public class PushChangesAction extends V8ScriptAction {
+  @Override
+  protected void execute(final FilePair filePair) {
+    UpdatableScript updatableScript =
+        LiveEditExtension.castToUpdatableScript(filePair.getVmResource().getScript());
+
+    if (updatableScript == null) {
+      throw new RuntimeException();
+    }
+
+    byte[] fileData;
+    try {
+      fileData = readFileContents(filePair.getFile());
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    } catch (CoreException e) {
+      throw new RuntimeException(e);
+    }
+
+    // We are using default charset here like usually.
+    String newSource = new String(fileData);
+
+    UpdatableScript.UpdateCallback callback = new UpdatableScript.UpdateCallback() {
+      public void success(Object report) {
+        ChromiumDebugPlugin.log(new Status(IStatus.OK, ChromiumDebugPlugin.PLUGIN_ID,
+            "Script has been successfully updated on remote: " + report)); //$NON-NLS-1$
+      }
+      public void failure(String message) {
+        ChromiumDebugPlugin.log(new Status(IStatus.ERROR, ChromiumDebugPlugin.PLUGIN_ID,
+            "Failed to change script on remote: " + message)); //$NON-NLS-1$
+      }
+    };
+
+    updatableScript.setSourceOnRemote(newSource, callback, null);
+  }
+
+
+  private static byte[] readFileContents(IFile file) throws IOException, CoreException {
+    InputStream inputStream = file.getContents();
+    try {
+      return readBytes(inputStream);
+    } finally {
+      inputStream.close();
+    }
+  }
+
+  private static byte[] readBytes(InputStream inputStream) throws IOException {
+    ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+    byte[] array = new byte[1024];
+    while (true) {
+      int len = inputStream.read(array);
+      if (len == -1) {
+        break;
+      }
+      buffer.write(array, 0, len);
+    }
+    return buffer.toByteArray();
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/actions/SynchronizeBreakpoints.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/SynchronizeBreakpoints.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,127 @@
+package org.chromium.debug.ui.actions;
+
+import java.text.MessageFormat;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.chromium.debug.core.ChromiumDebugPlugin;
+import org.chromium.debug.core.model.BreakpointSynchronizer;
+import org.chromium.debug.core.model.DebugTargetImpl;
+import org.chromium.debug.core.model.BreakpointSynchronizer.Direction;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.debug.core.ILaunch;
+import org.eclipse.debug.core.model.IDebugElement;
+import org.eclipse.debug.core.model.IDebugTarget;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.IWorkbenchWindowActionDelegate;
+
+public class SynchronizeBreakpoints implements IWorkbenchWindowActionDelegate {
+
+  public static class ResetRemote extends SynchronizeBreakpoints {
+    public ResetRemote() {
+      super(BreakpointSynchronizer.Direction.RESET_REMOTE);
+    }
+  }
+
+  public static class ResetLocal extends SynchronizeBreakpoints {
+    public ResetLocal() {
+      super(BreakpointSynchronizer.Direction.RESET_LOCAL);
+    }
+  }
+
+  public static class Merge extends SynchronizeBreakpoints {
+    public Merge() {
+      super(BreakpointSynchronizer.Direction.MERGE);
+    }
+  }
+
+  private final BreakpointSynchronizer.Direction direction;
+
+  protected SynchronizeBreakpoints(Direction direction) {
+    this.direction = direction;
+  }
+
+  public void dispose() {
+  }
+
+  public void init(IWorkbenchWindow window) {
+  }
+
+  public void run(IAction action) {
+    if (currentRunnable == null) {
+      return;
+    }
+    currentRunnable.run();
+    currentRunnable = null;
+  }
+
+  public void selectionChanged(IAction action, ISelection selection) {
+    currentRunnable = createRunnable(selection);
+    action.setEnabled(currentRunnable != null);
+  }
+
+  private Runnable createRunnable(ISelection selection) {
+    if (selection instanceof IStructuredSelection == false) {
+      return null;
+    }
+    IStructuredSelection structuredSelection = (IStructuredSelection) selection;
+    final Set<DebugTargetImpl> targets = new HashSet<DebugTargetImpl>(3);
+    for (Iterator<?> it = structuredSelection.iterator(); it.hasNext(); ) {
+      Object element = it.next();
+      IDebugTarget debugTarget;
+      if (element instanceof ILaunch) {
+        ILaunch launch = (ILaunch) element;
+        debugTarget = launch.getDebugTarget();
+      } else if (element instanceof IDebugElement) {
+        IDebugElement debugElement = (IDebugElement) element;
+        debugTarget = debugElement.getDebugTarget();
+      } else {
+        continue;
+      }
+      if (debugTarget instanceof DebugTargetImpl == false) {
+        continue;
+      }
+      DebugTargetImpl debugTargetImpl = (DebugTargetImpl) debugTarget;
+      targets.add(debugTargetImpl);
+    }
+    if (targets.isEmpty()) {
+      return null;
+    }
+    if (direction != BreakpointSynchronizer.Direction.RESET_REMOTE && targets.size() > 1) {
+      // Only "reset remote" mode is implemented for a multiple selection.
+      return null;
+    }
+
+    return new Runnable() {
+      public void run() {
+        new Job(MessageFormat.format(Messages.SynchronizeBreakpoints_JOB_TITLE, targets.size())) {
+          @Override
+          protected IStatus run(IProgressMonitor monitor) {
+            // TODO(peter.rybin): consider blocking this method until callback is invoked to
+            // keep the UI jobs open while something is still happening.
+            BreakpointSynchronizer.Callback callback = new BreakpointSynchronizer.Callback() {
+              public void onDone(IStatus status) {
+                ChromiumDebugPlugin.log(status);
+              }
+            };
+
+            // TODO(peter.rybin): consider showing progress for several targets.
+            for (DebugTargetImpl target : targets) {
+              target.synchronizeBreakpoints(direction, callback);
+            }
+            return Status.OK_STATUS;
+          }
+        }.schedule();
+      }
+    };
+  }
+
+  private Runnable currentRunnable;
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/actions/V8ScriptAction.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/V8ScriptAction.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,193 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.ui.actions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.chromium.debug.core.model.DebugTargetImpl;
+import org.chromium.debug.core.model.VmResource;
+import org.chromium.debug.core.util.ChromiumDebugPluginUtil;
+import org.chromium.sdk.JavascriptVm;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceVisitor;
+import org.eclipse.core.resources.mapping.ResourceMapping;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.ui.IActionDelegate2;
+import org.eclipse.ui.IObjectActionDelegate;
+import org.eclipse.ui.IWorkbenchPart;
+
+/**
+ * A base class for all LiveEdit actions that are scoped to a working file from user workspace.
+ * It makes all necessary checks and prepares data in form of {@link FilePair} class.
+ * The concrete actions implement the {@link #execute(FilePair)} method.
+ */
+abstract class V8ScriptAction implements IObjectActionDelegate, IActionDelegate2 {
+  private Runnable currentRunnable = null;
+
+  public void setActivePart(IAction action, IWorkbenchPart targetPart) {
+  }
+
+  public void run(IAction action) {
+    if (currentRunnable == null) {
+      return;
+    }
+    currentRunnable.run();
+    currentRunnable = null;
+  }
+
+  public void selectionChanged(IAction action, ISelection selection) {
+    currentRunnable = createRunnable(selection);
+    action.setEnabled(currentRunnable != null);
+  }
+
+  private Runnable createRunnable(ISelection selection) {
+    if (selection instanceof IStructuredSelection == false) {
+      return null;
+    }
+    IStructuredSelection structured = (IStructuredSelection) selection;
+    if (structured.size() != 1) {
+      return null;
+    }
+
+    Object firstElement = structured.getFirstElement();
+    if (firstElement instanceof ResourceMapping == false) {
+      return null;
+    }
+    ResourceMapping resourceMapping = (ResourceMapping) firstElement;
+    final List<IResource> resourceList = new ArrayList<IResource>(1);
+    IResourceVisitor visitor = new IResourceVisitor() {
+      public boolean visit(IResource resource) throws CoreException {
+        resourceList.add(resource);
+        return false;
+      }
+    };
+    try {
+      resourceMapping.accept(null, visitor, null);
+    } catch (CoreException e) {
+      throw new RuntimeException(e);
+    }
+    if (resourceList.size() != 1) {
+      return null;
+    }
+    if (resourceList.get(0) instanceof IFile == false) {
+      return null;
+    }
+    final IFile file = (IFile) resourceList.get(0);
+    if (!filterFileName(file.getName())) {
+      return null;
+    }
+    return new Runnable() {
+      public void run() {
+        try {
+          execute(file);
+        } catch (RuntimeException e) {
+          // TODO(peter.rybin): Handle it.
+          throw e;
+        }
+      }
+    };
+  }
+
+  private void execute(IFile file) {
+    List<? extends FilePair> filePairList = getFilePairs(file);
+    FilePair filePair = getSingleFilePair(filePairList);
+    execute(filePair);
+  }
+
+  protected abstract void execute(FilePair filePair);
+
+  /**
+   * A temporary method that excludes all cases when there are more than one file pair for a
+   * user file. The proper solution ought to provide a UI for user so that he could review
+   * which debug sessions should be included in action.
+   */
+  private static FilePair getSingleFilePair(List<? extends FilePair> pairs) {
+    if (pairs.size() == 0) {
+      throw new RuntimeException("File is not associated with any V8 VM");
+    }
+    if (pairs.size() != 1) {
+      throw new RuntimeException(
+          "File is associated with several V8 VMs, this is not supported yet.");
+    }
+    return pairs.get(0);
+  }
+
+  /**
+   * Finds all file pairs for a user working file. One working file may correspond to several
+   * scripts if there are more than one debug sessions.
+   */
+  private static List<? extends FilePair> getFilePairs(IFile localFile) {
+    List<DebugTargetImpl> targetList = DebugTargetImpl.getAllDebugTargetImpls();
+    ArrayList<FilePair> result = new ArrayList<FilePair>(targetList.size());
+
+    for (DebugTargetImpl target : targetList) {
+      VmResource script;
+      try {
+        script = target.getVmResource(localFile);
+      } catch (CoreException e) {
+        throw new RuntimeException("Failed to resolve script from the file " + localFile, e);
+      }
+      if (script == null) {
+        continue;
+      }
+      result.add(new FilePair(localFile, script, target));
+    }
+    return result;
+  }
+
+  protected static class FilePair {
+    private final IFile file;
+    private final VmResource vmResource;
+    private final DebugTargetImpl debugTargetImpl;
+
+    FilePair(IFile file, VmResource vmResource, DebugTargetImpl debugTargetImpl) {
+      this.file = file;
+      this.vmResource = vmResource;
+      this.debugTargetImpl = debugTargetImpl;
+    }
+    protected IFile getFile() {
+      return file;
+    }
+    protected VmResource getVmResource() {
+      return vmResource;
+    }
+    protected JavascriptVm getJavascriptVm() {
+      return debugTargetImpl.getJavascriptEmbedder().getJavascriptVm();
+    }
+    protected DebugTargetImpl getDebugTarget() {
+      return debugTargetImpl;
+    }
+  }
+
+  /**
+   * @return true if action should be enabled for this file name
+   */
+  private boolean filterFileName(String name) {
+    for (String suffix : ChromiumDebugPluginUtil.SUPPORTED_EXTENSIONS_SUFFIX_LIST) {
+      if (name.endsWith(suffix)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public void dispose() {
+    currentRunnable = null;
+  }
+
+  public void init(IAction action) {
+  }
+
+  public void runWithEvent(IAction action, Event event) {
+    run(action);
+  }
+}
+
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/actions/messages.properties
--- a/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/messages.properties	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/actions/messages.properties	Tue Jun 08 16:12:51 2010 -0700
@@ -5,3 +5,4 @@
 ExpressionEvaluator_SocketError=Socket error while evaluating expression
 ExpressionEvaluator_UnableToEvaluateExpression=Unable to evaluate expression
 JsBreakpointPropertiesRulerAction_ItemLabel=Breakpoint Properties...
+SynchronizeBreakpoints_JOB_TITLE=Synchronize breakpoints in {0} target(s)
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/editors/JsDocumentProvider.java
--- a/org.chromium.debug.ui/src/org/chromium/debug/ui/editors/JsDocumentProvider.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/editors/JsDocumentProvider.java	Tue Jun 08 16:12:51 2010 -0700
@@ -4,10 +4,12 @@
 
 package org.chromium.debug.ui.editors;
 
+import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.IDocumentPartitioner;
 import org.eclipse.jface.text.rules.FastPartitioner;
+import org.eclipse.ui.IFileEditorInput;
 import org.eclipse.ui.editors.text.FileDocumentProvider;
 
 /**
@@ -27,4 +29,22 @@
     return doc;
   }
 
+  /**
+   * Alternative implementation of the method that does not require file to be a physical file.
+   */
+  @Override
+  public boolean isDeleted(Object element) {
+    if (element instanceof IFileEditorInput) {
+      IFileEditorInput input= (IFileEditorInput) element;
+
+      IProject project = input.getFile().getProject();
+      if (project != null && !project.exists()) {
+        return true;
+      }
+
+      return !input.getFile().exists();
+    }
+    return super.isDeleted(element);
+  }
+
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/launcher/LaunchTabGroup.java
--- a/org.chromium.debug.ui/src/org/chromium/debug/ui/launcher/LaunchTabGroup.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/launcher/LaunchTabGroup.java	Tue Jun 08 16:12:51 2010 -0700
@@ -8,6 +8,7 @@
 import org.eclipse.debug.ui.CommonTab;
 import org.eclipse.debug.ui.ILaunchConfigurationDialog;
 import org.eclipse.debug.ui.ILaunchConfigurationTab;
+import org.eclipse.debug.ui.sourcelookup.SourceLookupTab;
 
 /**
  * The Chromium JavaScript debugger launch configuration tab group.
@@ -20,7 +21,8 @@
   }
 
   public void createTabs(ILaunchConfigurationDialog dialog, String mode) {
-    setTabs(new ILaunchConfigurationTab[] { new ChromiumRemoteTab(), new CommonTab() });
+    setTabs(new ILaunchConfigurationTab[] { new ChromiumRemoteTab(),
+        new SourceLookupTab(), new CommonTab() });
   }
 
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/source/Messages.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/source/Messages.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,30 @@
+package org.chromium.debug.ui.source;
+
+import org.eclipse.osgi.util.NLS;
+
+public class Messages extends NLS {
+  private static final String BUNDLE_NAME = "org.chromium.debug.ui.source.messages"; //$NON-NLS-1$
+  public static String SourceNameMapperContainerDialog_CONFIGURE_BUTTON;
+  public static String SourceNameMapperContainerDialog_CONFIGURE_TARGET_CONTAINER;
+  public static String SourceNameMapperContainerDialog_CONFIGURED_CONTAINER;
+  public static String SourceNameMapperContainerDialog_CONTAINER_GROUP;
+  public static String SourceNameMapperContainerDialog_DIALOG_SUBTITLE;
+  public static String SourceNameMapperContainerDialog_DIALOG_TITLE;
+  public static String SourceNameMapperContainerDialog_ENTER_PREFIX;
+  public static String SourceNameMapperContainerDialog_EXAMPLE_1;
+  public static String SourceNameMapperContainerDialog_EXAMPLE_2;
+  public static String SourceNameMapperContainerDialog_EXPLANATION_1;
+  public static String SourceNameMapperContainerDialog_EXPLANATION_2;
+  public static String SourceNameMapperContainerDialog_NOTHING_CONFIGURED;
+  public static String SourceNameMapperContainerDialog_PREFIX_GROUP;
+  public static String SourceNameMapperContainerDialog_PREFIX_NORMALLY_ENDS;
+  public static String SourceNameMapperContainerDialog_SAMPLE_FILE_NAME;
+  public static String SourceNameMapperContainerDialog_TYPE_LABEL;
+  static {
+    // initialize resource bundle
+    NLS.initializeMessages(BUNDLE_NAME, Messages.class);
+  }
+
+  private Messages() {
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/source/SourceNameMapperContainerDialog.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/source/SourceNameMapperContainerDialog.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,316 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.ui.source;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.chromium.debug.ui.DialogUtils.ComboWrapper;
+import org.chromium.debug.ui.DialogUtils.DialogElements;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
+import org.eclipse.debug.core.sourcelookup.ISourceContainerType;
+import org.eclipse.debug.core.sourcelookup.ISourceLookupDirector;
+import org.eclipse.debug.ui.DebugUITools;
+import org.eclipse.debug.ui.sourcelookup.ISourceContainerBrowser;
+import org.eclipse.jface.dialogs.Dialog;
+import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jface.dialogs.TitleAreaDialog;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.swt.widgets.Text;
+
+/**
+ * A dialog for adding and editing JavaScript source name mapper containers.
+ */
+public class SourceNameMapperContainerDialog extends TitleAreaDialog {
+  private final ISourceLookupDirector director;
+  private final PresetFieldValues initialParams;
+
+  private Result result = null;
+  private SourceNameMapperContainerDialogLogic logic = null;
+
+  /**
+   * An optional set of preset dialog field values. Useful in "edit" (not "add") mode of dialog.
+   */
+  public interface PresetFieldValues {
+    String getPrefix();
+    ISourceContainer getContainer();
+  }
+
+  public interface Result {
+    String getResultPrefix();
+    ISourceContainer getResultContainer();
+  }
+
+  public Result getResult() {
+    return result;
+  }
+
+  public SourceNameMapperContainerDialog(Shell shell, ISourceLookupDirector director,
+    PresetFieldValues initialParams) {
+    super(shell);
+    setShellStyle(getShellStyle() | SWT.RESIZE);
+    this.director = director;
+    this.initialParams = initialParams;
+  }
+
+  @Override
+  protected Control createDialogArea(Composite ancestor) {
+    getShell().setText(Messages.SourceNameMapperContainerDialog_DIALOG_TITLE);
+    setTitle(Messages.SourceNameMapperContainerDialog_DIALOG_SUBTITLE);
+
+    Composite parent = new Composite(ancestor, SWT.NULL);
+    {
+      GridLayout topLayout = new GridLayout();
+      topLayout.numColumns = 1;
+      parent.setLayout(topLayout);
+      parent.setLayoutData(new GridData(GridData.FILL_BOTH));
+    }
+
+    Label explanationOne = new Label(parent, 0);
+    explanationOne.setText(
+        Messages.SourceNameMapperContainerDialog_EXPLANATION_1);
+
+    Group prefixGroup = new Group(parent, SWT.NONE);
+    prefixGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+    prefixGroup.setText(Messages.SourceNameMapperContainerDialog_PREFIX_GROUP);
+    prefixGroup.setLayout(new GridLayout(1, false));
+    final Text prefixEditor = new Text(prefixGroup, SWT.SINGLE | SWT.BORDER);
+    prefixEditor.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+    final Label prefixExampleLine1Label = new Label(prefixGroup, 0);
+    prefixExampleLine1Label.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+    final Label prefixExampleLine2Label = new Label(prefixGroup, 0);
+    prefixExampleLine2Label.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+
+    Label explanationTwo = new Label(parent, 0);
+    explanationTwo.setText(Messages.SourceNameMapperContainerDialog_EXPLANATION_2);
+
+    Group containerGroup = new Group(parent, SWT.NONE);
+    containerGroup.setLayout(new GridLayout(1, false));
+    containerGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+    containerGroup.setText(Messages.SourceNameMapperContainerDialog_CONTAINER_GROUP);
+
+    Composite typeBlock = new Composite(containerGroup, SWT.NULL);
+    typeBlock.setLayout(new GridLayout(3, false));
+    typeBlock.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+
+    final List<ISourceContainerType> types =
+        filterTypes(DebugPlugin.getDefault().getLaunchManager().getSourceContainerTypes());
+
+    Collections.sort(types, TYPE_COMPARATOR_BY_NAME);
+
+    String[] typeNameArray = new String[types.size()];
+    for (int i = 0; i < typeNameArray.length; i++) {
+      typeNameArray[i] = types.get(i).getName();
+    }
+
+    Label comboLabel = new Label(typeBlock, 0);
+    comboLabel.setText(Messages.SourceNameMapperContainerDialog_TYPE_LABEL);
+
+    Combo typesCombo = new Combo(typeBlock, SWT.READ_ONLY);
+    typesCombo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+    typesCombo.setFont(parent.getFont());
+    typesCombo.setItems(typeNameArray);
+    if (typeNameArray.length > 0) {
+      typesCombo.select(0);
+    }
+    final Button configureButton = new Button(typeBlock, SWT.PUSH);
+    configureButton.setText(Messages.SourceNameMapperContainerDialog_CONFIGURE_BUTTON);
+
+    final Composite statusBox = new Composite(containerGroup, SWT.NULL);
+    statusBox.setLayout(new GridLayout(3, false));
+    statusBox.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+
+    final Label statusLabel = new Label(statusBox, 0);
+    final Label containerTypeIconLabel = new Label(statusBox, 0);
+    final Label containerNameLabel = new Label(statusBox, 0);
+
+    Dialog.applyDialogFont(parent);
+
+    // Implementing Elements interface
+    final ComboWrapper<ISourceContainerType> comboWrapper =
+        new ComboWrapper<ISourceContainerType>(typesCombo) {
+      @Override
+      public ISourceContainerType getSelected() {
+        return types.get(getCombo().getSelectionIndex());
+      }
+      @Override
+      public void setSelected(ISourceContainerType element) {
+        int index = types.indexOf(element);
+        if (index != -1) {
+          getCombo().select(index);
+        }
+      }
+    };
+
+    final ContainerStatusGroup containerStatusGroup = new ContainerStatusGroup() {
+      public Label getStatusLabel() {
+        return statusLabel;
+      }
+      public Label getTypeImageLabel() {
+        return containerTypeIconLabel;
+      }
+      public Label getContainerNameLabel() {
+        return containerNameLabel;
+      }
+      public void layout() {
+        statusBox.layout();
+      }
+      public void setEnabled(boolean enabled) {
+        statusLabel.setEnabled(enabled);
+        containerTypeIconLabel.setEnabled(enabled);
+        containerNameLabel.setEnabled(enabled);
+      }
+    };
+
+    Elements elements = new Elements() {
+      public Text getPrefixField() {
+        return prefixEditor;
+      }
+      public Label getPrefixExampleLine1Label() {
+        return prefixExampleLine1Label;
+      }
+      public Label getPrefixExampleLine2Label() {
+        return prefixExampleLine2Label;
+      }
+      public Button getConfigureButton() {
+        return configureButton;
+      }
+      public ComboWrapper<ISourceContainerType> getContainerTypeCombo() {
+        return comboWrapper;
+      }
+      public Shell getShell() {
+        return SourceNameMapperContainerDialog.this.getShell();
+      }
+      public ContainerStatusGroup getContainerStatusGroup() {
+        return containerStatusGroup;
+      }
+      public Button getOkButton() {
+        return SourceNameMapperContainerDialog.this.getButton(IDialogConstants.OK_ID);
+      }
+      public void setMessage(String message, int type) {
+        SourceNameMapperContainerDialog.this.setMessage(message, type);
+      }
+    };
+
+    logic = SourceNameMapperContainerDialogLogic.create(elements, director, initialParams);
+
+    return parent;
+  }
+
+  @Override
+  public void create() {
+    super.create();
+    logic.updateAll();
+  }
+
+  @Override
+  protected void okPressed() {
+    result = logic.getResult();
+    super.okPressed();
+  }
+
+  /**
+   * A main interface to dialog elements, that are used from logic engine.
+   */
+  interface Elements extends DialogElements {
+    Text getPrefixField();
+    Label getPrefixExampleLine1Label();
+    Label getPrefixExampleLine2Label();
+    ComboWrapper<ISourceContainerType> getContainerTypeCombo();
+    Button getConfigureButton();
+    ContainerStatusGroup getContainerStatusGroup();
+  }
+
+  interface ContainerStatusGroup {
+    Label getStatusLabel();
+    Label getTypeImageLabel();
+    Label getContainerNameLabel();
+    void layout();
+    void setEnabled(boolean enabled);
+  }
+
+  interface ConfigureButtonAction {
+    ISourceContainer run(Shell shell);
+  }
+
+  // Creates action implementation for a configure button or return null.
+  static ConfigureButtonAction prepareConfigureAction(ISourceContainerType type,
+      ISourceContainer alreadyCreatedContainer,
+      final ISourceLookupDirector director) {
+    if (type == null) {
+      return null;
+    }
+    final ISourceContainerBrowser browser = DebugUITools.getSourceContainerBrowser(type.getId());
+    if (browser == null) {
+      return null;
+    }
+    abstract class ActionBase implements ConfigureButtonAction {
+      public ISourceContainer run(Shell shell) {
+        ISourceContainer[] containers = runImpl(shell);
+        if (containers.length != 1) {
+          return null;
+        }
+        return containers[0];
+      }
+      abstract ISourceContainer[] runImpl(Shell shell);
+    }
+    ISourceContainer[] containers;
+    if (alreadyCreatedContainer != null && alreadyCreatedContainer.getType().equals(type)) {
+      // Edit existing.
+      final ISourceContainer[] alreadyCreatedContainerArray = { alreadyCreatedContainer };
+      if (browser.canEditSourceContainers(director, alreadyCreatedContainerArray)) {
+        return new ActionBase() {
+          @Override ISourceContainer[] runImpl(Shell shell) {
+            return browser.editSourceContainers(shell, director, alreadyCreatedContainerArray);
+          }
+        };
+      }
+    }
+    // Add new.
+    if (browser.canAddSourceContainers(director)) {
+      return new ActionBase() {
+        @Override ISourceContainer[] runImpl(Shell shell) {
+          return browser.addSourceContainers(shell, director);
+        }
+      };
+    }
+    return null;
+  }
+
+  private static final Comparator<ISourceContainerType> TYPE_COMPARATOR_BY_NAME =
+      new Comparator<ISourceContainerType>() {
+    public int compare(ISourceContainerType o1, ISourceContainerType o2) {
+      return o1.getName().compareTo(o2.getName());
+    }
+  };
+
+  private List<ISourceContainerType> filterTypes(ISourceContainerType[] types){
+    ArrayList<ISourceContainerType> result = new ArrayList<ISourceContainerType>();
+    for (int i = 0; i< types.length; i++) {
+      ISourceContainerType type = types[i];
+      if (director.supportsSourceContainerType(type)) {
+        ISourceContainerBrowser sourceContainerBrowser =
+            DebugUITools.getSourceContainerBrowser(type.getId());
+        if(sourceContainerBrowser != null &&
+            sourceContainerBrowser.canAddSourceContainers(director)) {
+          result.add(type);
+        }
+      }
+    }
+    return result;
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/source/SourceNameMapperContainerDialogLogic.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/source/SourceNameMapperContainerDialogLogic.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,272 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.ui.source;
+
+import static org.chromium.debug.ui.DialogUtils.createErrorOptional;
+import static org.chromium.debug.ui.DialogUtils.createOptional;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.chromium.debug.ui.DialogUtils.ExpressionProcessor;
+import org.chromium.debug.ui.DialogUtils.Message;
+import org.chromium.debug.ui.DialogUtils.MessagePriority;
+import org.chromium.debug.ui.DialogUtils.OkButtonControl;
+import org.chromium.debug.ui.DialogUtils.Optional;
+import org.chromium.debug.ui.DialogUtils.Updater;
+import org.chromium.debug.ui.DialogUtils.ValueConsumer;
+import org.chromium.debug.ui.DialogUtils.ValueProcessor;
+import org.chromium.debug.ui.DialogUtils.ValueSource;
+import org.chromium.debug.ui.source.SourceNameMapperContainerDialog.ConfigureButtonAction;
+import org.chromium.debug.ui.source.SourceNameMapperContainerDialog.ContainerStatusGroup;
+import org.chromium.debug.ui.source.SourceNameMapperContainerDialog.Elements;
+import org.chromium.debug.ui.source.SourceNameMapperContainerDialog.PresetFieldValues;
+import org.chromium.debug.ui.source.SourceNameMapperContainerDialog.Result;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
+import org.eclipse.debug.core.sourcelookup.ISourceContainerType;
+import org.eclipse.debug.core.sourcelookup.ISourceLookupDirector;
+import org.eclipse.debug.ui.DebugUITools;
+import org.eclipse.osgi.util.NLS;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.graphics.Image;
+
+/**
+ * A separated logic of {@link SourceNameMapperContainerDialog}. It describes how data flows
+ * from input elements to the OK button with all necessary asserts. Basically it only uses
+ * {@link SourceNameMapperContainerDialog.Elements} interface from the dialog.
+ */
+abstract class SourceNameMapperContainerDialogLogic {
+  abstract Result getResult();
+  abstract void updateAll();
+
+  static SourceNameMapperContainerDialogLogic create(
+      final Elements elements, final ISourceLookupDirector director,
+      final PresetFieldValues initialParams) {
+    final Updater updater = new Updater();
+
+    final List<ValueSource<String>> warningSources = new ArrayList<ValueSource<String>>(2);
+
+    // Represents value entered as prefix.
+    final ValueSource<String> prefixEditor = new ValueSource<String>() {
+      public String getValue() {
+        return elements.getPrefixField().getText();
+      }
+      {
+        if (initialParams != null) {
+          elements.getPrefixField().setText(initialParams.getPrefix());
+        }
+        final ValueSource<String> updatableThis = this;
+        ModifyListener listener = new ModifyListener() {
+          public void modifyText(ModifyEvent e) {
+            updater.reportChanged(updatableThis);
+            updater.update();
+          }
+        };
+        elements.getPrefixField().addModifyListener(listener);
+      }
+    };
+
+    // Represents prefix value after it has been validated.
+    final ValueProcessor<Optional<String>> prefixValue = new ExpressionProcessor<String>(
+        Collections.<ValueSource<? extends Optional<?>>>emptyList()) {
+      @Override
+      protected Optional<String> calculateNormal() {
+        String prefix = prefixEditor.getValue();
+        Optional<String> result;
+        if (prefix == null || prefix.length() == 0) {
+          return createErrorOptional(new Message(
+              Messages.SourceNameMapperContainerDialog_ENTER_PREFIX,
+              MessagePriority.BLOCKING_INFO));
+        } else {
+          return createOptional(prefix);
+        }
+      }
+    };
+    updater.addConsumer(prefixValue, prefixEditor);
+
+    // Represents possible warning about prefix value having no trailing slash.
+    ValueProcessor<String> noSlashWarning = new ValueProcessor<String>() {
+      public void update(Updater updater) {
+        Optional<String> prefix = prefixValue.getValue();
+        String result;
+        if (prefix.isNormal() && !prefix.getNormal().endsWith("/")) { //$NON-NLS-1$
+          result = Messages.SourceNameMapperContainerDialog_PREFIX_NORMALLY_ENDS;
+        } else {
+          result = null;
+        }
+        setCurrentValue(result);
+        updater.reportChanged(this);
+      }
+    };
+    updater.addConsumer(noSlashWarning, prefixValue);
+    warningSources.add(noSlashWarning);
+
+    // Represents prefix rule example printer.
+    ValueConsumer prefixExample = new ValueConsumer() {
+      public void update(Updater updater) {
+        Optional<String> prefix = prefixValue.getValue();
+        String line1;
+        String line2;
+        if (prefix.isNormal()) {
+          String sampleFileName = Messages.SourceNameMapperContainerDialog_SAMPLE_FILE_NAME;
+          line1 = NLS.bind(Messages.SourceNameMapperContainerDialog_EXAMPLE_1,
+              prefix.getNormal() + sampleFileName);
+          line2 = NLS.bind(Messages.SourceNameMapperContainerDialog_EXAMPLE_2, sampleFileName);
+        } else {
+          line1 = ""; //$NON-NLS-1$
+          line2 = ""; //$NON-NLS-1$
+        }
+        elements.getPrefixExampleLine1Label().setText(line1);
+        elements.getPrefixExampleLine2Label().setText(line2);
+      }
+    };
+    updater.addConsumer(prefixExample, prefixValue);
+
+    // Represents container type combo box.
+    final ValueSource<ISourceContainerType> selectedTypeValue =
+        new ValueSource<ISourceContainerType>() {
+      public ISourceContainerType getValue() {
+        return elements.getContainerTypeCombo().getSelected();
+      }
+      {
+        if (initialParams != null) {
+          ISourceContainerType type = initialParams.getContainer().getType();
+          elements.getContainerTypeCombo().setSelected(type);
+        }
+        final ValueSource<ISourceContainerType> updatableThis = this;
+        SelectionListener listener = new SelectionAdapter() {
+          @Override
+          public void widgetSelected(SelectionEvent e) {
+            updater.reportChanged(updatableThis);
+            updater.update();
+          }
+        };
+        elements.getContainerTypeCombo().addSelectionListener(listener);
+      }
+    };
+
+    // Represents "Configure" button that acts like a container factory.
+    final ValueProcessor<ISourceContainer> containerFactoryButtonValue =
+        new ValueProcessor<ISourceContainer>() {
+      private ConfigureButtonAction preparedAction = null;
+      {
+        if (initialParams != null) {
+          setCurrentValue(initialParams.getContainer());
+        }
+        final ValueSource<ISourceContainer> valueSourceThis = this;
+        elements.getConfigureButton().addSelectionListener(new SelectionAdapter() {
+          @Override
+          public void widgetSelected(SelectionEvent e) {
+            if (preparedAction != null) {
+              ISourceContainer value = preparedAction.run(elements.getShell());
+              if (value != null) {
+                setCurrentValue(value);
+              }
+              updater.reportChanged(valueSourceThis);
+              updater.update();
+              updateAction();
+            }
+          }
+        });
+      }
+      public void update(Updater updater) {
+        if (getValue() != null && !getValue().getType().equals(selectedTypeValue.getValue())) {
+          setCurrentValue(null);
+          updater.reportChanged(this);
+        }
+        updateAction();
+      }
+      private void updateAction() {
+        preparedAction = SourceNameMapperContainerDialog.prepareConfigureAction(
+            selectedTypeValue.getValue(), getValue(), director);
+        elements.getConfigureButton().setEnabled(preparedAction != null);
+      }
+    };
+    updater.addConsumer(containerFactoryButtonValue, selectedTypeValue);
+
+    // Represents printer that shows type and name of the created container.
+    ValueConsumer showContainerTypeValue = new ValueConsumer() {
+      public void update(Updater updater) {
+        ISourceContainer container = containerFactoryButtonValue.getValue();
+        String status;
+        Image image;
+        String name;
+        boolean enabled;
+        if (container == null) {
+          status = Messages.SourceNameMapperContainerDialog_NOTHING_CONFIGURED;
+          name = ""; //$NON-NLS-1$
+          image = null;
+          enabled = false;
+        } else {
+          status = Messages.SourceNameMapperContainerDialog_CONFIGURED_CONTAINER;
+          ISourceContainerType type = container.getType();
+          name = container.getName();
+          image = DebugUITools.getSourceContainerImage(type.getId());
+          enabled = true;
+        }
+        ContainerStatusGroup group = elements.getContainerStatusGroup();
+        group.getStatusLabel().setText(status);
+        group.getTypeImageLabel().setImage(image);
+        group.getContainerNameLabel().setText(name);
+        group.setEnabled(enabled);
+        group.layout();
+      }
+    };
+    updater.addConsumer(showContainerTypeValue, containerFactoryButtonValue);
+
+    // Represents expression that constructs dialog window result.
+    final ValueProcessor<? extends Optional<Result>> resultValue =
+        new ExpressionProcessor<Result>(
+            Arrays.<ValueSource<? extends Optional<?>>>asList(prefixValue) ) {
+          @Override
+          protected Optional<Result> calculateNormal() {
+            final String prefix = prefixValue.getValue().getNormal();
+            final ISourceContainer container = containerFactoryButtonValue.getValue();
+            if (container == null) {
+              return createErrorOptional(
+                  new Message(Messages.SourceNameMapperContainerDialog_CONFIGURE_TARGET_CONTAINER,
+                      MessagePriority.BLOCKING_INFO));
+            }
+            Result result = new Result() {
+              public ISourceContainer getResultContainer() {
+                return container;
+              }
+              public String getResultPrefix() {
+                return prefix;
+              }
+            };
+            return createOptional(result);
+          }
+    };
+    updater.addConsumer(resultValue, prefixValue, containerFactoryButtonValue);
+
+    // Represents controller that updates state of OK button and error messages.
+    OkButtonControl okButtonControl = new OkButtonControl(resultValue, warningSources, elements);
+    updater.addConsumer(okButtonControl, okButtonControl.getDependencies());
+
+    return new SourceNameMapperContainerDialogLogic() {
+      @Override
+      Result getResult() {
+        Optional<Result> optional = resultValue.getValue();
+        if (optional.isNormal()) {
+          return optional.getNormal();
+        } else {
+          // Normally should not be reachable, because UI should have disabled OK button.
+          return null;
+        }
+      }
+      @Override
+      void updateAll() {
+        updater.updateAll();
+      }
+    };
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/source/SourceNameMapperContainerPresentation.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/source/SourceNameMapperContainerPresentation.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,60 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.debug.ui.source;
+
+import org.chromium.debug.core.SourceNameMapperContainer;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
+import org.eclipse.debug.core.sourcelookup.ISourceLookupDirector;
+import org.eclipse.debug.ui.sourcelookup.ISourceContainerBrowser;
+import org.eclipse.swt.widgets.Shell;
+
+/**
+ * A presentation for JavaScript Source Name Mapper container that supports adding and editing.
+ */
+public class SourceNameMapperContainerPresentation implements ISourceContainerBrowser {
+
+  public ISourceContainer[] addSourceContainers(Shell shell, ISourceLookupDirector director) {
+    return openDialog(shell, director, null);
+  }
+
+  public boolean canAddSourceContainers(ISourceLookupDirector director) {
+    return true;
+  }
+
+  public boolean canEditSourceContainers(ISourceLookupDirector director,
+      ISourceContainer[] containers) {
+    return containers.length == 1;
+  }
+
+  public ISourceContainer[] editSourceContainers(Shell shell, ISourceLookupDirector director,
+      ISourceContainer[] containers) {
+    final SourceNameMapperContainer originalContainer = (SourceNameMapperContainer) containers[0];
+    SourceNameMapperContainerDialog.PresetFieldValues params =
+        new SourceNameMapperContainerDialog.PresetFieldValues() {
+      public ISourceContainer getContainer() {
+        return originalContainer.getTargetContainer();
+      }
+      public String getPrefix() {
+        return originalContainer.getPrefix();
+      }
+    };
+
+    return openDialog(shell, director, params);
+  }
+
+  private ISourceContainer[] openDialog(Shell shell, ISourceLookupDirector director,
+      SourceNameMapperContainerDialog.PresetFieldValues params) {
+    SourceNameMapperContainerDialog dialog =
+        new SourceNameMapperContainerDialog(shell, director, params);
+    dialog.open();
+    SourceNameMapperContainerDialog.Result dialogResult = dialog.getResult();
+    if (dialogResult == null) {
+      return new ISourceContainer[0];
+    }
+    ISourceContainer result = new SourceNameMapperContainer(dialogResult.getResultPrefix(),
+        dialogResult.getResultContainer());
+    return new ISourceContainer[] { result };
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.debug.ui/src/org/chromium/debug/ui/source/messages.properties
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.debug.ui/src/org/chromium/debug/ui/source/messages.properties	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,16 @@
+SourceNameMapperContainerDialog_CONFIGURE_BUTTON=Configure ...
+SourceNameMapperContainerDialog_CONFIGURE_TARGET_CONTAINER=Configure target container
+SourceNameMapperContainerDialog_CONFIGURED_CONTAINER=Configured container: 
+SourceNameMapperContainerDialog_CONTAINER_GROUP=Target source container
+SourceNameMapperContainerDialog_DIALOG_SUBTITLE=Configure how source names get translated and applied to target source container
+SourceNameMapperContainerDialog_DIALOG_TITLE=JavaScript Source Name Mapper
+SourceNameMapperContainerDialog_ENTER_PREFIX=Enter prefix
+SourceNameMapperContainerDialog_EXAMPLE_1=E.g.: source name ''{0}''
+SourceNameMapperContainerDialog_EXAMPLE_2=gets converted into ''{0}''
+SourceNameMapperContainerDialog_EXPLANATION_1=All resource names that start with prefix will have this prefix removed...
+SourceNameMapperContainerDialog_EXPLANATION_2=... and the short name will be looked up in source container.
+SourceNameMapperContainerDialog_NOTHING_CONFIGURED=<nothing configured>
+SourceNameMapperContainerDialog_PREFIX_GROUP=Prefix of source name
+SourceNameMapperContainerDialog_PREFIX_NORMALLY_ENDS=Prefix normally ends with '/'
+SourceNameMapperContainerDialog_SAMPLE_FILE_NAME=utils/timer.js
+SourceNameMapperContainerDialog_TYPE_LABEL=Type:
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/Breakpoint.java
--- a/org.chromium.sdk/src/org/chromium/sdk/Breakpoint.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/Breakpoint.java	Tue Jun 08 16:12:51 2010 -0700
@@ -7,7 +7,7 @@
 /**
  * A breakpoint in the browser JavaScript virtual machine. The {@code set*}
  * method invocations will not take effect until
- * {@link #flush(org.chromium.sdk.BrowserTab.BreakpointCallback)} is called.
+ * {@link #flush(org.chromium.sdk.JavascriptVm.BreakpointCallback)} is called.
  */
 public interface Breakpoint {
 
@@ -25,7 +25,7 @@
    *
    * @see #getIgnoreCount()
    * @see #setIgnoreCount(int)
-   * @see BrowserTab#setBreakpoint(Type, String, int, int, boolean, String, int, org.chromium.sdk.BrowserTab.BreakpointCallback)
+   * @see JavascriptVm#setBreakpoint
    */
   int EMPTY_VALUE = -1;
 
@@ -46,6 +46,26 @@
   long getId();
 
   /**
+   * @return scriptName as reported by the JavaScript VM debugger; may be null
+   */
+  String getScriptName();
+
+  /**
+   * @return scriptId as reported by the JavaScript VM debugger; may be null
+   */
+  Long getScriptId();
+
+  /**
+   * Returns line number of the breakpoint. As source is changed (typically with LiveEdit feature,
+   * and particularly by calling {@link UpdatableScript#setSourceOnRemote}) this value
+   * may become stale. It gets updated when {@link JavascriptVm#listBreakpoints} asynchronous
+   * method completes.
+   *
+   * @return 1-based line number in script source
+   */
+  long getLineNumber();
+
+  /**
    * @return whether this breakpoint is enabled
    */
   boolean isEnabled();
@@ -88,7 +108,7 @@
    *
    * @param callback to invoke once the operation result is available
    */
-  void clear(BrowserTab.BreakpointCallback callback);
+  void clear(JavascriptVm.BreakpointCallback callback, SyncCallback syncCallback);
 
   /**
    * Flushes the breakpoint parameter changes (set* methods) into the browser
@@ -97,5 +117,5 @@
    *
    * @param callback to invoke once the operation result is available
    */
-  void flush(BrowserTab.BreakpointCallback callback);
+  void flush(JavascriptVm.BreakpointCallback callback, SyncCallback syncCallback);
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/CallFrame.java
--- a/org.chromium.sdk/src/org/chromium/sdk/CallFrame.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/CallFrame.java	Tue Jun 08 16:12:51 2010 -0700
@@ -32,6 +32,7 @@
   /**
    * @return the current line number in the Script corresponding to this frame
    *         (0-based) or {@code -1} if unknown
+   * TODO(peter.rybin): consider returning absolute line number here, not in-script number.
    */
   int getLineNumber();
 
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/JavascriptVm.java
--- a/org.chromium.sdk/src/org/chromium/sdk/JavascriptVm.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/JavascriptVm.java	Tue Jun 08 16:12:51 2010 -0700
@@ -98,7 +98,7 @@
    *        may be {@code null}
    */
   void setBreakpoint(Breakpoint.Type type, String target, int line, int position, boolean enabled,
-      String condition, int ignoreCount, BreakpointCallback callback);
+      String condition, int ignoreCount, BreakpointCallback callback, SyncCallback syncCallback);
 
   /**
    * Tries to suspend VM. If successful, {@link DebugEventListener#suspended(DebugContext)}
@@ -107,4 +107,15 @@
    *        may be {@code null}
    */
   void suspend(SuspendCallback callback);
+
+  interface ListBreakpointsCallback {
+    void success(Collection<? extends Breakpoint> breakpoints);
+    void failure(Exception exception);
+  }
+
+  /**
+   * Asynchronously reads breakpoints from remote VM. The now-effective collection of breakpoints
+   * is returned to callback. Already existing {@link Breakpoint} instances are preserved.
+   */
+  void listBreakpoints(ListBreakpointsCallback callback, SyncCallback syncCallback);
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/LiveEditDebugEventListener.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.sdk/src/org/chromium/sdk/LiveEditDebugEventListener.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,16 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.sdk;
+
+/**
+ * An optional extension of {@link DebugEventListener} that supports experimental LiveEdit-related
+ * events.
+ */
+public interface LiveEditDebugEventListener extends DebugEventListener {
+  /**
+   * Reports that script source has been altered in remote VM.
+   */
+  void scriptContentChanged(UpdatableScript newScript);
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/LiveEditExtension.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.sdk/src/org/chromium/sdk/LiveEditExtension.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,38 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.sdk;
+
+/**
+ * Helper class for experimental support of LiveEdit feature. While regular API does not
+ * support LiveEdit (not to break compatibility with existing clients), it gives access to extended
+ * interfaces.
+ * <p>
+ * This class encapsulates all instanceofs/casts that are considered to be untrackable
+ * in the main code and therefore harmful.
+ */
+public class LiveEditExtension {
+  /**
+   * Casts script to the interface that supports updating source on remote VM.
+   * @return extended interface or null if unsupported
+   */
+  public static UpdatableScript castToUpdatableScript(Script script) {
+    if (script instanceof UpdatableScript == false) {
+      return null;
+    }
+    return (UpdatableScript) script;
+  }
+
+  /**
+   * Casts listener to interface that accepts LiveEdit-related events.
+   * @return extended interface or null if unsupported
+   */
+  public static LiveEditDebugEventListener castToLiveEditListener(
+      DebugEventListener debugEventListener) {
+    if (debugEventListener instanceof LiveEditDebugEventListener == false) {
+      return null;
+    }
+    return (LiveEditDebugEventListener) debugEventListener;
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/Script.java
--- a/org.chromium.sdk/src/org/chromium/sdk/Script.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/Script.java	Tue Jun 08 16:12:51 2010 -0700
@@ -44,11 +44,17 @@
 
   /**
    * @return the start line of this script in the original document
-   *         (zero-based), inclusive
+   *         (zero-based)
    */
   int getStartLine();
 
   /**
+   * @return the start column of this script in the original document
+   *         (zero-based)
+   */
+  int getStartColumn();
+
+  /**
    * @return the end line of this script in the original document (zero-based),
    *         inclusive
    */
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/UpdatableScript.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.sdk/src/org/chromium/sdk/UpdatableScript.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,27 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.sdk;
+
+/**
+ * This interface is a part of {@link Script} interface. It extends {@link Script} in order
+ * to support experimental feature and is under development.
+ */
+public interface UpdatableScript extends Script {
+  /**
+   * Demands that script text should be replaced with a new one if possible.
+   * @param newSource new text of script
+   */
+  void setSourceOnRemote(String newSource, UpdateCallback callback, SyncCallback syncCallback);
+
+  interface UpdateCallback {
+    /**
+     * Script text has been successfully changed. {@link DebugEventListener#scriptChanged} will
+     * be called additionally. Besides, a current context may be dismissed and recreated after this
+     * event. The order of all listed event notifications is not currently specified.
+     */
+    void success(Object report);
+    void failure(String message);
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/ContextBuilder.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/ContextBuilder.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/ContextBuilder.java	Tue Jun 08 16:12:51 2010 -0700
@@ -237,6 +237,17 @@
       }
     }
 
+    private boolean sendNoMessageAndInvalidate() {
+      synchronized (sendContextCommandsMonitor) {
+        if (!isValid) {
+          return false;
+        }
+        isValid = false;
+        return true;
+      }
+    }
+
+
     private class UserContext implements DebugContext {
       private final DebugContextData data;
 
@@ -266,6 +277,14 @@
         return data.exceptionData;
       }
 
+      Collection<Breakpoint> getBreakpointsHitSafe() {
+        return data.breakpointsHit;
+      }
+
+      ExceptionData getExceptionDataSafe() {
+        return data.exceptionData;
+      }
+
       public JsEvaluateContext getGlobalEvaluateContext() {
         return evaluateContext;
       }
@@ -306,6 +325,19 @@
         sendMessageAsyncAndIvalidate(message, commandCallback, true, null);
       }
 
+      /**
+       * Behaves as continue but does not send any messages to remote VM.
+       * This brings ContextBuilder to state when we are about to build a new context.
+       */
+      boolean continueLocally() {
+        if (!sendNoMessageAndInvalidate()) {
+          return false;
+        }
+        contextDismissed(UserContext.this);
+        getDebugSession().getDebugEventListener().resumed();
+        return true;
+      }
+
       InternalContext getInternalContextForTests() {
         return PreContext.this;
       }
@@ -385,6 +417,24 @@
     }
   }
 
+  /**
+   * Drops the current context and initiates reading data and building a new one.
+   * Must be called from Dispatch thread.
+   * @return ExpectingBacktraceStep or null if there is no active context currently
+   */
+  ExpectingBacktraceStep startRebuildCurrentContext() {
+    // We can use currentStep as long as we are being operated from Dispatch thread.
+    if (currentStep instanceof PreContext.UserContext == false) {
+      return null;
+    }
+    PreContext.UserContext userContext = (PreContext.UserContext) currentStep;
+    if (!userContext.continueLocally()) {
+      return null;
+    }
+    return buildNewContext().setContextState(userContext.getBreakpointsHitSafe(),
+        userContext.getExceptionDataSafe());
+  }
+
   static InternalContext getInternalContextForTests(DebugContext debugContext) {
     PreContext.UserContext userContext = (PreContext.UserContext) debugContext;
     return userContext.getInternalContextForTests();
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/DebugSession.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/DebugSession.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/DebugSession.java	Tue Jun 08 16:12:51 2010 -0700
@@ -10,6 +10,7 @@
 import java.util.List;
 
 import org.chromium.sdk.Breakpoint;
+import org.chromium.sdk.DebugContext;
 import org.chromium.sdk.DebugEventListener;
 import org.chromium.sdk.InvalidContextException;
 import org.chromium.sdk.Script;
@@ -32,7 +33,7 @@
 import org.chromium.sdk.internal.tools.v8.request.DebuggerMessageFactory;
 
 /**
- * A default, thread-safe implementation of the JsDebugContext interface.
+ * A class that holds and administers main parts of debug protocol implementation.
  */
 public class DebugSession {
 
@@ -58,7 +59,7 @@
 
   public DebugSession(DebugSessionManager sessionManager, V8ContextFilter contextFilter,
       V8CommandOutput v8CommandOutput) {
-    this.scriptManager = new ScriptManager(contextFilter);
+    this.scriptManager = new ScriptManager(contextFilter, this);
     this.sessionManager = sessionManager;
     this.breakpointManager = new BreakpointManager(this);
 
@@ -125,6 +126,27 @@
     return contextBuilder;
   }
 
+  /**
+   * Drops current context and creates a new one. This is useful if context is known to have changed
+   * (e.g. experimental feature LiveEdit may change current stack while execution is suspended).
+   * The method is asynchronous and returns immediately.
+   * Does nothing if currently there is no active context. Otherwise dismisses current context,
+   * invokes {@link DebugEventListener#resumed()} and initiates downloading stack frame descriptions
+   * and building new context. When the context is built,
+   * calls {@link DebugEventListener#suspended(DebugContext)}.
+   * <p>
+   * Must be called from Dispatch Thread.
+   * @return true if context has been actually dropped.
+   */
+  public boolean recreateCurrentContext() {
+    ContextBuilder.ExpectingBacktraceStep step = contextBuilder.startRebuildCurrentContext();
+    if (step == null) {
+      return false;
+    }
+    defaultResponseHandler.getBreakpointProcessor().processNextStep(step);
+    return true;
+  }
+
   public void suspend(final SuspendCallback suspendCallback) {
     V8CommandProcessor.V8HandlerCallback v8Callback = new V8CommandCallbackBase() {
       @Override
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/JavascriptVmImpl.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/JavascriptVmImpl.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/JavascriptVmImpl.java	Tue Jun 08 16:12:51 2010 -0700
@@ -9,6 +9,7 @@
 import org.chromium.sdk.Breakpoint;
 import org.chromium.sdk.CallbackSemaphore;
 import org.chromium.sdk.JavascriptVm;
+import org.chromium.sdk.SyncCallback;
 import org.chromium.sdk.internal.tools.v8.MethodIsBlockingException;
 
 /**
@@ -35,9 +36,14 @@
 
   public void setBreakpoint(Breakpoint.Type type, String target, int line,
       int position, boolean enabled, String condition, int ignoreCount,
-      BreakpointCallback callback) {
+      BreakpointCallback callback, SyncCallback syncCallback) {
     getDebugSession().getBreakpointManager()
-        .setBreakpoint(type, target, line, position, enabled, condition, ignoreCount, callback);
+        .setBreakpoint(type, target, line, position, enabled, condition, ignoreCount, callback,
+        syncCallback);
+  }
+
+  public void listBreakpoints(final ListBreakpointsCallback callback, SyncCallback syncCallback) {
+    getDebugSession().getBreakpointManager().reloadBreakpoints(callback, syncCallback);
   }
 
   protected abstract DebugSession getDebugSession();
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/JsObjectImpl.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/JsObjectImpl.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/JsObjectImpl.java	Tue Jun 08 16:12:51 2010 -0700
@@ -167,10 +167,10 @@
     List<JsVariableImpl> getPropertiesLazily() throws MethodIsBlockingException {
       synchronized (this) {
         if (properties == null) {
-
-        List<? extends PropertyReference> propertyRefs = getPropertyRefs(getSubpropertiesMirror());
-        ValueLoader valueLoader = context.getValueLoader();
-        List<ValueMirror> subMirrors = valueLoader.getOrLoadValueFromRefs(propertyRefs);
+          List<? extends PropertyReference> propertyRefs =
+              getPropertyRefs(getSubpropertiesMirror());
+          ValueLoader valueLoader = context.getValueLoader();
+          List<ValueMirror> subMirrors = valueLoader.getOrLoadValueFromRefs(propertyRefs);
 
           List<JsVariableImpl> wrappedProperties = createPropertiesFromMirror(subMirrors,
               propertyRefs);
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/ScriptImpl.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/ScriptImpl.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/ScriptImpl.java	Tue Jun 08 16:12:51 2010 -0700
@@ -4,20 +4,37 @@
 
 package org.chromium.sdk.internal;
 
+import java.util.Collections;
 import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
+import org.chromium.sdk.LiveEditDebugEventListener;
+import org.chromium.sdk.LiveEditExtension;
 import org.chromium.sdk.Script;
+import org.chromium.sdk.SyncCallback;
+import org.chromium.sdk.UpdatableScript;
+import org.chromium.sdk.internal.protocol.ChangeLiveBody;
+import org.chromium.sdk.internal.protocol.SuccessCommandResponse;
 import org.chromium.sdk.internal.protocol.data.ScriptHandle;
 import org.chromium.sdk.internal.protocol.data.SomeHandle;
 import org.chromium.sdk.internal.protocolparser.JsonProtocolParseException;
+import org.chromium.sdk.internal.tools.v8.V8CommandCallbackBase;
+import org.chromium.sdk.internal.tools.v8.V8CommandProcessor;
+import org.chromium.sdk.internal.tools.v8.V8Helper;
 import org.chromium.sdk.internal.tools.v8.V8ProtocolUtil;
+import org.chromium.sdk.internal.tools.v8.V8Helper.ScriptLoadCallback;
+import org.chromium.sdk.internal.tools.v8.request.ChangeLiveMessage;
 
 /**
  * An objects that holds data for a "script" which is a part of a resource
  * loaded into the browser, identified by its original document URL, line offset
  * in the original document, and the line count this script spans.
  */
-public class ScriptImpl implements Script {
+public class ScriptImpl implements Script, UpdatableScript {
+
+  /** The class logger. */
+  private static final Logger LOGGER = Logger.getLogger(ScriptImpl.class.getName());
 
   /**
    * An object containing data that uniquely identify a V8 script chunk.
@@ -29,15 +46,19 @@
 
     public final int lineOffset;
 
+    public final int columnOffset;
+
     public final int endLine;
 
     public final long id;
 
-    public Descriptor(Type type, long id, String name, int lineOffset, int lineCount) {
+    public Descriptor(Type type, long id, String name, int lineOffset, int columnOffset,
+        int lineCount) {
       this.type = type;
       this.id = id;
       this.name = name;
       this.lineOffset = lineOffset;
+      this.columnOffset = columnOffset;
       this.endLine = lineOffset + lineCount - 1;
     }
 
@@ -45,8 +66,8 @@
     public int hashCode() {
       return
           name != null ? name.hashCode() : (int) id * 0x101 +
-          lineOffset * 0x1001 +
-          endLine * 0x10001;
+          lineOffset * 0x1001 + columnOffset * 0x10001 +
+          endLine * 0x100001;
     }
 
     @Override
@@ -61,6 +82,7 @@
       // The id equality is stronger than the name equality.
       return this.id == that.id &&
           this.lineOffset == that.lineOffset &&
+          this.columnOffset == that.columnOffset &&
           this.endLine == that.endLine;
     }
 
@@ -78,9 +100,10 @@
           return null;
         }
         int lineOffset = (int) script.lineOffset();
+        int columnOffset = (int) script.columnOffset();
         int lineCount = (int) script.lineCount();
         int id = V8ProtocolUtil.getScriptIdFromResponse(script).intValue();
-        return new Descriptor(type, id, name, lineOffset, lineCount);
+        return new Descriptor(type, id, name, lineOffset, columnOffset, lineCount);
       } catch (Exception e) {
         // not a script object has been passed in
         return null;
@@ -92,12 +115,15 @@
 
   private volatile String source = null;
 
+  private final DebugSession debugSession;
+
   /**
    * @param descriptor of the script retrieved from a "scripts" response
    */
-  public ScriptImpl(Descriptor descriptor) {
+  public ScriptImpl(Descriptor descriptor, DebugSession debugSession) {
     this.descriptor = descriptor;
     this.source = null;
+    this.debugSession = debugSession;
   }
 
   public Type getType() {
@@ -112,6 +138,10 @@
     return descriptor.lineOffset;
   }
 
+  public int getStartColumn() {
+    return descriptor.columnOffset;
+  }
+
   public int getEndLine() {
     return descriptor.endLine;
   }
@@ -132,6 +162,56 @@
     this.source = source;
   }
 
+  public void setSourceOnRemote(String newSource, UpdateCallback callback,
+      SyncCallback syncCallback) {
+    V8CommandProcessor.V8HandlerCallback v8Callback = createScriptUpdateCallback(callback);
+    debugSession.sendMessageAsync(new ChangeLiveMessage(getId(), newSource),
+        true, v8Callback, syncCallback);
+  }
+
+  private V8CommandProcessor.V8HandlerCallback createScriptUpdateCallback(
+      final UpdateCallback callback) {
+    if (callback == null) {
+      return null;
+    }
+    return new V8CommandCallbackBase() {
+      @Override
+      public void success(SuccessCommandResponse successResponse) {
+        ChangeLiveBody body;
+        try {
+          body = successResponse.getBody().asChangeLiveBody();
+        } catch (JsonProtocolParseException e) {
+          throw new RuntimeException(e);
+        }
+
+        ScriptLoadCallback scriptCallback = new ScriptLoadCallback() {
+          public void failure(String message) {
+            LOGGER.log(Level.SEVERE,
+                "Failed to reload script after LiveEdit script update; " + message);
+          }
+          public void success() {
+            LiveEditDebugEventListener listener =
+                LiveEditExtension.castToLiveEditListener(debugSession.getDebugEventListener());
+            if (listener != null) {
+              listener.scriptContentChanged(ScriptImpl.this);
+            }
+          }
+        };
+        V8Helper.reloadScriptAsync(debugSession, Collections.singletonList(getId()),
+            scriptCallback, null);
+
+        debugSession.recreateCurrentContext();
+
+        callback.success(body.getChangeLog());
+      }
+
+      @Override
+      public void failure(String message) {
+        callback.failure(message);
+      }
+    };
+  }
+
   @Override
   public int hashCode() {
     return
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/ScriptManager.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/ScriptManager.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/ScriptManager.java	Tue Jun 08 16:12:51 2010 -0700
@@ -40,9 +40,11 @@
       Collections.synchronizedMap(new HashMap<Long, ScriptImpl>());
 
   private final V8ContextFilter contextFilter;
+  private final DebugSession debugSession;
 
-  ScriptManager(V8ContextFilter contextFilter) {
+  ScriptManager(V8ContextFilter contextFilter, DebugSession debugSession) {
     this.contextFilter = contextFilter;
+    this.debugSession = debugSession;
   }
 
   /**
@@ -62,7 +64,7 @@
       if (desc == null) {
         return null;
       }
-      theScript = new ScriptImpl(desc);
+      theScript = new ScriptImpl(desc, debugSession);
       idToScript.put(desc.id, theScript);
     }
     if (scriptBody.source() != null) {
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/protocol/ChangeLiveBody.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/protocol/ChangeLiveBody.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,15 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.sdk.internal.protocol;
+
+import org.chromium.sdk.internal.protocolparser.JsonField;
+import org.chromium.sdk.internal.protocolparser.JsonSubtype;
+import org.chromium.sdk.internal.protocolparser.JsonType;
+
+@JsonType
+public interface ChangeLiveBody extends JsonSubtype<CommandResponseBody>  {
+  @JsonField(jsonLiteralName="change_log")
+  Object getChangeLog();
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/protocol/CommandResponse.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/protocol/CommandResponse.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/protocol/CommandResponse.java	Tue Jun 08 16:12:51 2010 -0700
@@ -8,6 +8,7 @@
 
 import org.chromium.sdk.internal.protocolparser.EnumValueCondition;
 import org.chromium.sdk.internal.protocolparser.JsonField;
+import org.chromium.sdk.internal.protocolparser.JsonOptionalField;
 import org.chromium.sdk.internal.protocolparser.JsonOverrideField;
 import org.chromium.sdk.internal.protocolparser.JsonSubtype;
 import org.chromium.sdk.internal.protocolparser.JsonSubtypeCasting;
@@ -37,6 +38,7 @@
   @JsonField(jsonLiteralName="request_seq")
   long getRequestSeq();
 
+  @JsonOptionalField
   String getCommand();
 
   boolean success();
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/protocol/CommandResponseBody.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/protocol/CommandResponseBody.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/protocol/CommandResponseBody.java	Tue Jun 08 16:12:51 2010 -0700
@@ -41,4 +41,10 @@
 
   @JsonSubtypeCasting
   VersionBody asVersionBody() throws JsonProtocolParseException;
+
+  @JsonSubtypeCasting
+  ChangeLiveBody asChangeLiveBody() throws JsonProtocolParseException;
+
+  @JsonSubtypeCasting
+  ListBreakpointsBody asListBreakpointsBody() throws JsonProtocolParseException;
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/protocol/ListBreakpointsBody.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/protocol/ListBreakpointsBody.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,16 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.sdk.internal.protocol;
+
+import java.util.List;
+
+import org.chromium.sdk.internal.protocol.data.BreakpointInfo;
+import org.chromium.sdk.internal.protocolparser.JsonSubtype;
+import org.chromium.sdk.internal.protocolparser.JsonType;
+
+@JsonType
+public interface ListBreakpointsBody extends JsonSubtype<CommandResponseBody> {
+  List<BreakpointInfo> breakpoints();
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/protocol/data/BreakpointInfo.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/protocol/data/BreakpointInfo.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,43 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.sdk.internal.protocol.data;
+
+import org.chromium.sdk.internal.protocolparser.JsonNullable;
+import org.chromium.sdk.internal.protocolparser.JsonOptionalField;
+import org.chromium.sdk.internal.protocolparser.JsonType;
+
+@JsonType
+public interface BreakpointInfo {
+  Type type();
+
+  @JsonOptionalField
+  String script_name();
+
+  @JsonOptionalField
+  Long script_id();
+
+  long number();
+
+  long line();
+
+  Long column();
+
+  Long groupId();
+
+  long hit_count();
+
+  boolean active();
+
+  @JsonNullable
+  String condition();
+
+  long ignoreCount();
+
+  enum Type {
+    scriptName,
+    scriptId,
+    function
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/protocolparser/dynamicimpl/JsonProtocolParser.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/protocolparser/dynamicimpl/JsonProtocolParser.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/protocolparser/dynamicimpl/JsonProtocolParser.java	Tue Jun 08 16:12:51 2010 -0700
@@ -374,7 +374,7 @@
 
         if (fieldTypeParser.asQuickParser() != null) {
           LazyParseFieldMethodHandler onDemandHandler = new LazyParseFieldMethodHandler(
-              fieldTypeParser.asQuickParser(), isOptional, fieldName);
+              fieldTypeParser.asQuickParser(), isOptional, fieldName, typeClass);
           onDemandHanlers.add(onDemandHandler);
           methodHandler = onDemandHandler;
         } else {
@@ -534,11 +534,14 @@
     private final QuickParser<?> quickParser;
     private final boolean isOptional;
     private final String fieldName;
+    private final Class<?> typeClass;
 
-    LazyParseFieldMethodHandler(QuickParser<?> quickParser, boolean isOptional, String fieldName) {
+    LazyParseFieldMethodHandler(QuickParser<?> quickParser, boolean isOptional, String fieldName,
+        Class<?> typeClass) {
       this.quickParser = quickParser;
       this.isOptional = isOptional;
       this.fieldName = fieldName;
+      this.typeClass = typeClass;
     }
 
     @Override
@@ -546,7 +549,8 @@
       try {
         return parse(objectData);
       } catch (JsonProtocolParseException e) {
-        throw new JsonProtocolParseRuntimeException("On demand parsing failed", e);
+        throw new JsonProtocolParseRuntimeException(
+            "On demand parsing failed for " + objectData.getUnderlyingObject(), e);
       }
     }
 
@@ -568,11 +572,13 @@
         try {
           return quickParser.parseValueQuick(value);
         } catch (JsonProtocolParseException e) {
-          throw new JsonProtocolParseException("Failed to parse field " + fieldName, e);
+          throw new JsonProtocolParseException("Failed to parse field " + fieldName + " in type " +
+              typeClass.getName(), e);
         }
       } else {
         if (!isOptional) {
-          throw new JsonProtocolParseException("Field is not optional: " + fieldName);
+          throw new JsonProtocolParseException("Field is not optional: " + fieldName +
+              " (in type " + typeClass.getName() + ")");
         }
         return null;
       }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/BreakpointImpl.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/BreakpointImpl.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/BreakpointImpl.java	Tue Jun 08 16:12:51 2010 -0700
@@ -5,7 +5,9 @@
 package org.chromium.sdk.internal.tools.v8;
 
 import org.chromium.sdk.Breakpoint;
-import org.chromium.sdk.BrowserTab;
+import org.chromium.sdk.JavascriptVm;
+import org.chromium.sdk.SyncCallback;
+import org.chromium.sdk.internal.protocol.data.BreakpointInfo;
 
 /**
  * A generic implementation of the Breakpoint interface.
@@ -23,6 +25,21 @@
   private long id;
 
   /**
+   * The corresponding script name as reported by the JavaScript VM. May be null.
+   */
+  private String scriptName;
+
+  /**
+   * The corresponding script id as reported by the JavaScript VM. May be null.
+   */
+  private Long scriptId;
+
+  /**
+   * Breakpoint line number. May become invalidated by LiveEdit actions.
+   */
+  private long lineNumber;
+
+  /**
    * Whether the breakpoint is enabled.
    */
   private boolean isEnabled;
@@ -50,16 +67,40 @@
    */
   private volatile boolean isDirty = false;
 
-  public BreakpointImpl(Type type, long id, boolean enabled, int ignoreCount, String condition,
-      BreakpointManager breakpointManager) {
+  public BreakpointImpl(Type type, long id, String scriptName, Long scriptId, long lineNumber,
+      boolean enabled, int ignoreCount, String condition, BreakpointManager breakpointManager) {
     this.type = type;
+    this.scriptName = scriptName;
+    this.scriptId = scriptId;
     this.id = id;
     this.isEnabled = enabled;
     this.ignoreCount = ignoreCount;
     this.condition = condition;
+    this.lineNumber = lineNumber;
     this.breakpointManager = breakpointManager;
   }
 
+  public BreakpointImpl(BreakpointInfo info, BreakpointManager breakpointManager) {
+    this.type = getType(info);
+    this.id = info.number();
+    this.breakpointManager = breakpointManager;
+    updateFromRemote(info);
+  }
+  public void updateFromRemote(BreakpointInfo info) {
+    if (this.type != getType(info)) {
+      throw new IllegalArgumentException();
+    }
+    if (this.id != info.number()) {
+      throw new IllegalArgumentException();
+    }
+    this.lineNumber = info.line();
+    this.isEnabled = info.active();
+    this.ignoreCount = (int) info.ignoreCount();
+    this.condition = info.condition();
+    this.scriptName = info.script_name();
+    this.scriptId = info.script_id();
+  }
+
   public boolean isEnabled() {
     return isEnabled;
   }
@@ -72,6 +113,14 @@
     return id;
   }
 
+  public String getScriptName() {
+    return scriptName;
+  }
+
+  public Long getScriptId() {
+    return scriptId;
+  }
+
   public int getIgnoreCount() {
     return ignoreCount;
   }
@@ -80,6 +129,10 @@
     return condition;
   }
 
+  public long getLineNumber() {
+    return lineNumber;
+  }
+
   public void setEnabled(boolean enabled) {
     if (this.isEnabled != enabled) {
       setDirty(true);
@@ -106,21 +159,21 @@
     return left == right || (left != null && left.equals(right));
   }
 
-  public void clear(final BrowserTab.BreakpointCallback callback) {
-    breakpointManager.clearBreakpoint(this, callback);
+  public void clear(JavascriptVm.BreakpointCallback callback, SyncCallback syncCallback) {
+    breakpointManager.clearBreakpoint(this, callback, syncCallback);
     // The order must be preserved, otherwise the breakpointProcessor will not be able
     // to identify the original breakpoint ID.
     this.id = INVALID_ID;
   }
 
-  public void flush(final BrowserTab.BreakpointCallback callback) {
+  public void flush(final JavascriptVm.BreakpointCallback callback, SyncCallback syncCallback) {
     if (!isDirty()) {
       if (callback != null) {
         callback.success(this);
       }
       return;
     }
-    breakpointManager.changeBreakpoint(this, callback);
+    breakpointManager.changeBreakpoint(this, callback, syncCallback);
     setDirty(false);
   }
 
@@ -132,4 +185,13 @@
     return isDirty;
   }
 
-}
\ No newline at end of file
+  private static Type getType(BreakpointInfo info) {
+    BreakpointInfo.Type infoType = info.type();
+    switch (infoType) {
+      case scriptId: return Type.SCRIPT_ID;
+      case scriptName: return Type.SCRIPT_NAME;
+      case function: return Type.FUNCTION;
+    }
+    throw new RuntimeException("Unknown type: " + infoType);
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/BreakpointManager.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/BreakpointManager.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/BreakpointManager.java	Tue Jun 08 16:12:51 2010 -0700
@@ -1,22 +1,35 @@
+// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
 package org.chromium.sdk.internal.tools.v8;
 
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 
 import org.chromium.sdk.Breakpoint;
-import org.chromium.sdk.BrowserTab;
+import org.chromium.sdk.JavascriptVm;
+import org.chromium.sdk.SyncCallback;
 import org.chromium.sdk.JavascriptVm.BreakpointCallback;
+import org.chromium.sdk.JavascriptVm.ListBreakpointsCallback;
 import org.chromium.sdk.internal.DebugSession;
 import org.chromium.sdk.internal.protocol.BreakpointBody;
+import org.chromium.sdk.internal.protocol.CommandResponseBody;
+import org.chromium.sdk.internal.protocol.ListBreakpointsBody;
 import org.chromium.sdk.internal.protocol.SuccessCommandResponse;
+import org.chromium.sdk.internal.protocol.data.BreakpointInfo;
 import org.chromium.sdk.internal.protocolparser.JsonProtocolParseException;
 import org.chromium.sdk.internal.tools.v8.request.DebuggerMessageFactory;
+import org.chromium.sdk.internal.tools.v8.request.ListBreakpointsMessage;
 
 public class BreakpointManager {
   /**
    * This map shall contain only breakpoints with valid IDs.
    */
-  private final Map<Long, Breakpoint> idToBreakpoint = new HashMap<Long, Breakpoint>();
+  private final Map<Long, BreakpointImpl> idToBreakpoint = new HashMap<Long, BreakpointImpl>();
 
   private final DebugSession debugSession;
 
@@ -24,11 +37,28 @@
     this.debugSession = debugSession;
   }
 
-  public void setBreakpoint(final Breakpoint.Type type, String target, int line, int position,
-      final boolean enabled, final String condition, final int ignoreCount,
-      final BrowserTab.BreakpointCallback callback) {
+  public void setBreakpoint(final Breakpoint.Type type, final String target,
+      final int line, int position, final boolean enabled, final String condition,
+      final int ignoreCount, final JavascriptVm.BreakpointCallback callback,
+      SyncCallback syncCallback) {
+
+    final String scriptName;
+    final Long scriptId;
+    Object targetObject;
+    if (type == Breakpoint.Type.SCRIPT_ID) {
+      scriptName = null;
+      scriptId = Long.parseLong(target);
+      targetObject = scriptId;
+    } else if (type == Breakpoint.Type.SCRIPT_NAME) {
+      scriptName = target;
+      scriptId = null;
+      targetObject = scriptName;
+    } else {
+      throw new IllegalArgumentException("Unsupported breakpoint type " + type);
+    }
+
     debugSession.sendMessageAsync(
-        DebuggerMessageFactory.setBreakpoint(type, target, toNullableInteger(line),
+        DebuggerMessageFactory.setBreakpoint(type, targetObject, toNullableInteger(line),
             toNullableInteger(position), enabled, condition,
             toNullableInteger(ignoreCount)),
         true,
@@ -46,7 +76,7 @@
                 long id = body.getBreakpoint();
 
                 final BreakpointImpl breakpoint =
-                    new BreakpointImpl(type, id, enabled, ignoreCount,
+                    new BreakpointImpl(type, id, scriptName, scriptId, line, enabled, ignoreCount,
                         condition, BreakpointManager.this);
 
                 callback.success(breakpoint);
@@ -59,7 +89,7 @@
                 }
               }
             },
-            null);
+            syncCallback);
   }
 
   public Breakpoint getBreakpoint(Long id) {
@@ -67,7 +97,8 @@
   }
 
   public void clearBreakpoint(
-      final BreakpointImpl breakpointImpl, final BreakpointCallback callback) {
+      final BreakpointImpl breakpointImpl, final BreakpointCallback callback,
+      SyncCallback syncCallback) {
     long id = breakpointImpl.getId();
     if (id == Breakpoint.INVALID_ID) {
       return;
@@ -90,11 +121,11 @@
             }
           }
         },
-        null);
+        syncCallback);
   }
 
   public void changeBreakpoint(final BreakpointImpl breakpointImpl,
-      final BreakpointCallback callback) {
+      final BreakpointCallback callback, SyncCallback syncCallback) {
     debugSession.sendMessageAsync(
         DebuggerMessageFactory.changeBreakpoint(breakpointImpl),
         true,
@@ -112,7 +143,39 @@
             }
           }
         },
-        null);
+        syncCallback);
+  }
+
+  /**
+   * Reads a list of breakpoints from remote and updates local instances and the map.
+   */
+  public void reloadBreakpoints(final ListBreakpointsCallback callback, SyncCallback syncCallback) {
+    V8CommandCallbackBase v8Callback = new V8CommandCallbackBase() {
+      @Override
+      public void failure(String message) {
+        callback.failure(new Exception(message));
+      }
+      @Override
+      public void success(SuccessCommandResponse successResponse) {
+        CommandResponseBody body = successResponse.getBody();
+        ListBreakpointsBody listBreakpointsBody;
+        try {
+          listBreakpointsBody = body.asListBreakpointsBody();
+        } catch (JsonProtocolParseException e) {
+          callback.failure(new Exception("Failed to read server response", e));
+          return;
+        }
+        List<BreakpointInfo> infos = listBreakpointsBody.breakpoints();
+        try {
+          syncBreakpoints(infos);
+        } catch (RuntimeException e) {
+          callback.failure(new Exception("Failed to read server response", e));
+          return;
+        }
+        callback.success(Collections.unmodifiableCollection(idToBreakpoint.values()));
+      }
+    };
+    debugSession.sendMessageAsync(new ListBreakpointsMessage(), true, v8Callback, syncCallback);
   }
 
   private static Integer toNullableInteger(int value) {
@@ -120,4 +183,41 @@
         ? null
         : value;
   }
+
+  private void syncBreakpoints(List<BreakpointInfo> infoList) {
+    Map<Long, BreakpointImpl> actualBreakpoints = new HashMap<Long, BreakpointImpl>();
+    // Wrap all loaded BreakpointInfo as BreakpointImpl, possibly reusing old instances.
+    // Also check that all breakpoint id's in loaded list are unique.
+    for (BreakpointInfo info : infoList) {
+      if (info.type() == BreakpointInfo.Type.function) {
+        // We does not support function type breakpoints and ignore them.
+        continue;
+      }
+      BreakpointImpl breakpoint = idToBreakpoint.get(info.number());
+      if (breakpoint == null) {
+        breakpoint = new BreakpointImpl(info, this);
+      } else {
+        breakpoint.updateFromRemote(info);
+      }
+      Object conflict = actualBreakpoints.put(info.number(), breakpoint);
+      if (conflict != null) {
+        throw new RuntimeException("Duplicated breakpoint number " + info.number());
+      }
+    }
+
+    // Remove all obsolete breakpoints from the map.
+    for (Iterator<Long> it = idToBreakpoint.keySet().iterator(); it.hasNext(); ) {
+      Long id = it.next();
+      if (!actualBreakpoints.containsKey(id)) {
+        it.remove();
+      }
+    }
+
+    // Add breakpoints that are not in the main map yet.
+    for (BreakpointImpl breakpoint : actualBreakpoints.values()) {
+      if (!idToBreakpoint.containsKey(breakpoint.getId())) {
+        idToBreakpoint.put(breakpoint.getId(), breakpoint);
+      }
+    }
+  }
 }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/DebuggerCommand.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/DebuggerCommand.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/DebuggerCommand.java	Tue Jun 08 16:12:51 2010 -0700
@@ -16,11 +16,13 @@
   BACKTRACE("backtrace"),
   FRAME("frame"),
   SCRIPTS("scripts"),
+  CHANGELIVE("changelive"),
   SOURCE("source"),
   SCOPE("scope"),
   SETBREAKPOINT("setbreakpoint"),
   CHANGEBREAKPOINT("changebreakpoint"),
   CLEARBREAKPOINT("clearbreakpoint"),
+  LISTBREAKPOINTS("listbreakpoints"),
   LOOKUP("lookup"),
   SUSPEND("suspend"),
   VERSION("version"),
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/V8CommandCallbackBase.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/V8CommandCallbackBase.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/V8CommandCallbackBase.java	Tue Jun 08 16:12:51 2010 -0700
@@ -19,7 +19,7 @@
   public void messageReceived(CommandResponse response) {
     SuccessCommandResponse successResponse = response.asSuccess();
     if (successResponse == null) {
-      this.failure(response.asFailure().getMessage());
+      this.failure("Remote error: " + response.asFailure().getMessage());
       return;
     } else {
       success(successResponse);
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/V8Helper.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/V8Helper.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/V8Helper.java	Tue Jun 08 16:12:51 2010 -0700
@@ -19,6 +19,7 @@
 import org.chromium.sdk.internal.PropertyHoldingValueMirror;
 import org.chromium.sdk.internal.PropertyReference;
 import org.chromium.sdk.internal.ScopeMirror;
+import org.chromium.sdk.internal.ScriptImpl;
 import org.chromium.sdk.internal.ScriptManager;
 import org.chromium.sdk.internal.SubpropertiesMirror;
 import org.chromium.sdk.internal.ValueLoadException;
@@ -34,6 +35,7 @@
 import org.chromium.sdk.internal.protocol.data.ScriptHandle;
 import org.chromium.sdk.internal.protocol.data.ValueHandle;
 import org.chromium.sdk.internal.protocolparser.JsonProtocolParseException;
+import org.chromium.sdk.internal.tools.v8.request.ContextlessDebuggerMessage;
 import org.chromium.sdk.internal.tools.v8.request.DebuggerMessageFactory;
 import org.chromium.sdk.internal.tools.v8.request.ScriptsMessage;
 
@@ -42,13 +44,7 @@
  */
 public class V8Helper {
 
-  /**
-   * The debug context in which the operations are performed.
-   */
-  private final DebugSession debugSession;
-
   public V8Helper(DebugSession debugSession) {
-    this.debugSession = debugSession;
   }
 
   public interface ScriptLoadCallback {
@@ -63,13 +59,33 @@
    */
   public static void reloadAllScriptsAsync(final DebugSession debugSession,
       final ScriptLoadCallback callback, SyncCallback syncCallback) {
+    reloadScriptAsync(debugSession, null, callback, syncCallback);
+  }
+
+  /**
+   * Loads specified scripts or all existing scripts and stores them in ScriptManager.
+   * @param ids ids of requested scripts or null for all scripts
+   * @param callback to invoke when the script reloading has completed
+   * @param syncCallback to invoke after callback, regardless of whether it has returned normally
+   *        or thrown an exception
+   */
+  public static void reloadScriptAsync(final DebugSession debugSession, final List<Long> ids,
+      final ScriptLoadCallback callback, SyncCallback syncCallback) {
+    ContextlessDebuggerMessage message = DebuggerMessageFactory.scripts(ids, true);
+    if (ids == null) {
+      message = DebuggerMessageFactory.scripts(ScriptsMessage.SCRIPTS_NORMAL, true);
+    } else {
+      message = DebuggerMessageFactory.scripts(ids, true);
+    }
     debugSession.sendMessageAsync(
-        DebuggerMessageFactory.scripts(ScriptsMessage.SCRIPTS_NORMAL, true),
+        message,
         true,
         new V8CommandCallbackBase() {
           @Override
           public void failure(String message) {
-            callback.failure(message);
+            if (callback != null) {
+              callback.failure(message);
+            }
           }
 
           @Override
@@ -83,13 +99,24 @@
             ScriptManager scriptManager = debugSession.getScriptManager();
             for (int i = 0; i < body.size(); ++i) {
               ScriptHandle scriptHandle = body.get(i);
+              if (ChromeDevToolSessionManager.JAVASCRIPT_VOID.equals(scriptHandle.source())) {
+                continue;
+              }
               Long id = V8ProtocolUtil.getScriptIdFromResponse(scriptHandle);
-              if (scriptManager.findById(id) == null &&
-                  !ChromeDevToolSessionManager.JAVASCRIPT_VOID.equals(scriptHandle.source())) {
+              ScriptImpl scriptById = scriptManager.findById(id);
+              if (scriptById == null) {
                 scriptManager.addScript(scriptHandle, successResponse.getRefs());
+              } else {
+                // A scrupulous refactoring note:
+                // do not call setSource in a legacy case, when ids parameter is null.
+                if (ids != null) {
+                  scriptById.setSource(scriptHandle.source());
+                }
               }
             }
-            callback.success();
+            if (callback != null) {
+              callback.success();
+            }
           }
         },
         syncCallback);
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/V8ProtocolUtil.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/V8ProtocolUtil.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/V8ProtocolUtil.java	Tue Jun 08 16:12:51 2010 -0700
@@ -19,6 +19,7 @@
 import org.chromium.sdk.internal.protocol.BacktraceCommandBody;
 import org.chromium.sdk.internal.protocol.BreakEventBody;
 import org.chromium.sdk.internal.protocol.BreakpointBody;
+import org.chromium.sdk.internal.protocol.ChangeLiveBody;
 import org.chromium.sdk.internal.protocol.CommandResponse;
 import org.chromium.sdk.internal.protocol.CommandResponseBody;
 import org.chromium.sdk.internal.protocol.EventNotification;
@@ -26,10 +27,12 @@
 import org.chromium.sdk.internal.protocol.FailedCommandResponse;
 import org.chromium.sdk.internal.protocol.FrameObject;
 import org.chromium.sdk.internal.protocol.IncomingMessage;
+import org.chromium.sdk.internal.protocol.ListBreakpointsBody;
 import org.chromium.sdk.internal.protocol.ScopeBody;
 import org.chromium.sdk.internal.protocol.ScopeRef;
 import org.chromium.sdk.internal.protocol.SuccessCommandResponse;
 import org.chromium.sdk.internal.protocol.VersionBody;
+import org.chromium.sdk.internal.protocol.data.BreakpointInfo;
 import org.chromium.sdk.internal.protocol.data.ContextData;
 import org.chromium.sdk.internal.protocol.data.ContextHandle;
 import org.chromium.sdk.internal.protocol.data.FunctionValueHandle;
@@ -367,6 +370,8 @@
           ScopeRef.class,
           VersionBody.class,
           AfterCompileBody.class,
+          ChangeLiveBody.class,
+          ListBreakpointsBody.class,
 
           SomeHandle.class,
           ScriptHandle.class,
@@ -381,6 +386,7 @@
           SomeSerialized.class,
           ContextHandle.class,
           ContextData.class,
+          BreakpointInfo.class,
       });
     } catch (JsonProtocolModelParseException e) {
       throw new RuntimeException(e);
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/request/ChangeLiveMessage.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/request/ChangeLiveMessage.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,18 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.sdk.internal.tools.v8.request;
+
+import org.chromium.sdk.internal.tools.v8.DebuggerCommand;
+
+/**
+ * Represents a "changelive" experimental V8 request message.
+ */
+public class ChangeLiveMessage extends ContextlessDebuggerMessage {
+  public ChangeLiveMessage(long scriptId, String newSource) {
+    super(DebuggerCommand.CHANGELIVE.value);
+    putArgument("script_id", scriptId);
+    putArgument("new_source", newSource);
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/request/DebuggerMessageFactory.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/request/DebuggerMessageFactory.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/request/DebuggerMessageFactory.java	Tue Jun 08 16:12:51 2010 -0700
@@ -45,7 +45,7 @@
     return new SourceMessage(frame, fromLine, toLine);
   }
 
-  public static ContextlessDebuggerMessage setBreakpoint(Breakpoint.Type type, String target,
+  public static ContextlessDebuggerMessage setBreakpoint(Breakpoint.Type type, Object target,
       Integer line, Integer position, Boolean enabled, String condition, Integer ignoreCount) {
     return new SetBreakpointMessage(type, target, line, position, enabled, condition, ignoreCount);
   }
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/request/ListBreakpointsMessage.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/request/ListBreakpointsMessage.java	Tue Jun 08 16:12:51 2010 -0700
@@ -0,0 +1,17 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.sdk.internal.tools.v8.request;
+
+import org.chromium.sdk.internal.tools.v8.DebuggerCommand;
+
+/**
+ * Represents a "listbreakpoints" V8 request message.
+ */
+public class ListBreakpointsMessage extends ContextlessDebuggerMessage {
+
+  public ListBreakpointsMessage() {
+    super(DebuggerCommand.LISTBREAKPOINTS.value);
+  }
+}
diff -r 1f666f57e777 -r dd7d3426144c org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/request/SetBreakpointMessage.java
--- a/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/request/SetBreakpointMessage.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.chromium.sdk/src/org/chromium/sdk/internal/tools/v8/request/SetBreakpointMessage.java	Tue Jun 08 16:12:51 2010 -0700
@@ -34,7 +34,7 @@
    * @param ignoreCount nullable number specifying the amount of break point hits to ignore.
    *        Default is 0
    */
-  public SetBreakpointMessage(Breakpoint.Type type, String target,
+  public SetBreakpointMessage(Breakpoint.Type type, Object target,
       Integer line, Integer position, Boolean enabled, String condition,
       Integer ignoreCount) {
     super(DebuggerCommand.SETBREAKPOINT.value);
diff -r 1f666f57e777 -r dd7d3426144c org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/HtmlBreakpointProvider.java
--- a/org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/HtmlBreakpointProvider.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/HtmlBreakpointProvider.java	Tue Jun 08 16:12:51 2010 -0700
@@ -14,6 +14,7 @@
 import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
 import org.eclipse.wst.sse.ui.internal.provisional.extensions.ISourceEditingTextTools;
 import org.eclipse.wst.sse.ui.internal.provisional.extensions.breakpoint.IBreakpointProvider;
+import org.symbian.tools.wrttools.debug.internal.launch.WRTProjectWorkspaceBridge;
 
 @SuppressWarnings("restriction")
 public class HtmlBreakpointProvider implements IBreakpointProvider {
@@ -23,7 +24,8 @@
 		boolean hasScript = hasJavaScript(document, lineNumber);
 
 		if (hasScript) {
-			ChromiumLineBreakpoint breakpoint = new ChromiumLineBreakpoint(getResource(input), lineNumber);
+            ChromiumLineBreakpoint breakpoint = new ChromiumLineBreakpoint(getResource(input), lineNumber,
+                    WRTProjectWorkspaceBridge.DEBUG_MODEL_ID);
 			DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(breakpoint);
 		}
 		return Status.OK_STATUS;
diff -r 1f666f57e777 -r dd7d3426144c org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/launch/WRTProjectWorkspaceBridge.java
--- a/org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/launch/WRTProjectWorkspaceBridge.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/launch/WRTProjectWorkspaceBridge.java	Tue Jun 08 16:12:51 2010 -0700
@@ -4,14 +4,17 @@
 import java.util.ArrayList;
 import java.util.Collection;
 
+import org.chromium.debug.core.model.BreakpointSynchronizer.Callback;
+import org.chromium.debug.core.model.BreakpointSynchronizer.Direction;
 import org.chromium.debug.core.model.ChromiumLineBreakpoint;
 import org.chromium.debug.core.model.DebugTargetImpl;
 import org.chromium.debug.core.model.StackFrame;
+import org.chromium.debug.core.model.VmResource;
 import org.chromium.debug.core.model.WorkspaceBridge;
 import org.chromium.sdk.CallFrame;
 import org.chromium.sdk.JavascriptVm;
+import org.chromium.sdk.JavascriptVm.ScriptsCallback;
 import org.chromium.sdk.Script;
-import org.chromium.sdk.JavascriptVm.ScriptsCallback;
 import org.eclipse.core.filesystem.EFS;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IMarker;
@@ -51,7 +54,6 @@
 
 	}
 
-//	public final static String DEBUG_MODEL_ID = VProjectWorkspaceBridge.DEBUG_MODEL_ID;
 	public final static String DEBUG_MODEL_ID = "org.symbian.debug";
 
 	private final BreakpointHandler breakpointHandler;
@@ -63,9 +65,8 @@
 			JavascriptVm javascriptVm, IProject project) {
 		this.javascriptVm = javascriptVm;
 		this.project = project;
-		this.resourceManager = new ResourceManager();
-		breakpointHandler = new WorkspaceBreakpointHandler(debugTargetImpl,
-				javascriptVm, resourceManager);
+        this.resourceManager = new ResourceManager();
+        breakpointHandler = new WorkspaceBreakpointHandler(debugTargetImpl, resourceManager);
 		ILaunch launch = debugTargetImpl.getLaunch();
 		launch.setSourceLocator(sourceLocator);
 	}
@@ -78,10 +79,6 @@
 		return breakpointHandler;
 	}
 
-	public IFile getScriptResource(Script script) {
-		return resourceManager.getResource(script);
-	}
-
 	public void handleVmResetEvent() {
 		resourceManager.clear();
 	}
@@ -175,4 +172,19 @@
 		}
 	};
 
+    public VmResource findVmResourceFromWorkspaceFile(IFile resource) throws CoreException {
+        System.out.println(resource);
+        return null;
+    }
+
+    public void reloadScript(Script script) {
+        System.out.println(script);
+
+    }
+
+    public void synchronizeBreakpoints(Direction direction, Callback callback) {
+        System.out.println(direction);
+
+    }
+
 }
diff -r 1f666f57e777 -r dd7d3426144c org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/launch/WrtLabelProvider.java
--- a/org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/launch/WrtLabelProvider.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/launch/WrtLabelProvider.java	Tue Jun 08 16:12:51 2010 -0700
@@ -15,29 +15,29 @@
 
 public class WrtLabelProvider implements JsLabelProvider {
 
-	public String getStackFrameLabel(StackFrame stackFrame)
-			throws DebugException {
-		CallFrame callFrame = stackFrame.getCallFrame();
-		String name = callFrame.getFunctionName();
-		Script script = callFrame.getScript();
-		if (script == null) {
-			return "<unknown>";
-		}
-		IFile resource = stackFrame.getDebugTarget().getScriptResource(script);
-		int line = script.getStartLine() + stackFrame.getLineNumber();
-		if (line != -1) {
-			String resourcePath = resource != null ? resource
-					.getProjectRelativePath().toString() : script.getName();
-			name = NLS.bind("{0} [{1}:{2}]", new Object[] { name, resourcePath,
-					line });
-		}
-		return name;
-	}
+    public String getStackFrameLabel(StackFrame stackFrame) throws DebugException {
+        CallFrame callFrame = stackFrame.getCallFrame();
+        String name = callFrame.getFunctionName();
+        Script script = callFrame.getScript();
+        if (script == null) {
+            return "<unknown>";
+        }
+        Object element = stackFrame.getLaunch().getSourceLocator().getSourceElement(stackFrame);
+        if (element instanceof IFile) {
+            IFile resource = (IFile) element;
+            int line = script.getStartLine() + stackFrame.getLineNumber();
+            if (line != -1) {
+                String resourcePath = resource != null ? resource.getProjectRelativePath().toString() : script
+                        .getName();
+                name = NLS.bind("{0} [{1}:{2}]", new Object[] { name, resourcePath, line });
+            }
+        }
+        return name;
+    }
 
-	public String getTargetLabel(DebugTargetImpl debugTarget)
-			throws DebugException {
-		return "WRT Runtime";
-	}
+    public String getTargetLabel(DebugTargetImpl debugTarget) throws DebugException {
+        return "WRT Runtime";
+    }
 
     public String getThreadLabel(JavascriptThread thread) throws DebugException {
         return NLS.bind("JavaScript Thread ({0})", getThreadStateLabel(thread));
@@ -48,8 +48,8 @@
             DebugContext context = thread.getDebugTarget().getDebugContext();
             ExceptionData exceptionData = context.getExceptionData();
             if (exceptionData != null) {
-                return NLS.bind(Messages.JsThread_ThreadLabelSuspendedExceptionFormat, exceptionData
-                        .getExceptionMessage());
+                return NLS.bind(Messages.JsThread_ThreadLabelSuspendedExceptionFormat,
+                        exceptionData.getExceptionMessage());
             } else {
                 return Messages.JsThread_ThreadLabelSuspended;
             }
diff -r 1f666f57e777 -r dd7d3426144c org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/model/ResourceManager.java
--- a/org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/model/ResourceManager.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/model/ResourceManager.java	Tue Jun 08 16:12:51 2010 -0700
@@ -7,6 +7,7 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import org.chromium.debug.core.model.VmResourceId;
 import org.chromium.sdk.Script;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IResource;
@@ -15,77 +16,19 @@
 /**
  * This object handles the mapping between {@link Script}s and their
  * corresponding resources inside Eclipse.
- * 
- * Symbian branch is currently based on Revision 138
  */
 public class ResourceManager {
-	/**
-	 * Script identifier for a breakpoint location.
-	 */
-	public static class ScriptIdentifier {
-		public static ScriptIdentifier forScript(Script script) {
-			String name = script.getName();
-			return new ScriptIdentifier(name, name != null ? -1 : script
-					.getId(), script.getStartLine(), script.getEndLine());
-		}
-
-		private final int endLine;
-		private final long id;
-		private final String name;
-		private final int startLine;
-
-		private ScriptIdentifier(String name, long id, int startLine,
-				int endLine) {
-			this.name = name;
-			this.id = id;
-			this.startLine = startLine;
-			this.endLine = endLine;
-		}
+	private final Map<IFile, Script> resourceToScript = new HashMap<IFile, Script>();
+    private final Map<VmResourceId, IFile> scriptIdToResource = new HashMap<VmResourceId, IFile>();
 
-		@Override
-		public boolean equals(Object obj) {
-			if (!(obj instanceof ScriptIdentifier)) {
-				return false;
-			}
-			ScriptIdentifier that = (ScriptIdentifier) obj;
-			if (this.startLine != that.startLine
-					|| this.endLine != that.endLine) {
-				return false;
-			}
-			if (name == null) {
-				// an unnamed script, only id is known
-				return that.name == null && this.id == that.id;
-			}
-			// a named script
-			return this.name.equals(that.name);
-		}
-
-		@Override
-		public int hashCode() {
-			final int prime = 31;
-			int result = 1;
-			result = prime * result + (int) (id ^ (id >>> 32));
-			result = prime * result + ((name == null) ? 0 : name.hashCode());
-			result = prime * result + 17 * startLine + 19 * endLine;
-			return result;
-		}
-	}
-
-	private Object fileBeingAdded;
-	private final Map<IFile, Script> resourceToScript = new HashMap<IFile, Script>();
-	private final Map<ScriptIdentifier, IFile> scriptIdToResource = new HashMap<ScriptIdentifier, IFile>();
-
-	public synchronized void addScript(Script script) {
+    public synchronized void addScript(Script script) {
 		IFile scriptFile = getResource(script);
 		if (scriptFile == null) {
 			scriptFile = getFile(script.getName());
 			if (scriptFile != null) {
-				fileBeingAdded = scriptFile;
-				try {
-					putScript(script, scriptFile);
-				} finally {
-					fileBeingAdded = null;
-				}
+                VmResourceId scriptId = VmResourceId.forScript(script);
+                resourceToScript.put(scriptFile, script);
+                scriptIdToResource.put(scriptId, scriptFile);
 			}
 		}
 	}
@@ -106,32 +49,20 @@
 		return file;
 	}
 
-	public synchronized IFile getResource(Script script) {
-		return scriptIdToResource.get(ScriptIdentifier.forScript(script));
-	}
-
-	public synchronized Script getScript(IFile resource) {
-		return resourceToScript.get(resource);
+    public synchronized IFile getResource(Script script) {
+        return scriptIdToResource.get(VmResourceId.forScript(script));
 	}
 
-	/**
-	 * @return whether the given file is being added to the target project
-	 */
-	public boolean isAddingFile(IFile file) {
-		return file.equals(fileBeingAdded);
-	}
-
-	public synchronized void putScript(Script script, IFile resource) {
-		ScriptIdentifier scriptId = ScriptIdentifier.forScript(script);
-		resourceToScript.put(resource, script);
-		scriptIdToResource.put(scriptId, resource);
-	}
-
-	public synchronized boolean scriptHasResource(Script script) {
+    public synchronized boolean scriptHasResource(Script script) {
 		return getResource(script) != null;
 	}
 
 	public String translateResourceToScript(IResource resource) {
 		return PreviewerPlugin.getDefault().getHttpPreviewer().getHttpUrl(resource);
 	}
+
+    public VmResourceId findVmResource(IFile resource) {
+        Script script = resourceToScript.get(resource);
+        return script != null ? VmResourceId.forScript(script) : null;
+    }
 }
diff -r 1f666f57e777 -r dd7d3426144c org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/model/WorkspaceBreakpointHandler.java
--- a/org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/model/WorkspaceBreakpointHandler.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.symbian.tools.wrttools.debug.core/src/org/symbian/tools/wrttools/debug/internal/model/WorkspaceBreakpointHandler.java	Tue Jun 08 16:12:51 2010 -0700
@@ -6,123 +6,190 @@
 import java.util.Collection;
 
 import org.chromium.debug.core.ChromiumDebugPlugin;
+import org.chromium.debug.core.model.BreakpointMap;
+import org.chromium.debug.core.model.BreakpointSynchronizer.BreakpointHelper.CreateCallback;
 import org.chromium.debug.core.model.ChromiumLineBreakpoint;
 import org.chromium.debug.core.model.DebugTargetImpl;
 import org.chromium.debug.core.model.VProjectWorkspaceBridge;
+import org.chromium.debug.core.model.VmResourceId;
 import org.chromium.debug.core.model.WorkspaceBridge.BreakpointHandler;
 import org.chromium.sdk.Breakpoint;
 import org.chromium.sdk.JavascriptVm;
-import org.chromium.sdk.JavascriptVm.BreakpointCallback;
+import org.chromium.sdk.SyncCallback;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IMarkerDelta;
 import org.eclipse.core.runtime.CoreException;
-import org.eclipse.debug.core.DebugPlugin;
 import org.eclipse.debug.core.model.IBreakpoint;
-import org.symbian.tools.wrttools.debug.internal.Activator;
 import org.symbian.tools.wrttools.debug.internal.launch.WRTProjectWorkspaceBridge;
+import org.symbian.tools.wrttools.previewer.PreviewerPlugin;
 
 public final class WorkspaceBreakpointHandler implements BreakpointHandler {
-	private final ResourceManager resourceManager;
+	private final BreakpointMap.InTargetMap breakpointInTargetMap = new BreakpointMap.InTargetMap();
 	private final DebugTargetImpl debugTarget;
-	private final JavascriptVm vm;
-
-	public WorkspaceBreakpointHandler(DebugTargetImpl debugTarget, JavascriptVm vm, ResourceManager resourceManager) {
+	private final ResourceManager resourceManager;
+	
+    public WorkspaceBreakpointHandler(DebugTargetImpl debugTarget, ResourceManager resourceManager) {
 		this.debugTarget = debugTarget;
-		this.vm = vm;
+        //		this.vm = vm;
 		this.resourceManager = resourceManager;
 	}
-	
-	public boolean supportsBreakpoint(IBreakpoint breakpoint) {
+
+    public void breakpointAdded(IBreakpoint breakpoint) {
+        ChromiumLineBreakpoint lineBreakpoint = tryCastBreakpoint(breakpoint);
+        if (lineBreakpoint == null) {
+            return;
+        }
+        if (ChromiumLineBreakpoint.getIgnoreList().contains(breakpoint)) {
+            return;
+        }
+        if (!lineBreakpoint.isEnabled()) {
+            return;
+        }
+        IFile file = (IFile) lineBreakpoint.getMarker().getResource();
+        VmResourceId vmResourceId;
+        try {
+            vmResourceId = findVmResourceIdFromWorkspaceFile(file);
+        } catch (CoreException e) {
+            ChromiumDebugPlugin.log(new Exception("Failed to resolve script for the file " + file, e)); //$NON-NLS-1$
+            return;
+        }
+        if (vmResourceId == null) {
+            // Might be a script from a different debug target
+            return;
+        }
+        createBreakpointOnRemote(lineBreakpoint, vmResourceId, null, null);
+    }
+
+    public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
+        ChromiumLineBreakpoint lineBreakpoint = tryCastBreakpoint(breakpoint);
+        if (lineBreakpoint == null) {
+            return;
+        }
+        if (ChromiumLineBreakpoint.getIgnoreList().contains(lineBreakpoint)) {
+            return;
+        }
+        Breakpoint sdkBreakpoint = breakpointInTargetMap.getSdkBreakpoint(lineBreakpoint);
+        if (sdkBreakpoint == null) {
+            return;
+        }
+
+        try {
+            ChromiumLineBreakpoint.Helper.updateOnRemote(sdkBreakpoint, lineBreakpoint);
+        } catch (RuntimeException e) {
+            ChromiumDebugPlugin.log(new Exception("Failed to change breakpoint in " + //$NON-NLS-1$
+                    getTargetNameSafe(), e));
+        }
+
+    }
+
+    public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
+        ChromiumLineBreakpoint lineBreakpoint = tryCastBreakpoint(breakpoint);
+        if (lineBreakpoint == null) {
+            return;
+        }
+        if (ChromiumLineBreakpoint.getIgnoreList().contains(lineBreakpoint)) {
+            return;
+        }
+
+        Breakpoint sdkBreakpoint = breakpointInTargetMap.getSdkBreakpoint(lineBreakpoint);
+        if (sdkBreakpoint == null) {
+            return;
+        }
+
+        try {
+            if (!breakpoint.isEnabled()) {
+            return;
+            }
+        } catch (CoreException e) {
+            ChromiumDebugPlugin.log(e);
+            return;
+        }
+        JavascriptVm.BreakpointCallback callback = new JavascriptVm.BreakpointCallback() {
+            public void failure(String errorMessage) {
+                ChromiumDebugPlugin.log(new Exception("Failed to remove breakpoint in " + //$NON-NLS-1$
+                        getTargetNameSafe() + ": " + errorMessage)); //$NON-NLS-1$
+            }
+
+            public void success(Breakpoint breakpoint) {
+            }
+        };
+        try {
+            sdkBreakpoint.clear(callback, null);
+        } catch (RuntimeException e) {
+            ChromiumDebugPlugin.log(new Exception("Failed to remove breakpoint in " + //$NON-NLS-1$
+                    getTargetNameSafe(), e));
+        }
+        breakpointInTargetMap.remove(lineBreakpoint);
+    }
+
+    public void breakpointsHit(Collection<? extends Breakpoint> breakpointsHit) {
+        if (breakpointsHit.isEmpty()) {
+            return;
+        }
+
+        for (Breakpoint sdkBreakpoint : breakpointsHit) {
+            ChromiumLineBreakpoint uiBreakpoint = breakpointInTargetMap.getUiBreakpoint(sdkBreakpoint);
+            if (uiBreakpoint != null) {
+                uiBreakpoint.setIgnoreCount(-1); // reset ignore count as we've hit it
+            }
+        }
+    }
+
+    public void createBreakpointOnRemote(final ChromiumLineBreakpoint lineBreakpoint, final VmResourceId vmResourceId,
+            final CreateCallback createCallback, SyncCallback syncCallback) {
+        try {
+            ChromiumLineBreakpoint.Helper.CreateOnRemoveCallback callback = new ChromiumLineBreakpoint.Helper.CreateOnRemoveCallback() {
+                public void failure(String errorMessage) {
+                    if (createCallback == null) {
+                        ChromiumDebugPlugin.logError(errorMessage);
+                    } else {
+                        createCallback.failure(new Exception(errorMessage));
+                    }
+                }
+
+                public void success(Breakpoint breakpoint) {
+                    breakpointInTargetMap.add(breakpoint, lineBreakpoint);
+                    if (createCallback != null) {
+                        createCallback.success();
+                    }
+                }
+            };
+
+            ChromiumLineBreakpoint.Helper.createOnRemote(lineBreakpoint, vmResourceId, debugTarget, callback,
+                    syncCallback);
+        } catch (CoreException e) {
+            ChromiumDebugPlugin.log(new Exception("Failed to create breakpoint in " + //$NON-NLS-1$
+                    getTargetNameSafe(), e));
+        }
+    }
+
+    private VmResourceId findVmResourceIdFromWorkspaceFile(IFile resource) throws CoreException {
+        return VmResourceId.forName(PreviewerPlugin.getDefault().getHttpPreviewer().getHttpUrl(resource));
+    }
+
+    private String getTargetNameSafe() {
+        try {
+            return debugTarget.getLaunch().getLaunchConfiguration().getName();
+        } catch (RuntimeException e) {
+          return "<unknown>"; //$NON-NLS-1$
+        }
+    }
+
+    public boolean supportsBreakpoint(IBreakpoint breakpoint) {
 		return (WRTProjectWorkspaceBridge.DEBUG_MODEL_ID.equals(breakpoint
 				.getModelIdentifier()) || VProjectWorkspaceBridge.DEBUG_MODEL_ID
 				.equals(breakpoint.getModelIdentifier()))
 				&& !debugTarget.isDisconnected();
 	}
 
-	public void registerBreakpoint(final ChromiumLineBreakpoint breakpoint,
-			final String script) throws CoreException {
-		final int line = (breakpoint.getLineNumber() - 1);
-		BreakpointCallback callback = new BreakpointCallback() {
-			public void success(Breakpoint b) {
-				breakpoint.setBreakpoint(b);
-			}
-
-			public void failure(String errorMessage) {
-				Activator.log(errorMessage);
-			}
-		};
-		// ILineBreakpoint lines are 1-based while V8 lines are 0-based
-		JavascriptVm javascriptVm = vm;
-		if (script != null) {
-			javascriptVm.setBreakpoint(Breakpoint.Type.SCRIPT_NAME, script
-					,line, Breakpoint.EMPTY_VALUE, breakpoint
-					.isEnabled(), breakpoint.getCondition(), breakpoint
-					.getIgnoreCount(), callback);
-		} else {
-			javascriptVm.setBreakpoint(Breakpoint.Type.SCRIPT_ID, String
-					.valueOf(script), line, Breakpoint.EMPTY_VALUE,
-					breakpoint.isEnabled(), breakpoint.getCondition(),
-					breakpoint.getIgnoreCount(), callback);
-		}
-	}
-
-	public void breakpointAdded(IBreakpoint breakpoint) {
-		if (!supportsBreakpoint(breakpoint)) {
-			return;
-		}
-        try {
-            // Class cast is ensured by the supportsBreakpoint implementation
-            final ChromiumLineBreakpoint lineBreakpoint = (ChromiumLineBreakpoint) breakpoint;
-            IFile file = (IFile) breakpoint.getMarker().getResource();
-            if (!resourceManager.isAddingFile(file)) {
-                final String script = resourceManager.translateResourceToScript(file);
-                if (script != null) {
-                    registerBreakpoint(lineBreakpoint, script);
-                }
-            }
-        } catch (CoreException e) {
-            Activator.log(e);
+    public ChromiumLineBreakpoint tryCastBreakpoint(IBreakpoint breakpoint) {
+        if (!supportsBreakpoint(breakpoint)) {
+            return null;
         }
-	}
-
-	public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
-		if (!supportsBreakpoint(breakpoint)) {
-			return;
-		}
-		// Class cast is ensured by the supportsBreakpoint implementation
-		((ChromiumLineBreakpoint) breakpoint).changed();
-	}
+        if (breakpoint instanceof ChromiumLineBreakpoint == false) {
+            return null;
+        }
+        return (ChromiumLineBreakpoint) breakpoint;
+    }
 
-	public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
-		if (!supportsBreakpoint(breakpoint)) {
-			return;
-		}
-		try {
-			if (breakpoint.isEnabled()) {
-				// Class cast is ensured by the supportsBreakpoint
-				// implementation
-				ChromiumLineBreakpoint lineBreakpoint = (ChromiumLineBreakpoint) breakpoint;
-				lineBreakpoint.clear();
-			}
-		} catch (CoreException e) {
-			ChromiumDebugPlugin.log(e);
-		}
-	}
-
-	public void breakpointsHit(
-			Collection<? extends Breakpoint> breakpointsHit) {
-		if (breakpointsHit.isEmpty()) {
-			return;
-		}
-		IBreakpoint[] breakpoints = DebugPlugin.getDefault()
-				.getBreakpointManager().getBreakpoints(WRTProjectWorkspaceBridge.DEBUG_MODEL_ID);
-		for (IBreakpoint breakpoint : breakpoints) {
-			ChromiumLineBreakpoint jsBreakpoint = (ChromiumLineBreakpoint) breakpoint;
-			if (breakpointsHit
-					.contains(jsBreakpoint.getBrowserBreakpoint())) {
-				jsBreakpoint.setIgnoreCount(-1); // reset ignore count as
-													// we've hit it
-			}
-		}
-	}
 }
\ No newline at end of file
diff -r 1f666f57e777 -r dd7d3426144c org.symbian.tools.wrttools/src/org/symbian/tools/wrttools/wizards/WgzImportWizardPage.java
--- a/org.symbian.tools.wrttools/src/org/symbian/tools/wrttools/wizards/WgzImportWizardPage.java	Tue Jun 08 16:06:40 2010 -0700
+++ b/org.symbian.tools.wrttools/src/org/symbian/tools/wrttools/wizards/WgzImportWizardPage.java	Tue Jun 08 16:12:51 2010 -0700
@@ -453,7 +453,7 @@
                 ZipEntry entry;
                 while ((entry = stream.getNextEntry()) != null) {
                     final IPath path = new Path(entry.getName());
-                    if (path.segmentCount() == 2 && CoreUtil.METADATA_FILE.equals(path.segment(1))) {
+                    if (path.segmentCount() == 2 && CoreUtil.METADATA_FILE.equalsIgnoreCase(path.segment(1))) {
                         return true;
                     }
                 }