diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java
index a010bfd9701c..e69fbd1ac460 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java
@@ -31,9 +31,7 @@ import com.intellij.debugger.impl.DebuggerContextListener;
 import com.intellij.debugger.impl.DebuggerManagerImpl;
 import com.intellij.debugger.impl.DebuggerSession;
 import com.intellij.debugger.ui.JavaDebuggerSupport;
-import com.intellij.openapi.application.AccessToken;
 import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.application.WriteAction;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
@@ -43,10 +41,7 @@ import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.startup.StartupManager;
 import com.intellij.openapi.ui.MessageType;
-import com.intellij.openapi.util.Comparing;
-import com.intellij.openapi.util.InvalidDataException;
-import com.intellij.openapi.util.Key;
-import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.*;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.VirtualFileManager;
 import com.intellij.psi.PsiDocumentManager;
@@ -273,22 +268,22 @@ public class BreakpointManager {
   }
 
   @NotNull
-  public ExceptionBreakpoint addExceptionBreakpoint(@NotNull String exceptionClassName, String packageName) {
+  public ExceptionBreakpoint addExceptionBreakpoint(@NotNull final String exceptionClassName, final String packageName) {
     ApplicationManager.getApplication().assertIsDispatchThread();
-    JavaExceptionBreakpointType type = (JavaExceptionBreakpointType)XDebuggerUtil.getInstance().findBreakpointType(JavaExceptionBreakpointType.class);
-    AccessToken token = WriteAction.start();
-    try {
-      XBreakpoint<JavaExceptionBreakpointProperties> xBreakpoint = XDebuggerManager.getInstance(myProject).getBreakpointManager()
-        .addBreakpoint(type, new JavaExceptionBreakpointProperties(exceptionClassName, packageName));
-      ExceptionBreakpoint breakpoint = new ExceptionBreakpoint(myProject, exceptionClassName, packageName, xBreakpoint);
-      addBreakpoint(breakpoint);
-      if (LOG.isDebugEnabled()) {
-        LOG.debug("ExceptionBreakpoint Added");
+    final JavaExceptionBreakpointType type = (JavaExceptionBreakpointType)XDebuggerUtil.getInstance().findBreakpointType(JavaExceptionBreakpointType.class);
+    return ApplicationManager.getApplication().runWriteAction(new Computable<ExceptionBreakpoint>() {
+      @Override
+      public ExceptionBreakpoint compute() {
+        XBreakpoint<JavaExceptionBreakpointProperties> xBreakpoint = XDebuggerManager.getInstance(myProject).getBreakpointManager()
+          .addBreakpoint(type, new JavaExceptionBreakpointProperties(exceptionClassName, packageName));
+        ExceptionBreakpoint breakpoint = new ExceptionBreakpoint(myProject, exceptionClassName, packageName, xBreakpoint);
+        addBreakpoint(breakpoint);
+        if (LOG.isDebugEnabled()) {
+          LOG.debug("ExceptionBreakpoint Added");
+        }
+        return breakpoint;
       }
-      return breakpoint;
-    } finally {
-      token.finish();
-    }
+    });
   }
 
   @Nullable
@@ -307,17 +302,17 @@ public class BreakpointManager {
     return breakpoint;
   }
 
-  private <B extends XBreakpoint<?>> XLineBreakpoint addXLineBreakpoint(Class<? extends XBreakpointType<B,?>> typeCls, Document document, int lineIndex) {
-    XBreakpointType<B, ?> type = XDebuggerUtil.getInstance().findBreakpointType(typeCls);
-    VirtualFile file = FileDocumentManager.getInstance().getFile(document);
-    AccessToken token = WriteAction.start();
-    try {
-      return XDebuggerManager.getInstance(myProject).getBreakpointManager()
-        .addLineBreakpoint((XLineBreakpointType)type, file.getUrl(), lineIndex,
-                           ((XLineBreakpointType)type).createBreakpointProperties(file, lineIndex));
-    } finally {
-      token.finish();
-    }
+  private <B extends XBreakpoint<?>> XLineBreakpoint addXLineBreakpoint(Class<? extends XBreakpointType<B,?>> typeCls, Document document, final int lineIndex) {
+    final XBreakpointType<B, ?> type = XDebuggerUtil.getInstance().findBreakpointType(typeCls);
+    final VirtualFile file = FileDocumentManager.getInstance().getFile(document);
+    return ApplicationManager.getApplication().runWriteAction(new Computable<XLineBreakpoint>() {
+      @Override
+      public XLineBreakpoint compute() {
+        return XDebuggerManager.getInstance(myProject).getBreakpointManager()
+          .addLineBreakpoint((XLineBreakpointType)type, file.getUrl(), lineIndex,
+                             ((XLineBreakpointType)type).createBreakpointProperties(file, lineIndex));
+      }
+    });
   }
 
   @Nullable
@@ -548,14 +543,13 @@ public class BreakpointManager {
 
   private <B extends XBreakpoint<?>> XBreakpoint createXBreakpoint(Class<? extends XBreakpointType<B, ?>> typeCls,
                                                                            Element breakpointNode) throws InvalidDataException {
-    XBreakpointType<B, ?> type = XDebuggerUtil.getInstance().findBreakpointType(typeCls);
-    AccessToken token = WriteAction.start();
-    try {
+    final XBreakpointType<B, ?> type = XDebuggerUtil.getInstance().findBreakpointType(typeCls);
+    return ApplicationManager.getApplication().runWriteAction(new Computable<XBreakpoint>() {
+      @Override
+      public XBreakpoint compute() {
       return XDebuggerManager.getInstance(myProject).getBreakpointManager()
         .addBreakpoint((XBreakpointType)type, type.createProperties());
-    } finally {
-      token.finish();
-    }
+    }});
   }
 
   private <B extends XBreakpoint<?>> XLineBreakpoint createXLineBreakpoint(Class<? extends XBreakpointType<B, ?>> typeCls,
@@ -601,12 +595,12 @@ public class BreakpointManager {
     if (breakpoint == null) {
       return;
     }
-    AccessToken token = WriteAction.start();
-    try {
-      getXBreakpointManager().removeBreakpoint(breakpoint.myXBreakpoint);
-    } finally {
-      token.finish();
-    }
+    ApplicationManager.getApplication().runWriteAction(new Runnable() {
+      @Override
+      public void run() {
+        getXBreakpointManager().removeBreakpoint(breakpoint.myXBreakpoint);
+      }
+    });
   }
 
   private synchronized void onBreakpointRemoved(@Nullable final XBreakpoint xBreakpoint) {
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaExceptionBreakpointType.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaExceptionBreakpointType.java
index 89f6e432b3d3..f19157b5bf7d 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaExceptionBreakpointType.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaExceptionBreakpointType.java
@@ -21,9 +21,9 @@ import com.intellij.debugger.engine.JVMNameUtil;
 import com.intellij.icons.AllIcons;
 import com.intellij.ide.util.TreeClassChooser;
 import com.intellij.ide.util.TreeClassChooserFactory;
-import com.intellij.openapi.application.AccessToken;
-import com.intellij.openapi.application.WriteAction;
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Computable;
 import com.intellij.psi.JavaPsiFacade;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiClassOwner;
@@ -44,7 +44,7 @@ import javax.swing.*;
 public class JavaExceptionBreakpointType extends JavaBreakpointTypeBase<JavaExceptionBreakpointProperties>
                                          implements JavaBreakpointType<JavaExceptionBreakpointProperties> {
   public JavaExceptionBreakpointType() {
-    super("javaException", DebuggerBundle.message("exception.breakpoints.tab.title"));
+    super("java-exception", DebuggerBundle.message("exception.breakpoints.tab.title"));
   }
 
   @NotNull
@@ -104,25 +104,24 @@ public class JavaExceptionBreakpointType extends JavaBreakpointTypeBase<JavaExce
 
   @Nullable
   @Override
-  public XBreakpoint<JavaExceptionBreakpointProperties> addBreakpoint(Project project, JComponent parentComponent) {
+  public XBreakpoint<JavaExceptionBreakpointProperties> addBreakpoint(final Project project, JComponent parentComponent) {
     final PsiClass throwableClass =
       JavaPsiFacade.getInstance(project).findClass("java.lang.Throwable", GlobalSearchScope.allScope(project));
     TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project)
       .createInheritanceClassChooser(DebuggerBundle.message("add.exception.breakpoint.classchooser.title"),
                                      GlobalSearchScope.allScope(project), throwableClass, true, true, null);
     chooser.showDialog();
-    PsiClass selectedClass = chooser.getSelected();
-    String qName = selectedClass == null ? null : JVMNameUtil.getNonAnonymousClassName(selectedClass);
+    final PsiClass selectedClass = chooser.getSelected();
+    final String qName = selectedClass == null ? null : JVMNameUtil.getNonAnonymousClassName(selectedClass);
 
     if (qName != null && qName.length() > 0) {
-      AccessToken token = WriteAction.start();
-      try {
-        return XDebuggerManager.getInstance(project).getBreakpointManager().addBreakpoint(
-          this, new JavaExceptionBreakpointProperties(qName, ((PsiClassOwner)selectedClass.getContainingFile()).getPackageName()));
-      }
-      finally {
-        token.finish();
-      }
+      return ApplicationManager.getApplication().runWriteAction(new Computable<XBreakpoint<JavaExceptionBreakpointProperties>>() {
+       @Override
+       public XBreakpoint<JavaExceptionBreakpointProperties> compute() {
+         return XDebuggerManager.getInstance(project).getBreakpointManager().addBreakpoint(
+           JavaExceptionBreakpointType.this, new JavaExceptionBreakpointProperties(qName, ((PsiClassOwner)selectedClass.getContainingFile()).getPackageName()));
+       }
+     });
     }
     return null;
   }
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaFieldBreakpointType.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaFieldBreakpointType.java
index 43860054bd8a..c539afe1263b 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaFieldBreakpointType.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaFieldBreakpointType.java
@@ -19,8 +19,7 @@ import com.intellij.CommonBundle;
 import com.intellij.debugger.DebuggerBundle;
 import com.intellij.debugger.HelpID;
 import com.intellij.icons.AllIcons;
-import com.intellij.openapi.application.AccessToken;
-import com.intellij.openapi.application.WriteAction;
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.Messages;
@@ -44,7 +43,7 @@ import javax.swing.*;
  */
 public class JavaFieldBreakpointType extends JavaLineBreakpointTypeBase<JavaFieldBreakpointProperties> implements JavaBreakpointType {
   public JavaFieldBreakpointType() {
-    super("javaField", DebuggerBundle.message("field.watchpoints.tab.title"));
+    super("java-field", DebuggerBundle.message("field.watchpoints.tab.title"));
   }
 
   @NotNull
@@ -114,7 +113,7 @@ public class JavaFieldBreakpointType extends JavaLineBreakpointTypeBase<JavaFiel
                                      DebuggerBundle.message("add.field.breakpoint.dialog.title"), Messages.getErrorIcon());
           return false;
         }
-        String fieldName = getFieldName();
+        final String fieldName = getFieldName();
         if (fieldName.length() == 0) {
           Messages.showMessageDialog(project, DebuggerBundle.message("error.field.breakpoint.field.name.not.specified"),
                                      DebuggerBundle.message("add.field.breakpoint.dialog.title"), Messages.getErrorIcon());
@@ -122,24 +121,21 @@ public class JavaFieldBreakpointType extends JavaLineBreakpointTypeBase<JavaFiel
         }
         PsiClass psiClass = JavaPsiFacade.getInstance(project).findClass(className, GlobalSearchScope.allScope(project));
         if (psiClass != null) {
-          PsiFile psiFile  = psiClass.getContainingFile();
+          final PsiFile psiFile  = psiClass.getContainingFile();
           Document document = PsiDocumentManager.getInstance(project).getDocument(psiFile);
           if(document != null) {
             PsiField field = psiClass.findFieldByName(fieldName, true);
             if(field != null) {
-              int line = document.getLineNumber(field.getTextOffset());
-              AccessToken token = WriteAction.start();
-              try {
-                XLineBreakpoint<JavaFieldBreakpointProperties> fieldBreakpoint = XDebuggerManager.getInstance(project).getBreakpointManager()
-                  .addLineBreakpoint(JavaFieldBreakpointType.this, psiFile.getVirtualFile().getUrl(), line, new JavaFieldBreakpointProperties(fieldName));
-                if (fieldBreakpoint != null) {
+              final int line = document.getLineNumber(field.getTextOffset());
+              ApplicationManager.getApplication().runWriteAction(new Runnable() {
+                @Override
+                public void run() {
+                  XLineBreakpoint<JavaFieldBreakpointProperties> fieldBreakpoint = XDebuggerManager.getInstance(project).getBreakpointManager()
+                    .addLineBreakpoint(JavaFieldBreakpointType.this, psiFile.getVirtualFile().getUrl(), line, new JavaFieldBreakpointProperties(fieldName));
                   result.set(fieldBreakpoint);
-                  return true;
                 }
-              }
-              finally {
-                token.finish();
-              }
+              });
+              return true;
             }
             else {
               Messages.showMessageDialog(project,
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaLineBreakpointType.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaLineBreakpointType.java
index 91b270e4c4fb..4f67e68d9003 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaLineBreakpointType.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaLineBreakpointType.java
@@ -38,7 +38,7 @@ import java.util.List;
  */
 public class JavaLineBreakpointType extends JavaLineBreakpointTypeBase<JavaBreakpointProperties> implements JavaBreakpointType {
   public JavaLineBreakpointType() {
-    super("javaLine", DebuggerBundle.message("line.breakpoints.tab.title"));
+    super("java-line", DebuggerBundle.message("line.breakpoints.tab.title"));
   }
 
   @NotNull
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaMethodBreakpointType.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaMethodBreakpointType.java
index d35983f03d2a..3e4afd7ac5cb 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaMethodBreakpointType.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaMethodBreakpointType.java
@@ -36,7 +36,7 @@ import javax.swing.*;
  */
 public class JavaMethodBreakpointType extends JavaLineBreakpointTypeBase<JavaMethodBreakpointProperties> implements JavaBreakpointType {
   public JavaMethodBreakpointType() {
-    super("javaMethod", DebuggerBundle.message("method.breakpoints.tab.title"));
+    super("java-method", DebuggerBundle.message("method.breakpoints.tab.title"));
   }
 
   @NotNull
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaWildcardMethodBreakpointType.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaWildcardMethodBreakpointType.java
index 3d19e35fea0b..dd28ee241f1a 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaWildcardMethodBreakpointType.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaWildcardMethodBreakpointType.java
@@ -18,9 +18,9 @@ package com.intellij.debugger.ui.breakpoints;
 import com.intellij.debugger.DebuggerBundle;
 import com.intellij.debugger.HelpID;
 import com.intellij.icons.AllIcons;
-import com.intellij.openapi.application.AccessToken;
-import com.intellij.openapi.application.WriteAction;
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Computable;
 import com.intellij.xdebugger.XDebuggerManager;
 import com.intellij.xdebugger.breakpoints.XBreakpoint;
 import com.intellij.xdebugger.breakpoints.ui.XBreakpointCustomPropertiesPanel;
@@ -35,7 +35,7 @@ import javax.swing.*;
  */
 public class JavaWildcardMethodBreakpointType extends JavaBreakpointTypeBase<JavaMethodBreakpointProperties> implements JavaBreakpointType {
   public JavaWildcardMethodBreakpointType() {
-    super("javaWildcardMethod", DebuggerBundle.message("method.breakpoints.tab.title"));
+    super("java-wildcard-method", DebuggerBundle.message("method.breakpoints.tab.title"));
   }
 
   @NotNull
@@ -84,21 +84,20 @@ public class JavaWildcardMethodBreakpointType extends JavaBreakpointTypeBase<Jav
 
   @Nullable
   @Override
-  public XBreakpoint<JavaMethodBreakpointProperties> addBreakpoint(Project project, JComponent parentComponent) {
-    AddWildcardBreakpointDialog dialog = new AddWildcardBreakpointDialog(project);
+  public XBreakpoint<JavaMethodBreakpointProperties> addBreakpoint(final Project project, JComponent parentComponent) {
+    final AddWildcardBreakpointDialog dialog = new AddWildcardBreakpointDialog(project);
     dialog.show();
     if (!dialog.isOK()) {
       return null;
     }
-    AccessToken token = WriteAction.start();
-    try {
-      return XDebuggerManager.getInstance(project).getBreakpointManager().addBreakpoint(this, new JavaMethodBreakpointProperties(
-        dialog.getClassPattern(),
-        dialog.getMethodName()));
-    }
-    finally {
-      token.finish();
-    }
+    return ApplicationManager.getApplication().runWriteAction(new Computable<XBreakpoint<JavaMethodBreakpointProperties>>() {
+      @Override
+      public XBreakpoint<JavaMethodBreakpointProperties> compute() {
+        return XDebuggerManager.getInstance(project).getBreakpointManager().addBreakpoint(JavaWildcardMethodBreakpointType.this, new JavaMethodBreakpointProperties(
+          dialog.getClassPattern(),
+          dialog.getMethodName()));
+      }
+    });
   }
 
   @Override