leaked CmdMerger in UndoManager in tests

doc/openapi/examples/vfs/src/com/intellij/openapi/samples/VfsSamplePlugin.java

@@ -24,10 +24,10 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.VirtualFileAdapter;
 import com.intellij.openapi.vfs.VirtualFileEvent;
 import com.intellij.openapi.vfs.VirtualFileManager;
+import org.jetbrains.annotations.NotNull;
 
 public class VfsSamplePlugin implements ProjectComponent {
   private final Project myProject;
-  private MyVfsListener myVfsListener;
 
   private static int ourJavaFilesCount;
 
@@ -41,17 +41,15 @@ public class VfsSamplePlugin implements ProjectComponent {
 
     ourJavaFilesCount = 0;
 
-    for (int i = 0; i < sourceRoots.length; i++) {
-      VirtualFile sourceRoot = sourceRoots[i];
+    for (VirtualFile sourceRoot : sourceRoots) {
       countJavaFiles(sourceRoot);
     }
 
-    myVfsListener = new MyVfsListener();
-    VirtualFileManager.getInstance().addVirtualFileListener(myVfsListener);
+    MyVfsListener vfsListener = new MyVfsListener();
+    VirtualFileManager.getInstance().addVirtualFileListener(vfsListener,myProject);
   }
 
   public void projectClosed() {
-    VirtualFileManager.getInstance().removeVirtualFileListener(myVfsListener);
   }
 
   public void initComponent() {
@@ -62,11 +60,12 @@ public class VfsSamplePlugin implements ProjectComponent {
     // empty
   }
 
+  @NotNull
   public String getComponentName() {
     return "VfsSample.VfsSamplePlugin";
   }
 
-  private void updateCount(VirtualFile file, int increase) {
+  private static void updateCount(VirtualFile file, int increase) {
     FileTypeManager fileTypeManager = FileTypeManager.getInstance();
     if (!fileTypeManager.isFileIgnored(file.getName())
       && fileTypeManager.getFileTypeByFile(file) == StdFileTypes.JAVA) {
@@ -75,11 +74,10 @@ public class VfsSamplePlugin implements ProjectComponent {
     }
   }
 
-  private void countJavaFiles(VirtualFile virtualFile) {
+  private static void countJavaFiles(VirtualFile virtualFile) {
     VirtualFile[] children = virtualFile.getChildren();
     if (children == null) return;
-    for (int i = 0; i < children.length; i++) {
-      VirtualFile child = children[i];
+    for (VirtualFile child : children) {
       updateCount(child, +1);
       countJavaFiles(child);
     }
@@ -89,7 +87,7 @@ public class VfsSamplePlugin implements ProjectComponent {
   // MyVfsListener
   // -------------------------------------------------------------------------
 
-  private class MyVfsListener extends VirtualFileAdapter {
+  private static class MyVfsListener extends VirtualFileAdapter {
     public void fileCreated(VirtualFileEvent event) {
       updateCount(event.getFile(), +1);
     }

java/compiler/impl/src/com/intellij/compiler/CompilerConfigurationImpl.java

@@ -78,6 +78,7 @@ public class CompilerConfigurationImpl extends CompilerConfiguration implements
   public CompilerConfigurationImpl(Project project) {
     myProject = project;
     myExcludedEntriesConfiguration = new ExcludedEntriesConfiguration();
+    Disposer.register(project, myExcludedEntriesConfiguration);
   }
 
   public Element getState() {
@@ -156,7 +157,6 @@ public class CompilerConfigurationImpl extends CompilerConfiguration implements
   }
 
   public void disposeComponent() {
-    Disposer.dispose(myExcludedEntriesConfiguration);
   }
 
   public void initComponent() { }

java/debugger/impl/src/com/intellij/debugger/impl/DebuggerManagerImpl.java

@@ -30,10 +30,12 @@ import com.intellij.openapi.projectRoots.JdkUtil;
 import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.projectRoots.ex.JavaSdkUtil;
 import com.intellij.openapi.startup.StartupManager;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.WriteExternalException;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.Disposable;
 import com.intellij.psi.PsiClass;
 import com.intellij.util.EventDispatcher;
 import com.intellij.util.Function;
@@ -80,8 +82,7 @@ public class DebuggerManagerImpl extends DebuggerManagerEx {
       }
     }
   };
-  private static final @NonNls String DEBUG_KEY_NAME = "idea.xdebug.key";
-  private final EditorColorsListener myColorsListener;
+  @NonNls private static final String DEBUG_KEY_NAME = "idea.xdebug.key";
 
   public void addClassNameMapper(final NameMapper mapper) {
     myNameMappers.add(mapper);
@@ -109,15 +110,20 @@ public class DebuggerManagerImpl extends DebuggerManagerEx {
     myDispatcher.removeListener(listener);
   }
 
-  public DebuggerManagerImpl(Project project, StartupManager startupManager, EditorColorsManager colorsManager) {
+  public DebuggerManagerImpl(Project project, StartupManager startupManager, final EditorColorsManager colorsManager) {
     myProject = project;
     myBreakpointManager = new BreakpointManager(myProject, startupManager, this);
-    myColorsListener = new EditorColorsListener() {
+    final EditorColorsListener myColorsListener = new EditorColorsListener() {
       public void globalSchemeChange(EditorColorsScheme scheme) {
         getBreakpointManager().updateBreakpointsUI();
       }
     };
     colorsManager.addEditorColorsListener(myColorsListener);
+    Disposer.register(project, new Disposable() {
+      public void dispose() {
+        colorsManager.removeEditorColorsListener(myColorsListener);
+      }
+    });
   }
 
   public DebuggerSession getSession(DebugProcess process) {
@@ -131,12 +137,11 @@ public class DebuggerManagerImpl extends DebuggerManagerEx {
   public Collection<DebuggerSession> getSessions() {
     synchronized (mySessions) {
       final Collection<DebuggerSession> values = mySessions.values();
-      return values.size() > 0 ? new ArrayList<DebuggerSession>(values) : Collections.<DebuggerSession>emptyList();
+      return values.isEmpty() ? Collections.<DebuggerSession>emptyList() : new ArrayList<DebuggerSession>(values);
     }
   }
 
   public void disposeComponent() {
-    EditorColorsManager.getInstance().removeEditorColorsListener(myColorsListener);
   }
 
   public void initComponent() {
@@ -301,7 +306,7 @@ public class DebuggerManagerImpl extends DebuggerManagerEx {
     myCustomPositionManagerFactories.remove(factory);
   }
 
-  static private boolean hasWhitespace(String string) {
+  private static boolean hasWhitespace(String string) {
     int length = string.length();
     for (int i = 0; i < length; i++) {
       if (Character.isWhitespace(string.charAt(i))) {
@@ -318,10 +323,10 @@ public class DebuggerManagerImpl extends DebuggerManagerEx {
       throw new ExecutionException(DebuggerBundle.message("error.jdk.not.specified"));
     }
     final String versionString = jdk.getVersionString();
-    if (versionString.indexOf("1.0") > -1 || versionString.indexOf("1.1") > -1) {
+    if (versionString.contains("1.0") || versionString.contains("1.1")) {
       throw new ExecutionException(DebuggerBundle.message("error.unsupported.jdk.version", versionString));
     }
-    if (SystemInfo.isWindows && versionString.indexOf("1.2") > -1) {
+    if (SystemInfo.isWindows && versionString.contains("1.2")) {
       final VirtualFile homeDirectory = jdk.getHomeDirectory();
       if (homeDirectory == null || !homeDirectory.isValid()) {
         throw new ExecutionException(DebuggerBundle.message("error.invalid.jdk.home", versionString));

java/debugger/impl/src/com/intellij/debugger/ui/DebuggerPanelsManager.java

@@ -30,6 +30,7 @@ import com.intellij.openapi.editor.colors.EditorColorsManager;
 import com.intellij.openapi.editor.colors.EditorColorsScheme;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.Disposable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -44,22 +45,28 @@ public class DebuggerPanelsManager implements ProjectComponent {
   private static final Logger LOG = Logger.getInstance("#com.intellij.debugger.ui.DebuggerPanelsManager");
 
   private final Project myProject;
+  private final ExecutionManager myExecutionManager;
 
   private final PositionHighlighter myEditorManager;
   private final HashMap<ProcessHandler, DebuggerSessionTab> mySessionTabs = new HashMap<ProcessHandler, DebuggerSessionTab>();
-  private final EditorColorsListener myColorsListener;
 
-  public DebuggerPanelsManager(Project project, EditorColorsManager colorsManager) {
+  public DebuggerPanelsManager(Project project, final EditorColorsManager colorsManager, ExecutionManager executionManager) {
     myProject = project;
+    myExecutionManager = executionManager;
 
     myEditorManager = new PositionHighlighter(myProject, getContextManager());
 
-    myColorsListener = new EditorColorsListener() {
+    final EditorColorsListener myColorsListener = new EditorColorsListener() {
       public void globalSchemeChange(EditorColorsScheme scheme) {
         myEditorManager.updateContextPointDescription();
       }
     };
     colorsManager.addEditorColorsListener(myColorsListener);
+    Disposer.register(project, new Disposable() {
+      public void dispose() {
+        colorsManager.removeEditorColorsListener(myColorsListener);
+      }
+    });
 
     getContextManager().addListener(new DebuggerContextListener() {
       public void changeEvent(final DebuggerContextImpl newContext, int event) {
@@ -78,31 +85,8 @@ public class DebuggerPanelsManager implements ProjectComponent {
     return DebuggerManagerEx.getInstanceEx(myProject).getContextManager();
   }
 
-  private final RunContentListener myContentListener = new RunContentListener() {
-    public void contentSelected(RunContentDescriptor descriptor) {
-      DebuggerSessionTab sessionTab = descriptor != null ? getSessionTab(descriptor.getProcessHandler()) : null;
-
-      if (sessionTab != null) {
-        getContextManager()
-          .setState(sessionTab.getContextManager().getContext(), sessionTab.getSession().getState(), DebuggerSession.EVENT_CONTEXT, null);
-      }
-      else {
-        getContextManager()
-          .setState(DebuggerContextImpl.EMPTY_CONTEXT, DebuggerSession.STATE_DISPOSED, DebuggerSession.EVENT_CONTEXT, null);
-      }
-    }
-
-    public void contentRemoved(RunContentDescriptor descriptor) {
-      DebuggerSessionTab sessionTab = getSessionTab(descriptor.getProcessHandler());
-      if (sessionTab != null) {
-        mySessionTabs.remove(descriptor.getProcessHandler());
-        Disposer.dispose(sessionTab);
-      }
-    }
-  };
-
-  public
   @Nullable
+  public
   RunContentDescriptor attachVirtualMachine(Executor executor,
                                             ProgramRunner runner,
                                             ExecutionEnvironment environment,
@@ -146,14 +130,41 @@ public class DebuggerPanelsManager implements ProjectComponent {
 
 
   public void projectOpened() {
-    RunContentManager contentManager = ExecutionManager.getInstance(myProject).getContentManager();
+    final RunContentManager contentManager = myExecutionManager.getContentManager();
     LOG.assertTrue(contentManager != null, "Content manager is null");
+
+    final RunContentListener myContentListener = new RunContentListener() {
+      public void contentSelected(RunContentDescriptor descriptor) {
+        DebuggerSessionTab sessionTab = descriptor != null ? getSessionTab(descriptor.getProcessHandler()) : null;
+
+        if (sessionTab != null) {
+          getContextManager()
+            .setState(sessionTab.getContextManager().getContext(), sessionTab.getSession().getState(), DebuggerSession.EVENT_CONTEXT, null);
+        }
+        else {
+          getContextManager()
+            .setState(DebuggerContextImpl.EMPTY_CONTEXT, DebuggerSession.STATE_DISPOSED, DebuggerSession.EVENT_CONTEXT, null);
+        }
+      }
+
+      public void contentRemoved(RunContentDescriptor descriptor) {
+        DebuggerSessionTab sessionTab = getSessionTab(descriptor.getProcessHandler());
+        if (sessionTab != null) {
+          mySessionTabs.remove(descriptor.getProcessHandler());
+          Disposer.dispose(sessionTab);
+        }
+      }
+    };
+
     contentManager.addRunContentListener(myContentListener, DefaultDebugExecutor.getDebugExecutorInstance());
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        contentManager.removeRunContentListener(myContentListener);
+      }
+    });
   }
 
   public void projectClosed() {
-    final RunContentManager contentManager = ExecutionManager.getInstance(myProject).getContentManager();
-    contentManager.removeRunContentListener(myContentListener);
   }
 
   @NotNull
@@ -165,7 +176,6 @@ public class DebuggerPanelsManager implements ProjectComponent {
   }
 
   public void disposeComponent() {
-    EditorColorsManager.getInstance().removeEditorColorsListener(myColorsListener);
   }
 
   public static DebuggerPanelsManager getInstance(Project project) {
@@ -181,8 +191,7 @@ public class DebuggerPanelsManager implements ProjectComponent {
   @Nullable
   public DebuggerSessionTab getSessionTab() {
     DebuggerContextImpl context = DebuggerManagerEx.getInstanceEx(myProject).getContext();
-    DebuggerSessionTab sessionTab = getSessionTab(context.getDebuggerSession());
-    return sessionTab;
+    return getSessionTab(context.getDebuggerSession());
   }
 
   public void showFramePanel() {

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java

@@ -76,36 +76,11 @@ public class BreakpointManager implements JDOMExternalizable {
   private final Map<Key<? extends Breakpoint>, String> myDefaultSuspendPolicies = new HashMap<Key<? extends Breakpoint>, String>();
 
   private BreakpointsConfigurationDialogFactory myBreakpointsConfigurable;
-  private EditorMouseListener myEditorMouseListener;
 
   private final EventDispatcher<BreakpointManagerListener> myDispatcher = EventDispatcher.create(BreakpointManagerListener.class);
 
   private final StartupManager myStartupManager;
 
-  private final DocumentListener myDocumentListener = new DocumentAdapter() {
-    private final Alarm myUpdateAlarm = new Alarm();
-
-    public void documentChanged(final DocumentEvent e) {
-      final Document document = e.getDocument();
-      synchronized (BreakpointManager.this) {
-        List<BreakpointWithHighlighter> breakpoints = myDocumentBreakpoints.get(document);
-
-        if(breakpoints != null) {
-          myUpdateAlarm.cancelAllRequests();
-          // must create new array in order to avoid "concurrent modification" errors
-          final List<BreakpointWithHighlighter> breakpointsToUpdate = new ArrayList<BreakpointWithHighlighter>(breakpoints);
-          myUpdateAlarm.addRequest(new Runnable() {
-            public void run() {
-              if (!myProject.isDisposed()) {
-                PsiDocumentManager.getInstance(myProject).commitDocument(document);
-                update(breakpointsToUpdate);
-              }
-            }
-          }, 300, ModalityState.NON_MODAL);
-        }
-      }
-    }
-  };
   @NonNls private static final String MASTER_BREAKPOINT_TAGNAME = "master_breakpoint";
   @NonNls private static final String SLAVE_BREAKPOINT_TAGNAME = "slave_breakpoint";
   @NonNls private static final String DEFAULT_SUSPEND_POLICY_ATTRIBUTE_NAME = "default_suspend_policy";
@@ -179,7 +154,7 @@ public class BreakpointManager implements JDOMExternalizable {
 
   public void init() {
     EditorEventMulticaster eventMulticaster = EditorFactory.getInstance().getEventMulticaster();
-    myEditorMouseListener = new EditorMouseAdapter() {
+    EditorMouseAdapter myEditorMouseListener = new EditorMouseAdapter() {
       private EditorMouseEvent myMousePressedEvent;
 
       @Nullable
@@ -202,7 +177,7 @@ public class BreakpointManager implements JDOMExternalizable {
 
         int offset = editor.getCaretModel().getOffset();
         int editorLine = editor.getDocument().getLineNumber(offset);
-        if(editorLine != line) {
+        if (editorLine != line) {
           if (line < 0 || line >= document.getLineCount()) {
             return null;
           }
@@ -213,7 +188,7 @@ public class BreakpointManager implements JDOMExternalizable {
 
         Breakpoint breakpoint = findBreakpoint(document, offset, null);
         if (breakpoint == null) {
-          if(mostSuitingBreakpoint || isInsideCompiledClass) {
+          if (mostSuitingBreakpoint || isInsideCompiledClass) {
             breakpoint = addFieldBreakpoint(document, offset);
             if (breakpoint == null) {
               breakpoint = addMethodBreakpoint(document, line);
@@ -230,7 +205,7 @@ public class BreakpointManager implements JDOMExternalizable {
             }
           }
 
-          if(breakpoint != null) {
+          if (breakpoint != null) {
             RequestManagerImpl.createRequests(breakpoint);
           }
           return breakpoint;
@@ -267,7 +242,7 @@ public class BreakpointManager implements JDOMExternalizable {
       }
 
       public void mouseReleased(EditorMouseEvent e) {
-        if(myMousePressedEvent != null) {
+        if (myMousePressedEvent != null) {
           mouseClicked(e);
         }
         myMousePressedEvent = null;
@@ -303,16 +278,21 @@ public class BreakpointManager implements JDOMExternalizable {
                 public void run() {
                   Breakpoint breakpoint = toggleBreakpoint(e.getMouseEvent().isAltDown(), line);
 
-                  if(e.getMouseEvent().isShiftDown() && breakpoint != null) {
+                  if (e.getMouseEvent().isShiftDown() && breakpoint != null) {
                     breakpoint.LOG_EXPRESSION_ENABLED = true;
                     final TextWithImports logMessage = DebuggerUtilsEx.getEditorText(editor);
-                    breakpoint.setLogMessage(logMessage != null? logMessage : new TextWithImportsImpl(CodeFragmentKind.EXPRESSION, DebuggerBundle.message("breakpoint.log.message", breakpoint.getDisplayName())));
+                    breakpoint.setLogMessage(logMessage != null
+                                             ? logMessage
+                                             : new TextWithImportsImpl(CodeFragmentKind.EXPRESSION,
+                                                                       DebuggerBundle.message("breakpoint.log.message",
+                                                                                              breakpoint.getDisplayName())));
                     breakpoint.SUSPEND_POLICY = DebuggerSettings.SUSPEND_NONE;
 
-                    DialogWrapper dialog = DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().createConfigurationDialog(breakpoint, BreakpointPropertiesPanel.CONTROL_LOG_MESSAGE);
+                    DialogWrapper dialog = DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager()
+                      .createConfigurationDialog(breakpoint, BreakpointPropertiesPanel.CONTROL_LOG_MESSAGE);
                     dialog.show();
 
-                    if(!dialog.isOK()) {
+                    if (!dialog.isOK()) {
                       removeBreakpoint(breakpoint);
                     }
                   }
@@ -325,6 +305,32 @@ public class BreakpointManager implements JDOMExternalizable {
     };
 
     eventMulticaster.addEditorMouseListener(myEditorMouseListener, myProject);
+
+    final DocumentListener myDocumentListener = new DocumentAdapter() {
+      private final Alarm myUpdateAlarm = new Alarm();
+
+      public void documentChanged(final DocumentEvent e) {
+        final Document document = e.getDocument();
+        synchronized (BreakpointManager.this) {
+          List<BreakpointWithHighlighter> breakpoints = myDocumentBreakpoints.get(document);
+
+          if(breakpoints != null) {
+            myUpdateAlarm.cancelAllRequests();
+            // must create new array in order to avoid "concurrent modification" errors
+            final List<BreakpointWithHighlighter> breakpointsToUpdate = new ArrayList<BreakpointWithHighlighter>(breakpoints);
+            myUpdateAlarm.addRequest(new Runnable() {
+              public void run() {
+                if (!myProject.isDisposed()) {
+                  PsiDocumentManager.getInstance(myProject).commitDocument(document);
+                  update(breakpointsToUpdate);
+                }
+              }
+            }, 300, ModalityState.NON_MODAL);
+          }
+        }
+      }
+    };
+
     eventMulticaster.addDocumentListener(myDocumentListener, myProject);
   }
 

java/idea-ui/src/com/intellij/facet/impl/autodetecting/FacetAutodetectingManagerImpl.java

@@ -13,7 +13,6 @@ import com.intellij.facet.autodetecting.UnderlyingFacetSelector;
 import com.intellij.facet.impl.autodetecting.model.FacetInfo2;
 import com.intellij.facet.impl.autodetecting.model.ProjectFacetInfoSet;
 import com.intellij.facet.pointers.FacetPointersManager;
-import com.intellij.ide.impl.convert.ProjectFileVersion;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.components.PersistentStateComponent;
 import com.intellij.openapi.components.ProjectComponent;
@@ -58,7 +57,6 @@ public class FacetAutodetectingManagerImpl extends FacetAutodetectingManager imp
   private final PsiManager myPsiManager;
   private final FacetPointersManager myFacetPointersManager;
   private FacetDetectionIndex myFileIndex;
-  private MyPsiTreeChangeListener myPsiTreeChangeListener;
   private MergingUpdateQueue myMergingUpdateQueue;
   private final ProjectFacetInfoSet myDetectedFacetSet;
   private DetectedFacetManager myDetectedFacetManager;
@@ -116,8 +114,8 @@ public class FacetAutodetectingManagerImpl extends FacetAutodetectingManager imp
     }
     myFileIndex = new FacetDetectionIndex(myProject, this, myDetectors.keySet());
     myFileIndex.initialize();
-    myPsiTreeChangeListener = new MyPsiTreeChangeListener();
-    myPsiManager.addPsiTreeChangeListener(myPsiTreeChangeListener, myProject);
+    MyPsiTreeChangeListener psiTreeChangeListener = new MyPsiTreeChangeListener();
+    myPsiManager.addPsiTreeChangeListener(psiTreeChangeListener, myProject);
     myMergingUpdateQueue = new MergingUpdateQueue("FacetAutodetectionQueue", 500, true, null, myProject);
   }
 
@@ -146,7 +144,7 @@ public class FacetAutodetectingManagerImpl extends FacetAutodetectingManager imp
   public void processFile(VirtualFile virtualFile) {
     if (!virtualFile.isValid() || virtualFile.isDirectory() || myProject.isDisposed()
         || !virtualFile.exists() || !myFileIndex.getProjectFileIndex().isInContent(virtualFile)) return;
-    
+
     FileType fileType = virtualFile.getFileType();
     Collection<FacetDetectorWrapper> detectors = myDetectors.get(fileType);
     if (detectors == null) return;
@@ -319,7 +317,7 @@ public class FacetAutodetectingManagerImpl extends FacetAutodetectingManager imp
     return myDetectedFacetManager;
   }
 
-  @Nullable 
+  @Nullable
   public FacetDetector<?,?> findDetector(final String detectorId) {
     return myId2Detector.get(detectorId);
   }

java/testFramework/src/com/intellij/testFramework/ModuleTestCase.java

@@ -61,10 +61,6 @@ public abstract class ModuleTestCase extends IdeaTestCase {
     return createModule(path, moduleType);
   }
 
-  protected Module createModule(final String path) {
-    return createModule(path, StdModuleTypes.JAVA);
-  }
-
   protected Module createModule(final String path, final ModuleType moduleType) {
     Module module = ApplicationManager.getApplication().runWriteAction(
       new Computable<Module>() {

platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/DaemonCodeAnalyzerImpl.java

@@ -112,6 +112,8 @@ public class DaemonCodeAnalyzerImpl extends DaemonCodeAnalyzer implements JDOMEx
         return myDisposed || super.isDisposed();
       }
     };
+    Disposer.register(project, myPassExecutorService);
+    Disposer.register(project, myFileStatusMap);
   }
 
   @NotNull
@@ -120,16 +122,15 @@ public class DaemonCodeAnalyzerImpl extends DaemonCodeAnalyzer implements JDOMEx
   }
 
   public void initComponent() {
-    myFileStatusMap.markAllFilesDirty();
   }
 
   public void disposeComponent() {
-    myFileStatusMap.markAllFilesDirty();
   }
 
   public void projectOpened() {
     assert !myInitialized : "Double Initializing";
     myStatusBarUpdater = new StatusBarUpdater(myProject);
+    Disposer.register(myProject, myStatusBarUpdater);
 
     myDaemonListeners = new DaemonListeners(myProject, this, myEditorTracker);
     Disposer.register(myProject, myDaemonListeners);
@@ -148,8 +149,6 @@ public class DaemonCodeAnalyzerImpl extends DaemonCodeAnalyzer implements JDOMEx
     myFileStatusMap.markAllFilesDirty();
 
     stopProcess(false);
-    myPassExecutorService.dispose();
-    myStatusBarUpdater.dispose();
 
     myDisposed = true;
     myLastSettings = null;

platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/EditorTracker.java

@@ -1,6 +1,6 @@
 package com.intellij.codeInsight.daemon.impl;
 
-import com.intellij.openapi.components.ProjectComponent;
+import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.EditorFactory;
@@ -10,10 +10,12 @@ import com.intellij.openapi.fileEditor.FileEditorManager;
 import com.intellij.openapi.fileEditor.FileEditorManagerAdapter;
 import com.intellij.openapi.fileEditor.FileEditorManagerEvent;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.wm.ToolWindowManager;
 import com.intellij.openapi.wm.WindowManager;
 import com.intellij.openapi.wm.ex.WindowManagerEx;
 import com.intellij.openapi.wm.impl.IdeFrameImpl;
+import com.intellij.openapi.Disposable;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiFile;
 import com.intellij.util.EventDispatcher;
@@ -27,10 +29,9 @@ import java.awt.event.*;
 import java.util.*;
 import java.util.List;
 
-public class EditorTracker implements ProjectComponent {
+public class EditorTracker extends AbstractProjectComponent {
   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.daemon.impl.EditorTracker");
 
-  private final Project myProject;
   private final WindowManager myWindowManager;
   private final EditorFactory myEditorFactory;
   private final FileEditorManager myFileEditorManager;
@@ -67,15 +68,13 @@ public class EditorTracker implements ProjectComponent {
   //it actually initializes frame in WindowManager
   public EditorTracker(Project project, final WindowManager windowManager, final EditorFactory editorFactory,
                        final FileEditorManager fileEditorManager, ToolWindowManager toolwindowManager) {
-    myProject = project;
+    super(project);
     myWindowManager = windowManager;
     myEditorFactory = editorFactory;
     myFileEditorManager = fileEditorManager;
     myToolwindowManager = toolwindowManager;
-
   }
 
-
   public void projectOpened() {
     myIdeFrame = ((WindowManagerEx)myWindowManager).getFrame(myProject);
     myFileEditorManager.addFileEditorManagerListener(new FileEditorManagerAdapter() {
@@ -83,23 +82,24 @@ public class EditorTracker implements ProjectComponent {
         if (myIdeFrame.getFocusOwner() == null) return;
         setActiveWindow(myIdeFrame);
       }
-    });
+    }, myProject);
     if (myIdeFrame != null) {
       myIdeFrame.addWindowFocusListener(myIdeFrameFocusListener);
+      Disposer.register(myProject, new Disposable() {
+        public void dispose() {
+          myIdeFrame.removeWindowFocusListener(myIdeFrameFocusListener);
+        }
+      });
     }
 
     myEditorFactoryListener = new MyEditorFactoryListener();
     myEditorFactory.addEditorFactoryListener(myEditorFactoryListener);
-  }
-
-  public void projectClosed() {
-    if (myEditorFactoryListener != null) {
-      myEditorFactoryListener.dispose(null);
-      myEditorFactory.removeEditorFactoryListener(myEditorFactoryListener);
-    }
-    if (myIdeFrame != null) {
-      myIdeFrame.removeWindowFocusListener(myIdeFrameFocusListener);
-    }
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        myEditorFactoryListener.dispose(null);
+        myEditorFactory.removeEditorFactoryListener(myEditorFactoryListener);
+      }
+    });
   }
 
   @NonNls
@@ -108,12 +108,6 @@ public class EditorTracker implements ProjectComponent {
     return "EditorTracker";
   }
 
-  public void initComponent() {
-  }
-
-  public void disposeComponent() {
-  }
-
   private void editorFocused(Editor editor) {
     Window window = myEditorToWindowMap.get(editor);
     if (window == null) return;

platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/FileStatusMap.java

@@ -13,6 +13,7 @@ import com.intellij.openapi.editor.ex.RangeMarkerEx;
 import com.intellij.openapi.editor.ex.DocumentEx;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.Disposable;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiFile;
 import com.intellij.util.containers.WeakHashMap;
@@ -24,7 +25,7 @@ import org.jetbrains.annotations.Nullable;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 
-public class FileStatusMap {
+public class FileStatusMap implements Disposable {
   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.daemon.impl.FileStatusMap");
   private final Project myProject;
   private final Map<Document,FileStatus> myDocumentToStatusMap = new WeakHashMap<Document, FileStatus>(); // all dirty if absent
@@ -34,6 +35,10 @@ public class FileStatusMap {
     myProject = project;
   }
 
+  public void dispose() {
+    markAllFilesDirty();
+  }
+
   @Nullable
   public static TextRange getDirtyTextRange(@NotNull Editor editor, int passId) {
     Document document = editor.getDocument();

platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/StatusBarUpdater.java

@@ -2,6 +2,7 @@
 package com.intellij.codeInsight.daemon.impl;
 
 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
@@ -19,20 +20,19 @@ import com.intellij.openapi.wm.StatusBar;
 import com.intellij.openapi.wm.WindowManager;
 import com.intellij.openapi.wm.ex.StatusBarEx;
 
-public class StatusBarUpdater {
+public class StatusBarUpdater implements Disposable {
   private final Project myProject;
-  private final CaretListener myCaretListener;
   private final UpdateStatusRunnable myUpdateStatusRunnable = new UpdateStatusRunnable();
 
   public StatusBarUpdater(Project project) {
     myProject = project;
 
-    myCaretListener = new CaretListener() {
+    CaretListener caretListener = new CaretListener() {
       public void caretPositionChanged(CaretEvent e) {
         ApplicationManager.getApplication().invokeLater(myUpdateStatusRunnable);
       }
     };
-    EditorFactory.getInstance().getEventMulticaster().addCaretListener(myCaretListener);
+    EditorFactory.getInstance().getEventMulticaster().addCaretListener(caretListener, this);
 
     project.getMessageBus().connect().subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, new FileEditorManagerAdapter() {
       @Override
@@ -43,7 +43,6 @@ public class StatusBarUpdater {
   }
 
   public void dispose() {
-    EditorFactory.getInstance().getEventMulticaster().removeCaretListener(myCaretListener);
   }
 
   public void updateStatus() {

platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/WholeFileLocalInspectionsPassFactory.java

@@ -9,7 +9,9 @@ import com.intellij.codeInspection.ex.InspectionProfileWrapper;
 import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.Disposable;
 import com.intellij.profile.Profile;
 import com.intellij.profile.ProfileChangeAdapter;
 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
@@ -28,18 +30,7 @@ import java.util.Map;
  * @author cdr
 */
 public class WholeFileLocalInspectionsPassFactory extends AbstractProjectComponent implements TextEditorHighlightingPassFactory {
-  private Map<PsiFile, Boolean> myFileTools = new ConcurrentWeakHashMap<PsiFile, Boolean>();
-  private ProfileChangeAdapter myProfilesListener = new ProfileChangeAdapter() {
-    @Override
-    public void profileChanged(Profile profile) {
-      myFileTools.clear();
-    }
-
-    @Override
-    public void profileActivated(Profile oldProfile, Profile profile) {
-      myFileTools.clear();
-    }
-  };
+  private final Map<PsiFile, Boolean> myFileTools = new ConcurrentWeakHashMap<PsiFile, Boolean>();
   public InspectionProjectProfileManager myProfileManager;
 
   public WholeFileLocalInspectionsPassFactory(Project project, TextEditorHighlightingPassRegistrar highlightingPassRegistrar,
@@ -57,17 +48,25 @@ public class WholeFileLocalInspectionsPassFactory extends AbstractProjectCompone
   }
 
   @Override
-  public void initComponent() {
-    super.initComponent();
+  public void projectOpened() {
+    final ProfileChangeAdapter myProfilesListener = new ProfileChangeAdapter() {
+      @Override
+      public void profileChanged(Profile profile) {
+        myFileTools.clear();
+      }
+
+      @Override
+      public void profileActivated(Profile oldProfile, Profile profile) {
+        myFileTools.clear();
+      }
+    };
     myProfileManager.addProfilesListener(myProfilesListener);
-  }
-
-  @Override
-  public void disposeComponent() {
-    super.disposeComponent();
-
-    myProfileManager.removeProfilesListener(myProfilesListener);
-    myFileTools.clear();
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        myProfileManager.removeProfilesListener(myProfilesListener);
+        myFileTools.clear();
+      }
+    });
   }
 
   @Nullable

platform/lang-impl/src/com/intellij/codeInsight/folding/impl/CodeFoldingManagerImpl.java

@@ -36,8 +36,6 @@ import java.awt.event.MouseEvent;
 public class CodeFoldingManagerImpl extends CodeFoldingManager implements ProjectComponent {
   private final Project myProject;
 
-  private EditorMouseMotionAdapter myMouseMotionListener;
-
   private final WeakList<Document> myDocumentsWithFoldingInfo = new WeakList<Document>();
 
   private final Key<DocumentFoldingInfo> FOLDING_INFO_IN_DOCUMENT_KEY = Key.create("FOLDING_INFO_IN_DOCUMENT_KEY");
@@ -68,7 +66,7 @@ public class CodeFoldingManagerImpl extends CodeFoldingManager implements Projec
   }
 
   public void projectOpened() {
-    myMouseMotionListener = new EditorMouseMotionAdapter() {
+    final EditorMouseMotionAdapter myMouseMotionListener = new EditorMouseMotionAdapter() {
       LightweightHint myCurrentHint = null;
       FoldRegion myCurrentFold = null;
 
@@ -121,7 +119,7 @@ public class CodeFoldingManagerImpl extends CodeFoldingManager implements Projec
 
     StartupManager.getInstance(myProject).registerPostStartupActivity(new DumbAwareRunnable() {
       public void run() {
-        EditorFactory.getInstance().getEventMulticaster().addEditorMouseMotionListener(myMouseMotionListener);
+        EditorFactory.getInstance().getEventMulticaster().addEditorMouseMotionListener(myMouseMotionListener, myProject);
       }
     });
   }
@@ -181,7 +179,6 @@ public class CodeFoldingManagerImpl extends CodeFoldingManager implements Projec
   }
 
   public void projectClosed() {
-    EditorFactory.getInstance().getEventMulticaster().removeEditorMouseMotionListener(myMouseMotionListener);
   }
 
   public FoldRegion findFoldRegion(@NotNull Editor editor, int startOffset, int endOffset) {

platform/lang-impl/src/com/intellij/codeInsight/highlighting/BraceHighlighter.java

@@ -1,6 +1,7 @@
 package com.intellij.codeInsight.highlighting;
 
-import com.intellij.openapi.components.ProjectComponent;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.EditorFactory;
@@ -15,21 +16,15 @@ import com.intellij.openapi.project.DumbAwareRunnable;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.startup.StartupManager;
 import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.Disposable;
 import com.intellij.util.Alarm;
 import com.intellij.util.Processor;
 import org.jetbrains.annotations.NotNull;
 
-public class BraceHighlighter implements ProjectComponent {
-  private final Project myProject;
+public class BraceHighlighter extends AbstractProjectComponent {
   private final Alarm myAlarm = new Alarm();
-  private CaretListener myCaretListener;
-  private SelectionListener mySelectionListener;
-  private DocumentListener myDocumentListener;
-  private FocusChangeListener myFocusChangeListener;
 
   public BraceHighlighter(Project project) {
-    myProject = project;
+    super(project);
   }
 
   @NotNull
@@ -37,77 +32,74 @@ public class BraceHighlighter implements ProjectComponent {
     return "BraceHighlighter";
   }
 
-  public void initComponent() { }
-
-  public void disposeComponent() {
-  }
-
   public void projectOpened() {
     StartupManager.getInstance(myProject).registerPostStartupActivity(new DumbAwareRunnable() {
       public void run() {
+        doinit();
+      }
+    });
+  }
+
+  private void doinit() {
+    final EditorEventMulticaster eventMulticaster = EditorFactory.getInstance().getEventMulticaster();
+
+    CaretListener myCaretListener = new CaretListener() {
+      public void caretPositionChanged(CaretEvent e) {
+        myAlarm.cancelAllRequests();
+        Editor editor = e.getEditor();
+        if (editor.getProject() == myProject) {
+          updateBraces(editor, myAlarm);
+        }
+      }
+    };
+    eventMulticaster.addCaretListener(myCaretListener, myProject);
+
+    final SelectionListener mySelectionListener = new SelectionListener() {
+      public void selectionChanged(SelectionEvent e) {
+        myAlarm.cancelAllRequests();
+        Editor editor = e.getEditor();
+        if (editor.getProject() == myProject) {
+          updateBraces(editor, myAlarm);
+        }
+      }
+    };
+    eventMulticaster.addSelectionListener(mySelectionListener);
+
+    DocumentListener documentListener = new DocumentAdapter() {
+      public void documentChanged(DocumentEvent e) {
+        myAlarm.cancelAllRequests();
+        Editor[] editors = EditorFactory.getInstance().getEditors(e.getDocument(), myProject);
+        for (Editor editor : editors) {
+          updateBraces(editor, myAlarm);
+        }
+      }
+    };
+    eventMulticaster.addDocumentListener(documentListener, myProject);
+
+    final FocusChangeListener myFocusChangeListener = new FocusChangeListener() {
+      public void focusLost(Editor editor) {
+        clearBraces(editor);
+      }
+
+      public void focusGained(Editor editor) {
+        updateBraces(editor, myAlarm);
+      }
+    };
+    ((EditorEventMulticasterEx)eventMulticaster).addFocusChangeListner(myFocusChangeListener);
+
+    final FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject);
+
+    fileEditorManager.addFileEditorManagerListener(new FileEditorManagerAdapter() {
+      public void selectionChanged(FileEditorManagerEvent e) {
+        myAlarm.cancelAllRequests();
+      }
+    }, myProject);
+
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
         EditorEventMulticaster eventMulticaster = EditorFactory.getInstance().getEventMulticaster();
-
-        myCaretListener = new CaretListener() {
-          public void caretPositionChanged(CaretEvent e) {
-            myAlarm.cancelAllRequests();
-            Editor editor = e.getEditor();
-            if (editor.getProject() == myProject) {
-              updateBraces(editor, myAlarm);
-            }
-          }
-        };
-        eventMulticaster.addCaretListener(myCaretListener, myProject);
-
-        mySelectionListener = new SelectionListener() {
-          public void selectionChanged(SelectionEvent e) {
-            myAlarm.cancelAllRequests();
-            Editor editor = e.getEditor();
-            if (editor.getProject() == myProject) {
-              updateBraces(editor, myAlarm);
-            }
-          }
-        };
-        eventMulticaster.addSelectionListener(mySelectionListener);
-
-        myDocumentListener = new DocumentAdapter() {
-          public void documentChanged(DocumentEvent e) {
-            myAlarm.cancelAllRequests();
-            Editor[] editors = EditorFactory.getInstance().getEditors(e.getDocument(), myProject);
-            for (Editor editor : editors) {
-              updateBraces(editor, myAlarm);
-            }
-          }
-        };
-        eventMulticaster.addDocumentListener(myDocumentListener, myProject);
-
-        myFocusChangeListener = new FocusChangeListener() {
-          public void focusLost(Editor editor) {
-            clearBraces(editor);
-          }
-
-          public void focusGained(Editor editor) {
-            updateBraces(editor, myAlarm);
-          }
-        };
-        ((EditorEventMulticasterEx)eventMulticaster).addFocusChangeListner(myFocusChangeListener);
-
-        final FileEditorManager fileEditorManager = FileEditorManager.getInstance(myProject);
-
-        fileEditorManager.addFileEditorManagerListener(
-          new FileEditorManagerAdapter() {
-            public void selectionChanged(FileEditorManagerEvent e) {
-              myAlarm.cancelAllRequests();
-            }
-          }
-        );
-
-        Disposer.register(myProject, new Disposable() {
-          public void dispose() {
-            EditorEventMulticaster eventMulticaster = EditorFactory.getInstance().getEventMulticaster();
-            eventMulticaster.removeSelectionListener(mySelectionListener);
-            ((EditorEventMulticasterEx)eventMulticaster).removeFocusChangeListner(myFocusChangeListener);
-          }
-        });
+        ((EditorEventMulticasterEx)eventMulticaster).removeFocusChangeListner(myFocusChangeListener);
+        eventMulticaster.removeSelectionListener(mySelectionListener);
       }
     });
   }
@@ -132,7 +124,4 @@ public class BraceHighlighter implements ProjectComponent {
       }
     });
   }
-
-  public void projectClosed() {
-  }
 }

platform/lang-impl/src/com/intellij/codeInsight/highlighting/HighlightManagerImpl.java

@@ -33,8 +33,6 @@ import java.awt.*;
 import java.util.*;
 
 public class HighlightManagerImpl extends HighlightManager implements ProjectComponent {
-  private AnActionListener myAnActionListener;
-  private DocumentListener myDocumentListener;
   private final Project myProject;
 
   public HighlightManagerImpl(Project project) {
@@ -53,10 +51,10 @@ public class HighlightManagerImpl extends HighlightManager implements ProjectCom
   }
 
   public void projectOpened() {
-    myAnActionListener = new MyAnActionListener();
-    ActionManagerEx.getInstanceEx().addAnActionListener(myAnActionListener, myProject);
+    AnActionListener anActionListener = new MyAnActionListener();
+    ActionManagerEx.getInstanceEx().addAnActionListener(anActionListener, myProject);
 
-    myDocumentListener = new DocumentAdapter() {
+    DocumentListener documentListener = new DocumentAdapter() {
       public void documentChanged(DocumentEvent event) {
         Document document = event.getDocument();
         Editor[] editors = EditorFactory.getInstance().getEditors(document);
@@ -79,7 +77,7 @@ public class HighlightManagerImpl extends HighlightManager implements ProjectCom
         }
       }
     };
-    EditorFactory.getInstance().getEventMulticaster().addDocumentListener(myDocumentListener, myProject);
+    EditorFactory.getInstance().getEventMulticaster().addDocumentListener(documentListener, myProject);
   }
 
   public void projectClosed() {

platform/lang-impl/src/com/intellij/codeInsight/lookup/impl/LookupManagerImpl.java

@@ -5,14 +5,16 @@ import com.intellij.codeInsight.completion.impl.CamelHumpMatcher;
 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
 import com.intellij.codeInsight.documentation.DocumentationManager;
 import com.intellij.codeInsight.hint.EditorHintListener;
-import com.intellij.codeInsight.hint.HintManagerImpl;
+import com.intellij.codeInsight.hint.HintManager;
 import com.intellij.codeInsight.lookup.*;
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.components.ProjectComponent;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.EditorFactory;
 import com.intellij.openapi.editor.event.EditorFactoryAdapter;
 import com.intellij.openapi.editor.event.EditorFactoryEvent;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiFile;
 import com.intellij.ui.LightweightHint;
@@ -32,7 +34,6 @@ public class LookupManagerImpl extends LookupManager implements ProjectComponent
   private final PropertyChangeSupport myPropertyChangeSupport = new PropertyChangeSupport(this);
 
   private boolean myIsDisposed;
-  private EditorFactoryAdapter myEditorFactoryListener;
 
   public LookupManagerImpl(Project project, MessageBus bus) {
     myProject = project;
@@ -41,7 +42,7 @@ public class LookupManagerImpl extends LookupManager implements ProjectComponent
       public void hintShown(final Project project, final LightweightHint hint, final int flags) {
         if (project == myProject) {
           Lookup lookup = getActiveLookup();
-          if (lookup != null && (flags & HintManagerImpl.HIDE_BY_LOOKUP_ITEM_CHANGE) != 0) {
+          if (lookup != null && (flags & HintManager.HIDE_BY_LOOKUP_ITEM_CHANGE) != 0) {
             lookup.addLookupListener(
               new LookupAdapter() {
                 public void currentItemChanged(LookupEvent event) {
@@ -75,18 +76,23 @@ public class LookupManagerImpl extends LookupManager implements ProjectComponent
   }
 
   public void projectOpened(){
-    myEditorFactoryListener = new EditorFactoryAdapter() {
+
+    final EditorFactoryAdapter myEditorFactoryListener = new EditorFactoryAdapter() {
       public void editorReleased(EditorFactoryEvent event) {
-        if (event.getEditor() == myActiveLookupEditor){
+        if (event.getEditor() == myActiveLookupEditor) {
           hideActiveLookup();
         }
       }
     };
     EditorFactory.getInstance().addEditorFactoryListener(myEditorFactoryListener);
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        EditorFactory.getInstance().removeEditorFactoryListener(myEditorFactoryListener);
+      }
+    });
   }
 
   public void projectClosed(){
-    EditorFactory.getInstance().removeEditorFactoryListener(myEditorFactoryListener);
     myIsDisposed = true;
   }
 

platform/lang-impl/src/com/intellij/codeInsight/template/impl/TemplateManagerImpl.java

@@ -14,6 +14,7 @@ import com.intellij.openapi.editor.event.EditorFactoryListener;
 import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.Key;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiFile;
@@ -28,7 +29,6 @@ import java.util.List;
 public class TemplateManagerImpl extends TemplateManager implements ProjectComponent {
   protected Project myProject;
   private boolean myTemplateTesting;
-  private EditorFactoryListener myEditorFactoryListener;
   private final List<Disposable> myDisposables = new ArrayList<Disposable>();
 
   private static final Key<TemplateState> TEMPLATE_STATE_KEY = Key.create("TEMPLATE_STATE_KEY");
@@ -47,11 +47,10 @@ public class TemplateManagerImpl extends TemplateManager implements ProjectCompo
   public void initComponent() { }
 
   public void projectClosed() {
-    EditorFactory.getInstance().removeEditorFactoryListener(myEditorFactoryListener);
   }
 
   public void projectOpened() {
-    myEditorFactoryListener = new EditorFactoryAdapter() {
+    final EditorFactoryListener myEditorFactoryListener = new EditorFactoryAdapter() {
       public void editorReleased(EditorFactoryEvent event) {
         Editor editor = event.getEditor();
         if (editor.getProject() != null && editor.getProject() != myProject) return;
@@ -63,6 +62,11 @@ public class TemplateManagerImpl extends TemplateManager implements ProjectCompo
       }
     };
     EditorFactory.getInstance().addEditorFactoryListener(myEditorFactoryListener);
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        EditorFactory.getInstance().removeEditorFactoryListener(myEditorFactoryListener);
+      }
+    });
   }
 
   public void setTemplateTesting(final boolean templateTesting) {

platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java

@@ -17,10 +17,13 @@ import com.intellij.openapi.components.ProjectComponent;
 import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.project.DumbService;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.annotations.NonNls;
+import com.intellij.openapi.util.Disposer;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  * @author dyoma
@@ -29,8 +32,6 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
   private final Project myProject;
 
   private RunContentManagerImpl myContentManager;
-  @NonNls
-  protected static final String MAKE_PROJECT_ON_RUN_KEY = "makeProjectOnRun";
 
   /**
    * reflection
@@ -44,7 +45,6 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
   }
 
   public void projectClosed() {
-    myContentManager.dispose();
   }
 
   public void initComponent() { }
@@ -55,6 +55,7 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
   public RunContentManager getContentManager() {
     if (myContentManager == null) {
       myContentManager = new RunContentManagerImpl(myProject);
+      Disposer.register(myProject, myContentManager);
     }
     return myContentManager;
   }

platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java

@@ -44,7 +44,7 @@ import org.jetbrains.annotations.Nullable;
 import javax.swing.*;
 import java.util.*;
 
-public class RunContentManagerImpl implements RunContentManager {
+public class RunContentManagerImpl implements RunContentManager, Disposable {
   private static final Logger LOG = Logger.getInstance("#com.intellij.execution.ui.RunContentManagerImpl");
   private static final Key<RunContentDescriptor> DESCRIPTOR_KEY = new Key<RunContentDescriptor>("Descriptor");
 
@@ -55,7 +55,6 @@ public class RunContentManagerImpl implements RunContentManager {
   private final EventDispatcher<MyRunContentListener> myEventDispatcher;
   private final LinkedList<String> myToolwindowIdZbuffer = new LinkedList<String>();
 
-
   public RunContentManagerImpl(Project project) {
     myProject = project;
     myEventDispatcher = EventDispatcher.create(MyRunContentListener.class);
@@ -82,9 +81,7 @@ public class RunContentManagerImpl implements RunContentManager {
             Set<String> currentWindows = new HashSet<String>();
             String[] toolWindowIds = toolWindowManager.getToolWindowIds();
 
-            for (String toolWindowId : toolWindowIds) {
-              currentWindows.add(toolWindowId);
-            }
+            currentWindows.addAll(Arrays.asList(toolWindowIds));
             myToolwindowIdZbuffer.retainAll(currentWindows);
 
             final String activeToolWindowId = toolWindowManager.getActiveToolWindowId();
@@ -100,16 +97,9 @@ public class RunContentManagerImpl implements RunContentManager {
   }
 
   public void dispose() {
-    final String[] ids = myToolwindowIdToContentManagerMap.keySet().toArray(new String[myToolwindowIdToContentManagerMap.size()]);
-    for (String id : ids) {
-      unregisterToolwindow(id);
-    }
   }
 
   private void unregisterToolwindow(final String id) {
-    final ToolWindowManager windowManager = ToolWindowManager.getInstance(myProject);
-    if (windowManager.getToolWindow(id) == null) return;
-    windowManager.unregisterToolWindow(id);
     final ContentManager manager = myToolwindowIdToContentManagerMap.get(id);
     manager.removeAllContents(true);
     myToolwindowIdToContentManagerMap.remove(id);
@@ -124,7 +114,7 @@ public class RunContentManagerImpl implements RunContentManager {
       return;
     }
 
-    final ToolWindow toolWindow = toolWindowManager.registerToolWindow(toolWindowId, true, ToolWindowAnchor.BOTTOM);
+    final ToolWindow toolWindow = toolWindowManager.registerToolWindow(toolWindowId, true, ToolWindowAnchor.BOTTOM, this);
 
     final ContentManager contentManager = toolWindow.getContentManager();
     class MyDataProvider implements DataProvider {
@@ -155,6 +145,11 @@ public class RunContentManagerImpl implements RunContentManager {
       }
     });
     myToolwindowIdToContentManagerMap.put(toolWindowId, contentManager);
+    Disposer.register(contentManager, new Disposable() {
+      public void dispose() {
+        unregisterToolwindow(toolWindowId);
+      }
+    });
     myToolwindowIdZbuffer.addLast(toolWindowId);
   }
 
@@ -360,7 +355,7 @@ public class RunContentManagerImpl implements RunContentManager {
     content.putUserData(DESCRIPTOR_KEY, descriptor);
     content.putUserData(ToolWindow.SHOW_CONTENT_ICON, Boolean.TRUE);
     contentManager.addContent(content);
-    new CloseListener(content, myProject, toolWindowId);
+    new CloseListener(content, toolWindowId);
     return content;
   }
 
@@ -456,13 +451,11 @@ public class RunContentManagerImpl implements RunContentManager {
   }
 
   private class CloseListener extends ContentManagerAdapter implements ProjectManagerListener {
-    private final Project myProject;
     private Content myContent;
     private final String myToolwindowId;
 
-    public CloseListener(final Content content, final Project project, String toolWindowId) {
+    private CloseListener(final Content content, String toolWindowId) {
       myContent = content;
-      myProject = project;
       content.getManager().addContentManagerListener(this);
       ProjectManager.getInstance().addProjectManagerListener(this);
       myToolwindowId = toolWindowId;
@@ -609,7 +602,7 @@ public class RunContentManagerImpl implements RunContentManager {
     }, progressTitle, true, myProject);
   }
 
-  public static interface MyRunContentListener extends EventListener {
+  public interface MyRunContentListener extends EventListener {
     void contentSelected(RunContentDescriptor descriptor, String toolwindowId);
     void contentRemoved (RunContentDescriptor descriptor, String toolwindowId);
   }

platform/lang-impl/src/com/intellij/ide/bookmarks/BookmarkManager.java

@@ -1,6 +1,6 @@
 package com.intellij.ide.bookmarks;
 
-import com.intellij.openapi.components.ProjectComponent;
+import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
@@ -32,9 +32,8 @@ import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
 
-public class BookmarkManager implements JDOMExternalizable, ProjectComponent {
+public class BookmarkManager extends AbstractProjectComponent implements JDOMExternalizable {
   private static final Logger LOG = Logger.getInstance("#com.intellij.ide.bookmarks.BookmarkManager");
-  private final Project myProject;
   private final BookmarksCollection.ForEditors myEditorBookmarks = new BookmarksCollection.ForEditors();
   private final BookmarksCollection.ForPsiElements myCommanderBookmarks = new BookmarksCollection.ForPsiElements();
   private final MyEditorMouseListener myEditorMouseListener = new MyEditorMouseListener();
@@ -45,32 +44,19 @@ public class BookmarkManager implements JDOMExternalizable, ProjectComponent {
   }
 
   public BookmarkManager(Project project) {
-    myProject = project;
+    super(project);
   }
 
-  public void disposeComponent() {
-  }
-
-  public void initComponent() { }
-
   public void projectOpened() {
     EditorEventMulticasterEx eventMulticaster = (EditorEventMulticasterEx)EditorFactory.getInstance()
       .getEventMulticaster();
-    eventMulticaster.addEditorMouseListener(myEditorMouseListener);
-  }
-
-  public void projectClosed() {
-    EditorEventMulticasterEx eventMulticaster = (EditorEventMulticasterEx)EditorFactory.getInstance()
-      .getEventMulticaster();
-    eventMulticaster.removeEditorMouseListener(myEditorMouseListener);
+    eventMulticaster.addEditorMouseListener(myEditorMouseListener, myProject);
   }
 
   public Project getProject() {
     return myProject;
   }
 
-
-
   public void addEditorBookmark(Editor editor, int lineIndex, int number) {
     Document document = editor.getDocument();
     PsiFile psiFile = PsiDocumentManager.getInstance(myProject).getPsiFile(document);

platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesManager.java

@@ -30,7 +30,6 @@ public class FavoritesManager implements ProjectComponent, JDOMExternalizable {
   // fav list name -> list of (root: root url, root class)
   private final Map<String, List<Pair<AbstractUrl,String>>> myName2FavoritesRoots = new LinkedHashMap<String, List<Pair<AbstractUrl, String>>>();
   private final Project myProject;
-  private final MyRootsChangeAdapter myPsiTreeChangeAdapter = new MyRootsChangeAdapter();
   private final List<FavoritesListener> myListeners = new ArrayList<FavoritesListener>();
   public interface FavoritesListener {
     void rootsChanged(String listName);
@@ -152,13 +151,14 @@ public class FavoritesManager implements ProjectComponent, JDOMExternalizable {
           final String name = myProject.getName();
           createNewList(name);
         }
-        PsiManager.getInstance(myProject).addPsiTreeChangeListener(myPsiTreeChangeAdapter);
+        final MyRootsChangeAdapter myPsiTreeChangeAdapter = new MyRootsChangeAdapter();
+
+        PsiManager.getInstance(myProject).addPsiTreeChangeListener(myPsiTreeChangeAdapter, myProject);
       }
     });
   }
 
   public void projectClosed() {
-    PsiManager.getInstance(myProject).removePsiTreeChangeListener(myPsiTreeChangeAdapter);
   }
 
   @NotNull
@@ -184,7 +184,7 @@ public class FavoritesManager implements ProjectComponent, JDOMExternalizable {
     List<Pair<AbstractUrl, String>> result = new ArrayList<Pair<AbstractUrl, String>>();
     for (Object favorite : list.getChildren(FAVORITES_ROOT)) {
       final String className = ((Element)favorite).getAttributeValue(CLASS_NAME);
-      final AbstractUrl abstractUrl = readUrlFromElement(((Element)favorite), project);
+      final AbstractUrl abstractUrl = readUrlFromElement((Element)favorite, project);
       if (abstractUrl != null) {
         result.add(Pair.create(abstractUrl, className));
       }
@@ -237,7 +237,8 @@ public class FavoritesManager implements ProjectComponent, JDOMExternalizable {
     DefaultJDOMExternalizer.writeExternal(this, element);
   }
 
-  private static @Nullable AbstractUrl createUrlByElement(Object element, final Project project) {
+  @Nullable
+  private static AbstractUrl createUrlByElement(Object element, final Project project) {
     if (element instanceof SmartPsiElementPointer) element = ((SmartPsiElementPointer)element).getElement();
                                                                                                                                                
     for(FavoriteNodeProvider nodeProvider: Extensions.getExtensions(FavoriteNodeProvider.EP_NAME, project)) {
@@ -254,7 +255,7 @@ public class FavoritesManager implements ProjectComponent, JDOMExternalizable {
     return null;
   }
 
-  private static void writeRoots(Element element, List<Pair<AbstractUrl, String>> roots) throws WriteExternalException {
+  private static void writeRoots(Element element, List<Pair<AbstractUrl, String>> roots) {
     for (Pair<AbstractUrl, String> root : roots) {
       final AbstractUrl url = root.getFirst();
       if (url == null) continue;

platform/lang-impl/src/com/intellij/openapi/module/impl/ModuleImpl.java

@@ -40,7 +40,6 @@ public class ModuleImpl extends ComponentManagerImpl implements Module {
 
   @NotNull private final Project myProject;
   private ModuleType myModuleType = null;
-  private MyVirtualFileListener myVirtualFileListener;
   private boolean isModuleAdded;
 
   private GlobalSearchScope myModuleScope = null;
@@ -84,8 +83,8 @@ public class ModuleImpl extends ComponentManagerImpl implements Module {
   private void init(String filePath) {
     getStateStore().setModuleFilePath(filePath);
 
-    myVirtualFileListener = new MyVirtualFileListener();
-    VirtualFileManager.getInstance().addVirtualFileListener(myVirtualFileListener);
+    MyVirtualFileListener myVirtualFileListener = new MyVirtualFileListener();
+    VirtualFileManager.getInstance().addVirtualFileListener(myVirtualFileListener,this);
   }
 
   public void loadModuleComponents() {
@@ -149,7 +148,6 @@ public class ModuleImpl extends ComponentManagerImpl implements Module {
   public synchronized void dispose() {
     isModuleAdded = false;
     disposeComponents();
-    VirtualFileManager.getInstance().removeVirtualFileListener(myVirtualFileListener);
     Extensions.disposeArea(this);
     super.dispose();
   }

platform/lang-impl/src/com/intellij/openapi/module/impl/ModuleManagerImpl.java

@@ -85,7 +85,7 @@ public class ModuleManagerImpl extends ModuleManager implements ProjectComponent
   public ModuleManagerImpl(Project project, MessageBus bus) {
     myProject = project;
     myMessageBus = bus;
-    myConnection = bus.connect();
+    myConnection = bus.connect(project);
 
     myConnection.setDefaultHandler(new MessageHandler() {
       public void handle(Method event, Object... params) {
@@ -113,7 +113,6 @@ public class ModuleManagerImpl extends ModuleManager implements ProjectComponent
 
   public void disposeComponent() {
     myModuleModel.disposeModel();
-    myConnection.disconnect();
   }
 
   public long getModificationCount() {

platform/lang-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java

@@ -56,7 +56,7 @@ public class DirectoryIndexImpl extends DirectoryIndex implements ProjectCompone
 
   public DirectoryIndexImpl(Project project, PsiManagerConfiguration psiManagerConfiguration, StartupManager startupManager) {
     myProject = project;
-    myConnection = project.getMessageBus().connect();
+    myConnection = project.getMessageBus().connect(project);
 
     myIsLasyMode = !psiManagerConfiguration.REPOSITORY_ENABLED;
     ((StartupManagerEx)startupManager).registerPreStartupActivity(new Runnable() {
@@ -76,9 +76,6 @@ public class DirectoryIndexImpl extends DirectoryIndex implements ProjectCompone
   }
 
   public void disposeComponent() {
-    if (myInitialized) {
-      myConnection.disconnect();
-    }
     myDisposed = true;
   }
 

platform/lang-impl/src/com/intellij/openapi/vcs/changes/VcsEventWatcher.java

@@ -3,7 +3,7 @@ package com.intellij.openapi.vcs.changes;
 import com.intellij.ProjectTopics;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.ModalityState;
-import com.intellij.openapi.components.ProjectComponent;
+import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ModuleRootEvent;
 import com.intellij.openapi.roots.ModuleRootListener;
@@ -17,18 +17,14 @@ import org.jetbrains.annotations.NotNull;
 /**
  * @author yole
  */
-public class VcsEventWatcher implements ProjectComponent {
-  private final Project myProject;
-  private MessageBusConnection myConnection;
-  private final WolfTheProblemSolver.ProblemListener myProblemListener = new MyProblemListener();
-
+public class VcsEventWatcher extends AbstractProjectComponent {
   public VcsEventWatcher(Project project) {
-    myProject = project;
+    super(project);
   }
 
   public void projectOpened() {
-    myConnection = myProject.getMessageBus().connect();
-    myConnection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootListener() {
+    MessageBusConnection connection = myProject.getMessageBus().connect(myProject);
+    connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootListener() {
       public void beforeRootsChange(ModuleRootEvent event) {
       }
 
@@ -41,12 +37,8 @@ public class VcsEventWatcher implements ProjectComponent {
         }, ModalityState.NON_MODAL);
       }
     });
-    WolfTheProblemSolver.getInstance(myProject).addProblemListener(myProblemListener);
-  }
-
-  public void projectClosed() {
-    WolfTheProblemSolver.getInstance(myProject).removeProblemListener(myProblemListener);
-    myConnection.disconnect();
+    final WolfTheProblemSolver.ProblemListener myProblemListener = new MyProblemListener();
+    WolfTheProblemSolver.getInstance(myProject).addProblemListener(myProblemListener,myProject);
   }
 
   @NonNls
@@ -54,13 +46,6 @@ public class VcsEventWatcher implements ProjectComponent {
   public String getComponentName() {
     return "VcsEventWatcher";
   }
-
-  public void initComponent() {
-  }
-
-  public void disposeComponent() {
-  }
-
   private class MyProblemListener extends WolfTheProblemSolver.ProblemListener {
     @Override
     public void problemsAppeared(final VirtualFile file) {

platform/lang-impl/src/com/intellij/openapi/vcs/impl/ModuleVcsDetector.java

@@ -41,6 +41,8 @@ public class ModuleVcsDetector implements ProjectComponent {
   }
 
   public void projectOpened() {
+    if (ApplicationManager.getApplication().isUnitTestMode()) return;
+    
     final StartupManager manager = StartupManager.getInstance(myProject);
     manager.registerStartupActivity(new Runnable() {
       public void run() {

platform/lang-impl/src/com/intellij/profile/codeInspection/InspectionProjectProfileManager.java

@@ -25,11 +25,13 @@ import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.components.*;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.startup.StartupManager;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.WriteExternalException;
 import com.intellij.openapi.wm.WindowManager;
 import com.intellij.openapi.wm.ex.StatusBarEx;
 import com.intellij.openapi.wm.impl.status.TogglePopupHintsPanel;
+import com.intellij.openapi.Disposable;
 import com.intellij.packageDependencies.DependencyValidationManager;
 import com.intellij.profile.DefaultProjectProfileManager;
 import com.intellij.profile.Profile;
@@ -151,6 +153,11 @@ public class InspectionProjectProfileManager extends DefaultProjectProfileManage
     myStatusBar = (StatusBarEx)WindowManager.getInstance().getStatusBar(myProject);
     myTogglePopupHintsPanel = new TogglePopupHintsPanel(myStatusBar);
     myStatusBar.addFileStatusComponent(myTogglePopupHintsPanel);
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        myStatusBar.removeFileStatusComponent(myTogglePopupHintsPanel);
+      }
+    });
     StartupManager.getInstance(myProject).registerPostStartupActivity(new Runnable() {
       public void run() {
         final Set<Profile> profiles = new HashSet<Profile>();
@@ -181,7 +188,6 @@ public class InspectionProjectProfileManager extends DefaultProjectProfileManage
   }
 
   public void projectClosed() {
-    myStatusBar.removeFileStatusComponent(myTogglePopupHintsPanel);
 
     final Application app = ApplicationManager.getApplication();
     Runnable cleanupInspectionProfilesRunnable = new Runnable() {

platform/lang-impl/src/com/intellij/psi/impl/source/tree/injected/InjectedLanguageManagerImpl.java

@@ -11,13 +11,15 @@ import com.intellij.openapi.extensions.ExtensionPoint;
 import com.intellij.openapi.extensions.ExtensionPointListener;
 import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.extensions.PluginDescriptor;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.project.DumbService;
 import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.project.DumbService;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.ProperTextRange;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.Disposable;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.PsiManagerEx;
 import com.intellij.util.ArrayUtil;
@@ -37,7 +39,6 @@ public class InjectedLanguageManagerImpl extends InjectedLanguageManager {
   private final Project myProject;
   private final DumbService myDumbService;
   private final AtomicReference<MultiHostInjector> myPsiManagerRegisteredInjectorsAdapter = new AtomicReference<MultiHostInjector>();
-  private final ExtensionPointListener<LanguageInjector> myListener;
 
   public static InjectedLanguageManagerImpl getInstanceImpl(Project project) {
     return (InjectedLanguageManagerImpl)InjectedLanguageManager.getInstance(project);
@@ -57,7 +58,7 @@ public class InjectedLanguageManagerImpl extends InjectedLanguageManager {
         unregisterMultiHostInjector(injector);
       }
     });
-    myListener = new ExtensionPointListener<LanguageInjector>() {
+    final ExtensionPointListener<LanguageInjector> myListener = new ExtensionPointListener<LanguageInjector>() {
       public void extensionAdded(LanguageInjector extension, @Nullable PluginDescriptor pluginDescriptor) {
         psiManagerInjectorsChanged();
       }
@@ -66,8 +67,13 @@ public class InjectedLanguageManagerImpl extends InjectedLanguageManager {
         psiManagerInjectorsChanged();
       }
     };
-    ExtensionPoint<LanguageInjector> psiManagerPoint = Extensions.getRootArea().getExtensionPoint(LanguageInjector.EXTENSION_POINT_NAME);
+    final ExtensionPoint<LanguageInjector> psiManagerPoint = Extensions.getRootArea().getExtensionPoint(LanguageInjector.EXTENSION_POINT_NAME);
     psiManagerPoint.addExtensionPointListener(myListener);
+    Disposer.register(project, new Disposable() {
+      public void dispose() {
+        psiManagerPoint.removeExtensionPointListener(myListener);
+      }
+    });
   }
 
   public void projectOpened() {
@@ -277,8 +283,6 @@ public class InjectedLanguageManagerImpl extends InjectedLanguageManager {
   }
 
   public void disposeComponent() {
-    ExtensionPoint<LanguageInjector> psiManagerPoint = Extensions.getRootArea().getExtensionPoint(LanguageInjector.EXTENSION_POINT_NAME);
-    psiManagerPoint.removeExtensionPointListener(myListener);
   }
 
   private static class PsiManagerRegisteredInjectorsAdapter implements MultiHostInjector {

platform/lang-impl/src/com/intellij/util/fileIndex/AbstractFileIndex.java

@@ -19,6 +19,7 @@ import com.intellij.openapi.roots.ProjectFileIndex;
 import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.openapi.roots.ex.ProjectRootManagerEx;
 import com.intellij.openapi.startup.StartupManager;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiManager;
@@ -38,7 +39,7 @@ public abstract class AbstractFileIndex<IndexEntry extends FileIndexEntry> imple
   private final ProjectFileIndex myProjectFileIndex;
   private boolean myFormatChanged;
   private final Project myProject;
-  private AbstractFileIndex.FileIndexCacheUpdater myRootsChangeCacheUpdater;
+  private FileIndexCacheUpdater myRootsChangeCacheUpdater;
   private final StartupManagerEx myStartupManager;
   private FileIndexRefreshCacheUpdater myRefreshCacheUpdater;
   private final Object myIndexLock = new Object();
@@ -128,7 +129,8 @@ public abstract class AbstractFileIndex<IndexEntry extends FileIndexEntry> imple
         }
       }
       cacheFile.delete();
-    } finally {
+    }
+    finally {
       if (output != null) {
         try {
           output.close();
@@ -248,7 +250,6 @@ public abstract class AbstractFileIndex<IndexEntry extends FileIndexEntry> imple
     else {
       StartupManager.getInstance(myProject).registerStartupActivity(loadCacheRunnable);
     }
-
   }
 
   @Nullable
@@ -258,7 +259,7 @@ public abstract class AbstractFileIndex<IndexEntry extends FileIndexEntry> imple
 
   public void dispose() {
     if (myRefreshCacheUpdater != null) {
-      myRefreshCacheUpdater.dispose();
+      Disposer.dispose(myRefreshCacheUpdater);
     }
     if (myRootsChangeCacheUpdater != null) {
       ProjectRootManagerEx.getInstanceEx(myProject).unregisterChangeUpdater(myRootsChangeCacheUpdater);

platform/lang-impl/src/com/intellij/util/fileIndex/FileIndexRefreshCacheUpdater.java

@@ -27,15 +27,14 @@ public class FileIndexRefreshCacheUpdater extends VirtualFileAdapter implements
 
   public FileIndexRefreshCacheUpdater(final AbstractFileIndex fileIndex) {
     myFileIndex = fileIndex;
-    myVirtualFileManager = (VirtualFileManagerEx)VirtualFileManagerEx.getInstance();
+    myVirtualFileManager = (VirtualFileManagerEx)VirtualFileManager.getInstance();
     myVirtualFileManager.addVirtualFileManagerListener(this);
-    myVirtualFileManager.addVirtualFileListener(this);
+    myVirtualFileManager.addVirtualFileListener(this,this);
     myVirtualFileManager.registerRefreshUpdater(this);
   }
 
   public void dispose() {
     myVirtualFileManager.removeVirtualFileManagerListener(this);
-    myVirtualFileManager.removeVirtualFileListener(this);
     myVirtualFileManager.unregisterRefreshUpdater(this);
   }
 

platform/lvcs-impl/src/com/intellij/openapi/command/impl/FileOperationsUndoProvider.java

@@ -3,7 +3,6 @@ package com.intellij.openapi.command.impl;
 import com.intellij.ProjectTopics;
 import com.intellij.history.Checkpoint;
 import com.intellij.history.LocalHistory;
-import com.intellij.openapi.Disposable;
 import com.intellij.openapi.command.undo.*;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ModuleRootEvent;
@@ -17,26 +16,27 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
-public class FileOperationsUndoProvider extends VirtualFileAdapter implements UndoProvider, Disposable {
+public class FileOperationsUndoProvider extends VirtualFileAdapter implements UndoProvider {
   private final Key<Boolean> DELETION_WAS_UNDOABLE = new Key<Boolean>("DeletionWasUndoable");
 
-  private Project myProject;
+  private final Project myProject;
   private boolean myIsInsideCommand;
 
   private List<MyUndoableAction> myCommandActions;
-  private MessageBusConnection myBusConnection;
+  private final MessageBusConnection myBusConnection;
 
+  @SuppressWarnings({"UnusedDeclaration"})
   public FileOperationsUndoProvider() {
     this(null, null);
   }
 
-  public FileOperationsUndoProvider(Project p, MessageBus bus) {
-    myProject = p;
+  public FileOperationsUndoProvider(Project project, MessageBus bus) {
+    myProject = project;
+    myBusConnection = project == null ? null : bus.connect(project);
+
     if (myProject == null) return;
 
-    myBusConnection = bus.connect();
-
-    getFileManager().addVirtualFileListener(this);
+    getFileManager().addVirtualFileListener(this, project);
     listenForModuleChanges();
   }
 
@@ -62,14 +62,7 @@ public class FileOperationsUndoProvider extends VirtualFileAdapter implements Un
     });
   }
 
-  public void dispose() {
-    if (myProject == null) return;
-
-    myBusConnection.disconnect();
-    getFileManager().removeVirtualFileListener(this);
-  }
-
-  private VirtualFileManager getFileManager() {
+  private static VirtualFileManager getFileManager() {
     return VirtualFileManager.getInstance();
   }
 
@@ -150,7 +143,7 @@ public class FileOperationsUndoProvider extends VirtualFileAdapter implements Un
     return myProject.isDisposed();
   }
 
-  private boolean isUndoable(VirtualFileEvent e) {
+  private static boolean isUndoable(VirtualFileEvent e) {
     return !e.isFromRefresh();
   }
 
@@ -197,7 +190,7 @@ public class FileOperationsUndoProvider extends VirtualFileAdapter implements Un
     myCommandActions.add(a);
   }
 
-  private DocumentReference createDocumentReference(VirtualFile f, boolean isDeletion) {
+  private static DocumentReference createDocumentReference(VirtualFile f, boolean isDeletion) {
     DocumentReference r = new DocumentReferenceByVirtualFile(f);
     if (isDeletion) r.beforeFileDeletion(f);
     return r;
@@ -217,7 +210,7 @@ public class FileOperationsUndoProvider extends VirtualFileAdapter implements Un
     private boolean myProcessDuringUndo;
     private boolean myProcessDuringRedo;
 
-    public MyUndoableAction(DocumentReference r) {
+    private MyUndoableAction(DocumentReference r) {
       myDocumentRef = r;
       myAfterActionCheckpoint = LocalHistory.putCheckpoint(myProject);
     }

platform/platform-api/src/com/intellij/util/ui/Animator.java

@@ -17,17 +17,16 @@
 package com.intellij.util.ui;
 
 import com.intellij.openapi.Disposable;
-import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.Application;
+import com.intellij.openapi.application.ApplicationManager;
 
 import javax.swing.*;
 
 public abstract class Animator implements Disposable {
 
-  private String myName;
   private int myTotalFrames;
   private int myCycleLength;
-  private Timer myTimer;
+  private final Timer myTimer;
 
   private int myCurrentFrame;
   private int myQueuedFrames = 0;
@@ -56,30 +55,15 @@ public abstract class Animator implements Disposable {
                   boolean repeatable,
                   final int interCycleGap,
                   final int maxRepeatCount, boolean forward) {
-    myName = name;
     myTotalFrames = totalFrames;
     myCycleLength = cycleLength;
     myRepeatable = repeatable;
     myForward = forward;
     myCurrentFrame = forward ? 0 : totalFrames;
 
-    Application app = ApplicationManager.getApplication();
-    myTimer = (app != null && app.isUnitTestMode()) ?
-              new Timer(myName, myCycleLength / myTotalFrames) {
-                {
-                  dispose();
-                }
-                @Override
-                public boolean isRunning() {
-                  return true;
-                }
-
-                @Override
-                protected void onTimer() throws InterruptedException {
-
-                }
-              }
-              : new Timer(myName, myCycleLength / myTotalFrames) {
+    Application application = ApplicationManager.getApplication();
+    myTimer = application == null || application.isUnitTestMode() ? null :
+              new Timer(name, myCycleLength / myTotalFrames) {
       protected void onTimer() throws InterruptedException {
         boolean repaint = true;
         if (!isAnimated()) {
@@ -162,25 +146,27 @@ public abstract class Animator implements Disposable {
   }
 
   public void suspend() {
-    myTimer.suspend();
+    if (myTimer != null) {
+      myTimer.suspend();
+    }
   }
 
   public void resume() {
-    myTimer.resume();
+    if (myTimer != null) { myTimer.resume();}
   }
 
   public void setTakInitialDelay(boolean take) {
-    myTimer.setTakeInitialDelay(take);
+    if (myTimer != null) {myTimer.setTakeInitialDelay(take);}
   }
 
   public abstract void paintNow(float frame, final float totalFrames, final float cycle);
 
   public void dispose() {
-    myTimer.dispose();
+    if (myTimer != null) {myTimer.dispose();}
   }
 
   public boolean isRunning() {
-    return myTimer.isRunning() && myLastAnimated;
+    return myTimer != null && myTimer.isRunning() && myLastAnimated;
   }
 
   public boolean isAnimated() {
@@ -197,6 +183,6 @@ public abstract class Animator implements Disposable {
   }
 
   public boolean isDisposed() {
-    return myTimer.isDisposed();
+    return myTimer == null || myTimer.isDisposed();
   }
 }

platform/platform-impl/src/com/intellij/notification/impl/ProjectNotificationsComponent.java

@@ -1,23 +1,22 @@
 package com.intellij.notification.impl;
 
-import com.intellij.openapi.components.ProjectComponent;
+import com.intellij.notification.Notifications;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.application.Application;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.wm.WindowManager;
 import com.intellij.openapi.wm.ex.StatusBarEx;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.application.Application;
-import com.intellij.notification.Notifications;
 import org.jetbrains.annotations.NotNull;
 
 /**
  * @author spleaner
  */
-public class ProjectNotificationsComponent implements ProjectComponent {
-  private Project myProject;
-  private StatusBarEx myStatusBar;
-
+public class ProjectNotificationsComponent extends AbstractProjectComponent {
   public ProjectNotificationsComponent(final Project project) {
-    myProject = project;
+    super(project);
   }
 
   public void projectOpened() {
@@ -25,17 +24,13 @@ public class ProjectNotificationsComponent implements ProjectComponent {
       return;
     }
 
-    myStatusBar = (StatusBarEx) WindowManager.getInstance().getStatusBar(myProject);
-    myProject.getMessageBus().connect().subscribe(Notifications.TOPIC, myStatusBar.getNotificationArea());
-  }
-
-  public void projectClosed() {
-    if (isDummyEnvironment()) {
-      return;
-    }
-
-    NotificationsManager.getNotificationsManager().clear(myProject);
-    myProject = null;
+    StatusBarEx statusBar = (StatusBarEx)WindowManager.getInstance().getStatusBar(myProject);
+    myProject.getMessageBus().connect().subscribe(Notifications.TOPIC, statusBar.getNotificationArea());
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        NotificationsManager.getNotificationsManager().clear(myProject);
+      }
+    });
   }
 
   private static boolean isDummyEnvironment() {
@@ -47,10 +42,4 @@ public class ProjectNotificationsComponent implements ProjectComponent {
   public String getComponentName() {
     return "Project Notifications";
   }
-
-  public void initComponent() {
-  }
-
-  public void disposeComponent() {
-  }
 }

platform/platform-impl/src/com/intellij/openapi/command/impl/CommandMerger.java

@@ -1,7 +1,8 @@
 package com.intellij.openapi.command.impl;
 
-import com.intellij.openapi.command.UndoConfirmationPolicy;
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.command.NoneGroupId;
+import com.intellij.openapi.command.UndoConfirmationPolicy;
 import com.intellij.openapi.command.undo.DocumentReference;
 import com.intellij.openapi.command.undo.UndoableAction;
 import com.intellij.openapi.editor.Document;
@@ -13,6 +14,7 @@ import com.intellij.openapi.fileEditor.FileEditor;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.testFramework.LightVirtualFile;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
 
@@ -20,7 +22,7 @@ import java.util.*;
  * author: lesya
  */
 
-public class CommandMerger {
+public class CommandMerger implements Disposable {
   private final UndoManagerImpl myManager;
   private Object myLastGroupId = null;
   private boolean myIsComplex = false;
@@ -29,15 +31,14 @@ public class CommandMerger {
   private String myCommandName = null;
   private ArrayList<UndoableAction> myCurrentActions = new ArrayList<UndoableAction>();
   private Set<DocumentReference> myAffectedDocuments = new HashSet<DocumentReference>();
-  private final DocumentAdapter myDocumentListener;
   private EditorAndState myStateBefore;
   private EditorAndState myStateAfter;
   private UndoConfirmationPolicy myUndoConfirmationPolicy = UndoConfirmationPolicy.DEFAULT;
 
-  CommandMerger(UndoManagerImpl manager, EditorFactory editorFactory) {
+  CommandMerger(@NotNull UndoManagerImpl manager, @NotNull EditorFactory editorFactory) {
     myManager = manager;
     EditorEventMulticaster eventMulticaster = editorFactory.getEventMulticaster();
-    myDocumentListener = new DocumentAdapter() {
+    DocumentAdapter documentListener = new DocumentAdapter() {
       public void documentChanged(DocumentEvent e) {
         Document document = e.getDocument();
         if (myManager.isActive() && !myManager.isUndoInProgress() && !myManager.isRedoInProgress()) {
@@ -45,12 +46,10 @@ public class CommandMerger {
         }
       }
     };
-    eventMulticaster.addDocumentListener(myDocumentListener);
+    eventMulticaster.addDocumentListener(documentListener, this);
   }
 
   public void dispose() {
-    EditorEventMulticaster eventMulticaster = EditorFactory.getInstance().getEventMulticaster();
-    eventMulticaster.removeDocumentListener(myDocumentListener);
     clearDocumentRefs();
   }
 
@@ -91,7 +90,7 @@ public class CommandMerger {
       myManager.compact();
     }
     merge(nextCommandToMerge);
-    clearRedoStacks(nextCommandToMerge);    
+    clearRedoStacks(nextCommandToMerge);
 
     myLastGroupId = groupId;
     if (myCommandName == null) myCommandName = commandName;

platform/platform-impl/src/com/intellij/openapi/command/impl/DocumentEditingUndoProvider.java

@@ -1,5 +1,6 @@
 package com.intellij.openapi.command.impl;
 
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.command.undo.DocumentReference;
 import com.intellij.openapi.command.undo.DocumentReferenceByDocument;
@@ -21,28 +22,20 @@ import com.intellij.psi.ExternalChangeAction;
 /**
  * author: lesya
  */
-class DocumentEditingUndoProvider {
-  private static final Logger LOG = Logger.getInstance(
-    "#com.intellij.openapi.command.impl.DocumentEditingUndoProvider");
+class DocumentEditingUndoProvider implements Disposable {
+  private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.command.impl.DocumentEditingUndoProvider");
 
-  private final MyEditorDocumentListener myDocumentListener;
   private final Project myProject;
 
-  public DocumentEditingUndoProvider(Project project, EditorFactory editorFactory) {
-    myDocumentListener = new MyEditorDocumentListener();
+  DocumentEditingUndoProvider(Project project, EditorFactory editorFactory) {
+    MyEditorDocumentListener documentListener = new MyEditorDocumentListener();
     myProject = project;
 
     EditorEventMulticaster m = editorFactory.getEventMulticaster();
-    m.addDocumentListener(myDocumentListener);
+    m.addDocumentListener(documentListener, this);
   }
 
   public void dispose() {
-    EditorEventMulticaster m = EditorFactory.getInstance().getEventMulticaster();
-    m.removeDocumentListener(myDocumentListener);
-  }
-
-  private boolean isCopy(Document d) {
-    return getUndoManager().isCopy(d);
   }
 
   private UndoManagerImpl getUndoManager() {
@@ -56,7 +49,7 @@ class DocumentEditingUndoProvider {
       // if we don't ignore copy's events, we will receive notification
       // for the same event twice (from original document too)
       // and undo will work incorrectly
-      if (isCopy(document)) return;
+      if (UndoManagerImpl.isCopy(document)) return;
 
       if (allEditorsAreViewersFor(document)) return;
       if (!isToRecordActions(document)) return;
@@ -83,11 +76,7 @@ class DocumentEditingUndoProvider {
       if (document.getUserData(UndoManager.DONT_RECORD_UNDO) == Boolean.TRUE) return false;
 
       final VirtualFile vFile = FileDocumentManager.getInstance().getFile(document);
-      if (vFile != null && vFile.getUserData(UndoManager.DONT_RECORD_UNDO) == Boolean.TRUE) {
-        return false;
-      }
-
-      return true;
+      return vFile == null || vFile.getUserData(UndoManager.DONT_RECORD_UNDO) != Boolean.TRUE;
     }
 
     private boolean allEditorsAreViewersFor(Document document) {

platform/platform-impl/src/com/intellij/openapi/command/impl/UndoManagerImpl.java

@@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.ex.ProjectEx;
 import com.intellij.openapi.startup.StartupManager;
 import com.intellij.openapi.util.Comparing;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.EmptyRunnable;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.VirtualFileAdapter;
@@ -32,7 +33,7 @@ import org.jetbrains.annotations.TestOnly;
 
 import java.util.*;
 
-public class UndoManagerImpl extends UndoManager implements ProjectComponent, ApplicationComponent {
+public class UndoManagerImpl extends UndoManager implements ProjectComponent, ApplicationComponent, Disposable {
   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.command.impl.UndoManagerImpl");
 
   public static final int GLOBAL_UNDO_LIMIT = 10;
@@ -41,7 +42,7 @@ public class UndoManagerImpl extends UndoManager implements ProjectComponent, Ap
   private static final int COMMAND_TO_RUN_COMPACT = 20;
   private static final int FREE_QUEUES_LIMIT = 30;
 
-  private ProjectEx myProject;
+  private final ProjectEx myProject;
 
   private int myCommandLevel = 0;
 
@@ -50,39 +51,38 @@ public class UndoManagerImpl extends UndoManager implements ProjectComponent, Ap
   private static final int REDO = 2;
   private int myCurrentOperationState = NONE;
 
-  private CommandMerger myMerger;
+  private final CommandMerger myMerger;
 
-  private CommandListener myCommandListener;
+  private final UndoRedoStacksHolder myUndoStacksHolder = new UndoRedoStacksHolder();
+  private final UndoRedoStacksHolder myRedoStacksHolder = new UndoRedoStacksHolder();
 
-  private final UndoRedoStacksHolder myUndoStacksHolder = new UndoRedoStacksHolder(this);
-  private final UndoRedoStacksHolder myRedoStacksHolder = new UndoRedoStacksHolder(this);
-
-  private DocumentEditingUndoProvider myDocumentEditingUndoProvider;
   private CommandMerger myCurrentMerger;
   private CurrentEditorProvider myCurrentEditorProvider;
 
   private Project myCurrentActionProject = DummyProject.getInstance();
   private int myCommandCounter = 1;
-  private MyBeforeDeletionListener myBeforeFileDeletionListener;
   private final CommandProcessor myCommandProcessor;
   private final EditorFactory myEditorFactory;
   private final VirtualFileManager myVirtualFileManager;
   private final StartupManager myStartupManager;
   private UndoProvider[] myUndoProviders;
 
-  public UndoManagerImpl(Project project,
+  public UndoManagerImpl(ProjectEx project,
                          Application application,
                          CommandProcessor commandProcessor,
                          EditorFactory editorFactory,
                          VirtualFileManager virtualFileManager,
                          StartupManager startupManager) {
-    myProject = (ProjectEx)project;
+    myProject = project;
     myCommandProcessor = commandProcessor;
     myEditorFactory = editorFactory;
     myVirtualFileManager = virtualFileManager;
     myStartupManager = startupManager;
 
     init(application);
+
+    myMerger = new CommandMerger(this, myEditorFactory);
+    Disposer.register(this, myMerger);
   }
 
   public UndoManagerImpl(Application application,
@@ -112,23 +112,21 @@ public class UndoManagerImpl extends UndoManager implements ProjectComponent, Ap
   }
 
   private void initialize() {
-    Runnable initAction = new Runnable() {
-      public void run() {
-        runStartupActivity();
-      }
-    };
-    if (myProject != null) {
-      myStartupManager.registerStartupActivity(initAction);
+    if (myProject == null) {
+      runStartupActivity();
     }
     else {
-      initAction.run();
+      myStartupManager.registerStartupActivity(new Runnable() {
+        public void run() {
+          runStartupActivity();
+        }
+      });
     }
-
   }
 
   private void runStartupActivity() {
     myCurrentEditorProvider = new FocusBasedCurrentEditorProvider();
-    myCommandListener = new CommandAdapter() {
+    CommandListener commandListener = new CommandAdapter() {
       private boolean myFakeCommandStarted = false;
 
       public void commandStarted(CommandEvent event) {
@@ -153,21 +151,22 @@ public class UndoManagerImpl extends UndoManager implements ProjectComponent, Ap
         }
       }
     };
-    myCommandProcessor.addCommandListener(myCommandListener);
+    myCommandProcessor.addCommandListener(commandListener, this);
 
-    myDocumentEditingUndoProvider = new DocumentEditingUndoProvider(myProject, myEditorFactory);
-    myMerger = new CommandMerger(this, myEditorFactory);
+    DocumentEditingUndoProvider documentEditingUndoProvider = new DocumentEditingUndoProvider(myProject, myEditorFactory);
+    Disposer.register(this, documentEditingUndoProvider);
 
-    if (myProject != null) {
-      myUndoProviders = Extensions.getExtensions(UndoProvider.PROJECT_EP_NAME, myProject);
-    }
-    else {
-      myUndoProviders = Extensions.getExtensions(UndoProvider.EP_NAME);
+    myUndoProviders = myProject == null
+                      ? Extensions.getExtensions(UndoProvider.EP_NAME)
+                      : Extensions.getExtensions(UndoProvider.PROJECT_EP_NAME, myProject);
+    for (UndoProvider undoProvider : myUndoProviders) {
+      if (undoProvider instanceof Disposable) {
+        Disposer.register(this, (Disposable)undoProvider);
+      }
     }
 
-    myBeforeFileDeletionListener = new MyBeforeDeletionListener();
-    myVirtualFileManager.addVirtualFileListener(myBeforeFileDeletionListener);
-
+    MyBeforeDeletionListener beforeFileDeletionListener = new MyBeforeDeletionListener();
+    myVirtualFileManager.addVirtualFileListener(beforeFileDeletionListener, this);
   }
 
   private void onCommandFinished(final Project project, final String commandName, final Object commandGroupId) {
@@ -237,21 +236,10 @@ public class UndoManagerImpl extends UndoManager implements ProjectComponent, Ap
       .executeCommand(myProject, EmptyRunnable.getInstance(), CommonBundle.message("drop.undo.history.command.name"), null);
   }
 
+  public void dispose() {
+  }
+
   public void disposeComponent() {
-    if (myCommandListener != null) {
-      myCommandProcessor.removeCommandListener(myCommandListener);
-      myDocumentEditingUndoProvider.dispose();
-      myMerger.dispose();
-      for(UndoProvider provider: myUndoProviders) {
-        if (provider instanceof Disposable) {
-          ((Disposable) provider).dispose();
-        }
-      }
-    }
-    if (myBeforeFileDeletionListener != null) {
-      myVirtualFileManager.removeVirtualFileListener(myBeforeFileDeletionListener);
-    }
-    myProject = null;
   }
 
   public void setCurrentEditorProvider(CurrentEditorProvider p) {
@@ -455,7 +443,7 @@ public class UndoManagerImpl extends UndoManager implements ProjectComponent, Ap
     }
   }
 
-  DocumentReference[] getDocumentReferences(FileEditor editor) {
+  static DocumentReference[] getDocumentReferences(FileEditor editor) {
     List<DocumentReference> documentReferences = new ArrayList<DocumentReference>();
     Document[] documents = editor == null ? null : TextEditorProvider.getDocuments(editor);
 
@@ -479,6 +467,7 @@ public class UndoManagerImpl extends UndoManager implements ProjectComponent, Ap
   private void commandStarted(UndoConfirmationPolicy undoConfirmationPolicy) {
     if (myCommandLevel == 0) {
       myCurrentMerger = new CommandMerger(this, EditorFactory.getInstance());
+      Disposer.register(this, myCurrentMerger);
     }
     LOG.assertTrue(myCurrentMerger != null, String.valueOf(myCommandLevel));
     myCurrentMerger.setBeforeState(getCurrentState());
@@ -514,7 +503,7 @@ public class UndoManagerImpl extends UndoManager implements ProjectComponent, Ap
   private void disposeCurrentMerger() {
     LOG.assertTrue(myCommandLevel == 0);
     if (myCurrentMerger != null) {
-      myCurrentMerger.dispose();
+      Disposer.dispose(myCurrentMerger);
       myCurrentMerger = null;
     }
   }
@@ -575,9 +564,9 @@ public class UndoManagerImpl extends UndoManager implements ProjectComponent, Ap
 
   }
 
-  public Document getOriginal(Document d) {
-    Document result = d.getUserData(FragmentContent.ORIGINAL_DOCUMENT);
-    return result == null ? d : result;
+  static Document getOriginal(Document document) {
+    Document result = document.getUserData(FragmentContent.ORIGINAL_DOCUMENT);
+    return result == null ? document : result;
   }
 
   public static boolean isCopy(Document d) {

platform/platform-impl/src/com/intellij/openapi/command/impl/UndoRedoStacksHolder.java

@@ -17,24 +17,18 @@ import java.util.*;
 class UndoRedoStacksHolder {
   private final Key<LinkedList<UndoableGroup>> STACK_IN_DOCUMENT_KEY = Key.create("STACK_IN_DOCUMENT_KEY");
 
-  private final UndoManagerImpl myManager;
-
   private final LinkedList<UndoableGroup> myGlobalStack = new LinkedList<UndoableGroup>();
 
   private final Map<DocumentReference, LinkedList<UndoableGroup>> myDocumentStacks = new HashMap<DocumentReference, LinkedList<UndoableGroup>>();
   private final WeakList<Document> myDocumentsWithStacks = new WeakList<Document>();
 
 
-  public UndoRedoStacksHolder(UndoManagerImpl m) {
-    myManager = m;
-  }
-
   public LinkedList<UndoableGroup> getStack(Document d) {
     return getStack(createReferenceOrGetOriginal(d));
   }
 
-  private DocumentReference createReferenceOrGetOriginal(Document d) {
-    Document original = myManager.getOriginal(d);
+  private static DocumentReference createReferenceOrGetOriginal(Document d) {
+    Document original = UndoManagerImpl.getOriginal(d);
     return DocumentReferenceByDocument.createDocumentReference(original);
   }
 
@@ -118,7 +112,7 @@ class UndoRedoStacksHolder {
   }
 
   public void clearEditorStack(FileEditor e) {
-    for (DocumentReference d : myManager.getDocumentReferences(e)) {
+    for (DocumentReference d : UndoManagerImpl.getDocumentReferences(e)) {
       clearFileStack(d);
     }
   }
@@ -134,7 +128,7 @@ class UndoRedoStacksHolder {
     }
   }
 
-  private void invalidateAllComplexCommands(LinkedList<UndoableGroup> stack) {
+  private static void invalidateAllComplexCommands(LinkedList<UndoableGroup> stack) {
     for (UndoableGroup g : stack) {
       g.invalidateIfComplex();
     }
@@ -155,7 +149,7 @@ class UndoRedoStacksHolder {
     addToStack(getGlobalStack(), g, UndoManagerImpl.GLOBAL_UNDO_LIMIT);
   }
 
-  private void addToStack(LinkedList<UndoableGroup> stack, UndoableGroup g, int limit) {
+  private static void addToStack(LinkedList<UndoableGroup> stack, UndoableGroup g, int limit) {
     stack.addLast(g);
     while (stack.size() > limit) {
       stack.removeFirst();

platform/platform-impl/src/com/intellij/openapi/fileChooser/impl/FileTreeBuilder.java

@@ -22,7 +22,6 @@ import java.util.Comparator;
 public class FileTreeBuilder extends AbstractTreeBuilder {
   private final FileChooserDescriptor myChooserDescriptor;
 
-  private VirtualFileAdapter myVirtualFileListener;
   private final Runnable myOnInitialized;
 
   public FileTreeBuilder(JTree tree,
@@ -49,7 +48,8 @@ public class FileTreeBuilder extends AbstractTreeBuilder {
   }
 
   private void installVirtualFileListener() {
-    myVirtualFileListener = new VirtualFileAdapter() {
+
+    VirtualFileAdapter myVirtualFileListener = new VirtualFileAdapter() {
       public void propertyChanged(VirtualFilePropertyEvent event) {
         getUpdater().addSubtreeToUpdate(getRootNode());
       }
@@ -67,13 +67,9 @@ public class FileTreeBuilder extends AbstractTreeBuilder {
       }
     };
 
-    VirtualFileManager.getInstance().addVirtualFileListener(myVirtualFileListener);
+    VirtualFileManager.getInstance().addVirtualFileListener(myVirtualFileListener,this);
   }
 
-  public final void dispose() {
-    VirtualFileManager.getInstance().removeVirtualFileListener(myVirtualFileListener);
-    super.dispose();
-  }
 
   protected boolean isAlwaysShowPlus(NodeDescriptor nodeDescriptor) {
     final Object element = nodeDescriptor.getElement();
@@ -84,10 +80,7 @@ public class FileTreeBuilder extends AbstractTreeBuilder {
         if (myChooserDescriptor.isChooseJarContents() && FileElement.isArchive(file)) {
           return true;
         }
-        if (file.isDirectory()) {
-          return true;
-        }
-        return false;
+        return file.isDirectory();
       }
     }
     return true;

platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorHistoryManager.java

@@ -2,8 +2,9 @@ package com.intellij.openapi.fileEditor.impl;
 
 import com.intellij.ide.ui.UISettings;
 import com.intellij.ide.ui.UISettingsListener;
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.components.ProjectComponent;
+import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.fileEditor.*;
 import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx;
@@ -11,6 +12,7 @@ import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.project.DumbAwareRunnable;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.startup.StartupManager;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.JDOMExternalizable;
 import com.intellij.openapi.util.Pair;
@@ -23,7 +25,7 @@ import org.jetbrains.annotations.NotNull;
 import java.util.ArrayList;
 import java.util.List;
 
-public final class EditorHistoryManager implements ProjectComponent, JDOMExternalizable{
+public final class EditorHistoryManager extends AbstractProjectComponent implements JDOMExternalizable {
   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.fileEditor.impl.EditorHistoryManager");
   private Element myElement;
 
@@ -31,29 +33,29 @@ public final class EditorHistoryManager implements ProjectComponent, JDOMExterna
     return project.getComponent(EditorHistoryManager.class);
   }
 
-  private final Project myProject;
   /**
    * State corresponding to the most recent file is the last
    */
   private final ArrayList<HistoryEntry> myEntriesList;
-  /**
-   * Listen opening of myEditor to update history
-   */
-  private final MyEditorManagerListener myEditorManagerListener;
-  /**
-   * Updates history length
-   */
-  private final MyUISettingsListener myUISettingsListener;
 
   /** Invoked by reflection */
-  EditorHistoryManager(final Project project, FileEditorManager fileEditorManager, UISettings uiSettings){
-    myProject = project;
+  EditorHistoryManager(final Project project, FileEditorManager fileEditorManager, final UISettings uiSettings){
+    super(project);
     myEntriesList = new ArrayList<HistoryEntry>();
-    myEditorManagerListener = new MyEditorManagerListener();
-    myUISettingsListener = new MyUISettingsListener();
+    MyEditorManagerListener editorManagerListener = new MyEditorManagerListener();
 
-    fileEditorManager.addFileEditorManagerListener(myEditorManagerListener);
+    /**
+     * Updates history length
+     */
+    final MyUISettingsListener myUISettingsListener = new MyUISettingsListener();
+
+    fileEditorManager.addFileEditorManagerListener(editorManagerListener, project);
     uiSettings.addUISettingsListener(myUISettingsListener);
+    Disposer.register(project, new Disposable() {
+      public void dispose() {
+        uiSettings.removeUISettingsListener(myUISettingsListener);
+      }
+    });
   }
 
   public void projectOpened(){
@@ -86,20 +88,12 @@ public final class EditorHistoryManager implements ProjectComponent, JDOMExterna
     );
   }
 
-  public void projectClosed(){}
 
   @NotNull
   public String getComponentName(){
     return "editorHistoryManager";
   }
 
-  public void initComponent() { }
-
-  public void disposeComponent(){
-    FileEditorManager.getInstance(myProject).removeFileEditorManagerListener(myEditorManagerListener);
-    UISettings.getInstance().removeUISettingsListener(myUISettingsListener);
-  }
-
   /**
    * Makes file most recent one
    */

platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/FileEditorManagerImpl.java

@@ -69,8 +69,8 @@ public class FileEditorManagerImpl extends FileEditorManagerEx implements Projec
   private static final Key<LocalFileSystem.WatchRequest> WATCH_REQUEST_KEY = Key.create("WATCH_REQUEST_KEY");
   private static final Key<Boolean> DUMB_AWARE = Key.create("DUMB_AWARE");
 
-  private static final FileEditor[] EMPTY_EDITOR_ARRAY = new FileEditor[]{};
-  private static final FileEditorProvider[] EMPTY_PROVIDER_ARRAY = new FileEditorProvider[]{};
+  private static final FileEditor[] EMPTY_EDITOR_ARRAY = {};
+  private static final FileEditorProvider[] EMPTY_PROVIDER_ARRAY = {};
 
   private volatile JPanel myPanels;
   private EditorsSplitters mySplitters;
@@ -78,35 +78,16 @@ public class FileEditorManagerImpl extends FileEditorManagerEx implements Projec
 
   private final MergingUpdateQueue myQueue = new MergingUpdateQueue("FileEditorManagerUpdateQueue", 50, true, null);
 
-  /**
-   * Updates tabs colors
-   */
-  private final MyFileStatusListener myFileStatusListener;
-
   /**
    * Removes invalid myEditor and updates "modified" status.
    */
-  private final MyEditorPropertyChangeListener myEditorPropertyChangeListener;
-  /**
-   * Updates tabs names
-   */
-  private final MyVirtualFileListener myVirtualFileListener;
-  /**
-   * Extends/cuts number of opened tabs. Also updates location of tabs.
-   */
-  private final MyUISettingsListener myUISettingsListener;
+  private final MyEditorPropertyChangeListener myEditorPropertyChangeListener = new MyEditorPropertyChangeListener();
 
   private final List<EditorDataProvider> myDataProviders = new ArrayList<EditorDataProvider>();
-  private MessageBusConnection myConnection;
 
   public FileEditorManagerImpl(final Project project) {
 /*    ApplicationManager.getApplication().assertIsDispatchThread(); */
     myProject = project;
-
-    myFileStatusListener = new MyFileStatusListener();
-    myEditorPropertyChangeListener = new MyEditorPropertyChangeListener();
-    myVirtualFileListener = new MyVirtualFileListener();
-    myUISettingsListener = new MyUISettingsListener();
     myListenerList = new MessageListenerList<FileEditorManagerListener>(myProject.getMessageBus(), FileEditorManagerListener.FILE_EDITOR_MANAGER);
   }
 
@@ -814,12 +795,7 @@ public class FileEditorManagerImpl extends FileEditorManagerEx implements Projec
     }
 
     final List<EditorWithProviderComposite> composites = getEditorComposites(file);
-    if (!composites.isEmpty()) {
-      return composites.get(0).getSelectedEditorWithProvider();
-    }
-    else {
-      return null;
-    }
+    return composites.isEmpty() ? null : composites.get(0).getSelectedEditorWithProvider();
   }
 
   @NotNull
@@ -947,15 +923,32 @@ public class FileEditorManagerImpl extends FileEditorManagerEx implements Projec
     //myFocusWatcher.install(myWindows.getComponent ());
     getSplitters().startListeningFocus();
 
-    myConnection = myProject.getMessageBus().connect();
+    MessageBusConnection connection = myProject.getMessageBus().connect(myProject);
 
     final FileStatusManager fileStatusManager = FileStatusManager.getInstance(myProject);
     if (fileStatusManager != null) {
-      fileStatusManager.addFileStatusListener(myFileStatusListener);
+      /**
+       * Updates tabs colors
+       */
+      final MyFileStatusListener myFileStatusListener = new MyFileStatusListener();
+      fileStatusManager.addFileStatusListener(myFileStatusListener, myProject);
     }
-    myConnection.subscribe(AppTopics.FILE_TYPES, new MyFileTypeListener());
-    VirtualFileManager.getInstance().addVirtualFileListener(myVirtualFileListener);
+    connection.subscribe(AppTopics.FILE_TYPES, new MyFileTypeListener());
+    /**
+     * Updates tabs names
+     */
+    final MyVirtualFileListener myVirtualFileListener = new MyVirtualFileListener();
+    VirtualFileManager.getInstance().addVirtualFileListener(myVirtualFileListener, myProject);
+    /**
+     * Extends/cuts number of opened tabs. Also updates location of tabs.
+     */
+    final MyUISettingsListener myUISettingsListener = new MyUISettingsListener();
     UISettings.getInstance().addUISettingsListener(myUISettingsListener);
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        UISettings.getInstance().removeUISettingsListener(myUISettingsListener);
+      }
+    });
 
     StartupManager.getInstance(myProject).registerPostStartupActivity(new DumbAwareRunnable() {
       public void run() {
@@ -982,23 +975,12 @@ public class FileEditorManagerImpl extends FileEditorManagerEx implements Projec
         });
       }
     });
-
   }
 
   public void projectClosed() {
     //myFocusWatcher.deinstall(myWindows.getComponent ());
     getSplitters().dispose();
 
-    myConnection.disconnect();
-
-// Remove application level listeners
-    final FileStatusManager fileStatusManager = FileStatusManager.getInstance(myProject);
-    if (fileStatusManager != null) {
-      fileStatusManager.removeFileStatusListener(myFileStatusListener);
-    }
-    VirtualFileManager.getInstance().removeVirtualFileListener(myVirtualFileListener);
-    UISettings.getInstance().removeUISettingsListener(myUISettingsListener);
-
 // Dispose created editors. We do not use use closeEditor method because
 // it fires event and changes history.
     closeAllFiles();

platform/platform-impl/src/com/intellij/openapi/vcs/impl/FileStatusManagerImpl.java

@@ -10,18 +10,18 @@ import com.intellij.openapi.editor.EditorFactory;
 import com.intellij.openapi.editor.event.DocumentAdapter;
 import com.intellij.openapi.editor.event.DocumentEvent;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
-import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.DumbAwareRunnable;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.startup.StartupManager;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vcs.FileStatus;
 import com.intellij.openapi.vcs.FileStatusListener;
 import com.intellij.openapi.vcs.FileStatusManager;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.HashMap;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -33,8 +33,7 @@ public class FileStatusManagerImpl extends FileStatusManager implements ProjectC
   private final Map<VirtualFile, FileStatus> myCachedStatuses = Collections.synchronizedMap(new HashMap<VirtualFile, FileStatus>());
 
   private final Project myProject;
-  private final List<FileStatusListener> myListeners = new ArrayList<FileStatusListener>();
-  private MyDocumentAdapter myDocumentListener;
+  private final List<FileStatusListener> myListeners = ContainerUtil.createEmptyCOWList();
   private FileStatusProvider myFileStatusProvider;
 
   public FileStatusManagerImpl(Project project, StartupManager startupManager) {
@@ -63,8 +62,8 @@ public class FileStatusManagerImpl extends FileStatusManager implements ProjectC
   }
 
   public void projectOpened() {
-    myDocumentListener = new MyDocumentAdapter();
-    EditorFactory.getInstance().getEventMulticaster().addDocumentListener(myDocumentListener, myProject);
+    MyDocumentAdapter documentListener = new MyDocumentAdapter();
+    EditorFactory.getInstance().getEventMulticaster().addDocumentListener(documentListener, myProject);
   }
 
   public void disposeComponent() {
@@ -106,8 +105,7 @@ public class FileStatusManagerImpl extends FileStatusManager implements ProjectC
 
     myCachedStatuses.clear();
 
-    final FileStatusListener[] listeners = myListeners.toArray(new FileStatusListener[myListeners.size()]);
-    for (FileStatusListener listener : listeners) {
+    for (FileStatusListener listener : myListeners) {
       listener.fileStatusesChanged();
     }
   }
@@ -130,8 +128,7 @@ public class FileStatusManagerImpl extends FileStatusManager implements ProjectC
     if (cachedStatus == newStatus) return;
     myCachedStatuses.put(file, newStatus);
 
-    final FileStatusListener[] listeners = myListeners.toArray(new FileStatusListener[myListeners.size()]);
-    for (FileStatusListener listener : listeners) {
+    for (FileStatusListener listener : myListeners) {
       listener.fileStatusChanged(file);
     }
   }

platform/platform-impl/src/com/intellij/openapi/vfs/encoding/EncodingManagerImpl.java

@@ -6,13 +6,14 @@
  */
 package com.intellij.openapi.vfs.encoding;
 
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.components.PersistentStateComponent;
 import com.intellij.openapi.components.State;
 import com.intellij.openapi.components.Storage;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.EditorFactory;
-import com.intellij.openapi.editor.event.DocumentEvent;
 import com.intellij.openapi.editor.event.DocumentAdapter;
+import com.intellij.openapi.editor.event.DocumentEvent;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.fileEditor.impl.LoadTextUtil;
 import com.intellij.openapi.project.Project;
@@ -22,7 +23,6 @@ import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.CharsetToolkit;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.util.Alarm;
 import gnu.trove.THashSet;
 import org.jdom.Element;
@@ -45,18 +45,12 @@ import java.util.concurrent.ConcurrentLinkedQueue;
       @Storage(id = "Encoding", file = "$APP_CONFIG$/encoding.xml")
   }
 )
-public class EncodingManagerImpl extends EncodingManager implements PersistentStateComponent<Element> {
+public class EncodingManagerImpl extends EncodingManager implements PersistentStateComponent<Element>, Disposable {
   private final PropertyChangeSupport myPropertyChangeSupport = new PropertyChangeSupport(this);
   private String myDefaultEncoding = "";
   private Charset myCachedCharset = null;
-  private final DocumentAdapter myDocumentListener = new DocumentAdapter() {
-    @Override
-    public void documentChanged(DocumentEvent e) {
-      updateEncodingFromContent(e);
-    }
-  };
 
-  private final Alarm updateEncodingFromContent = new Alarm(Alarm.ThreadToUse.OWN_THREAD, ApplicationManager.getApplication());
+  private final Alarm updateEncodingFromContent = new Alarm(Alarm.ThreadToUse.OWN_THREAD, this);
   private static final Key<Charset> CACHED_CHARSET_FROM_CONTENT = Key.create("CACHED_CHARSET_FROM_CONTENT");
   private final Queue<Document> myChangedDocuments = new ConcurrentLinkedQueue<Document>();
   private final Runnable myEncodingUpdateRunnable = new Runnable() {
@@ -66,10 +60,16 @@ public class EncodingManagerImpl extends EncodingManager implements PersistentSt
       VirtualFile virtualFile = FileDocumentManager.getInstance().getFile(document);
       if (virtualFile == null) return;
       Project project = guessProject(virtualFile);
+      if (project != null && project.isDisposed()) return;
       Charset charset = LoadTextUtil.charsetFromContentOrNull(project, virtualFile, document.getText());
       document.putUserData(CACHED_CHARSET_FROM_CONTENT, charset);
     }
   };
+
+  public void dispose() {
+    updateEncodingFromContent.cancelAllRequests();
+  }
+
   private void updateEncodingFromContent(final DocumentEvent e) {
     myChangedDocuments.offer(e.getDocument());
     updateEncodingFromContent.cancelAllRequests();
@@ -87,11 +87,17 @@ public class EncodingManagerImpl extends EncodingManager implements PersistentSt
   }
 
   public void initComponent() {
-    EditorFactory.getInstance().getEventMulticaster().addDocumentListener(myDocumentListener);
+    final DocumentAdapter myDocumentListener = new DocumentAdapter() {
+      @Override
+      public void documentChanged(DocumentEvent e) {
+        updateEncodingFromContent(e);
+      }
+    };
+
+    EditorFactory.getInstance().getEventMulticaster().addDocumentListener(myDocumentListener, this);
   }
 
   public void disposeComponent() {
-    EditorFactory.getInstance().getEventMulticaster().removeDocumentListener(myDocumentListener);
   }
 
   public Element getState() {

platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowManagerImpl.java

@@ -74,8 +74,6 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
   private final EditorComponentFocusWatcher myEditorComponentFocusWatcher;
   private final MyToolWindowPropertyChangeListener myToolWindowPropertyChangeListener;
   private final InternalDecoratorListener myInternalDecoratorListener;
-  private final MyUIManagerPropertyChangeListener myUIManagerPropertyChangeListener;
-  private final MyLafManagerListener myLafManagerListener;
 
   private boolean myEditorComponentActive;
   private final ActiveStack myActiveStack;
@@ -110,32 +108,30 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
   };
 
   private FocusCommand myRequestFocusCmd;
-  private ArrayList<FocusCommand> myFocusRequests = new ArrayList<FocusCommand>();
+  private final ArrayList<FocusCommand> myFocusRequests = new ArrayList<FocusCommand>();
 
-  private FocusCommand myUnforcedRequestFocusCmd;
-
-  private ArrayList<KeyEvent> myToDispatchOnDone = new ArrayList<KeyEvent>();
+  private final ArrayList<KeyEvent> myToDispatchOnDone = new ArrayList<KeyEvent>();
   private int myFlushingIdleRequestsEntryCount = 0;
 
   private WeakReference<FocusCommand> myLastForcedRequest = new WeakReference<FocusCommand>(null);
-  private Application myApp;
-  private AppListener myAppListener;
 
   private FocusCommand myFocusCommandOnAppActivation;
   private ActionCallback myCallbackOnActivation;
   private WeakReference<Component> myFocusedComponentOnDeactivation;
   private WeakReference<Component> myLastFocusedProjectComponent;
 
-  private IdeEventQueue myQueue;
-  private KeyProcessorConext myKeyProcessorContext = new KeyProcessorConext();
+  private final IdeEventQueue myQueue;
+  private final KeyProcessorConext myKeyProcessorContext = new KeyProcessorConext();
 
   private long myCmdTimestamp;
   private long myForcedCmdTimestamp;
+  private final Application myApp;
 
   /**
    * invoked by reflection
    */
-  public ToolWindowManagerImpl(final Project project, WindowManagerEx windowManagerEx, Application app) {
+  public ToolWindowManagerImpl(final Project project, WindowManagerEx windowManagerEx, final Application app) {
+    myApp = app;
     myQueue = IdeEventQueue.getInstance();
     myProject = project;
     myWindowManager = windowManagerEx;
@@ -152,8 +148,7 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
     myEditorComponentFocusWatcher = new EditorComponentFocusWatcher();
     myToolWindowPropertyChangeListener = new MyToolWindowPropertyChangeListener();
     myInternalDecoratorListener = new MyInternalDecoratorListener();
-    myUIManagerPropertyChangeListener = new MyUIManagerPropertyChangeListener();
-    myLafManagerListener = new MyLafManagerListener();
+
     myEditorComponentActive = false;
     myActiveStack = new ActiveStack();
     mySideStack = new SideStack();
@@ -162,9 +157,13 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
     myForcedFocusRequestsAlarm = new EdtAlarm(project);
     myIdleAlarm = new EdtAlarm(project);
 
-    myApp = app;
-    myAppListener = new AppListener();
-    myApp.addApplicationListener(myAppListener);
+    final AppListener myAppListener = new AppListener();
+    app.addApplicationListener(myAppListener);
+    Disposer.register(project, new Disposable() {
+      public void dispose() {
+        app.removeApplicationListener(myAppListener);
+      }
+    });
 
     IdeEventQueue.getInstance().addDispatcher(new IdeEventQueue.EventDispatcher() {
       public boolean dispatch(AWTEvent e) {
@@ -197,13 +196,21 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
   }
 
   public void disposeComponent() {
-    myApp.removeApplicationListener(myAppListener);
   }
 
   public void projectOpened() {
+    final MyUIManagerPropertyChangeListener myUIManagerPropertyChangeListener = new MyUIManagerPropertyChangeListener();
+    final MyLafManagerListener myLafManagerListener = new MyLafManagerListener();
+
     UIManager.addPropertyChangeListener(myUIManagerPropertyChangeListener);
     LafManager.getInstance().addLafManagerListener(myLafManagerListener);
 
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        UIManager.removePropertyChangeListener(myUIManagerPropertyChangeListener);
+        LafManager.getInstance().removeLafManagerListener(myLafManagerListener);
+      }
+    });
     myFrame = myWindowManager.allocateFrame(myProject);
     LOG.assertTrue(myFrame != null);
 
@@ -305,8 +312,6 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
   }
 
   public void projectClosed() {
-    UIManager.removePropertyChangeListener(myUIManagerPropertyChangeListener);
-    LafManager.getInstance().removeLafManagerListener(myLafManagerListener);
     final ArrayList<FinalizableCommand> commandsList = new ArrayList<FinalizableCommand>();
     final String[] ids = getToolWindowIds();
 
@@ -1022,7 +1027,7 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
   }
 
   public void notifyByBalloon(@NotNull final String toolWindowId,
-                              final MessageType type,
+                              @NotNull final MessageType type,
                               @NotNull final String text,
                               @Nullable final Icon icon,
                               @Nullable HyperlinkListener listener) {
@@ -1544,14 +1549,14 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
 
       boolean keyWasPressed = false;
 
-      for (int i = 0; i < events.length; i++) {
-        KeyEvent each = events[i];
+      for (KeyEvent each : events) {
         if (!isFocusTransferReady()) break;
 
         if (!keyWasPressed) {
           if (each.getID() == KeyEvent.KEY_PRESSED) {
             keyWasPressed = true;
-          } else {
+          }
+          else {
             myToDispatchOnDone.remove(each);
             continue;
           }
@@ -1586,10 +1591,6 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
     }
   }
 
-  private String toString(KeyEvent e) {
-    return KeyStroke.getKeyStrokeForEvent(e).toString();
-  }
-
   public boolean isFocusTransferReady() {
     if (!myFocusRequests.isEmpty()) return false;
     if (myQueue == null) return true;
@@ -1598,11 +1599,11 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
   }
 
   private boolean isIdleQueueEmpty() {
-    return isPendingKeyEventsRedispatched() && myIdleRequests.size() == 0;
+    return isPendingKeyEventsRedispatched() && myIdleRequests.isEmpty();
   }
 
   private boolean isPendingKeyEventsRedispatched() {
-    return myToDispatchOnDone.size() == 0;
+    return myToDispatchOnDone.isEmpty();
   }
 
   public boolean dispatch(KeyEvent e) {
@@ -1658,7 +1659,7 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
     /**
      * Creates floating decorator for specified floating decorator.
      */
-    public AddFloatingDecoratorCmd(final InternalDecorator decorator, final WindowInfoImpl info) {
+    private AddFloatingDecoratorCmd(final InternalDecorator decorator, final WindowInfoImpl info) {
       super(myWindowManager.getCommandProcessor());
       myFloatingDecorator = new FloatingDecorator(myFrame, info.copy(), decorator);
       myId2FloatingDecorator.put(info.getId(), myFloatingDecorator);
@@ -1696,7 +1697,7 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
   private final class RemoveFloatingDecoratorCmd extends FinalizableCommand {
     private final FloatingDecorator myFloatingDecorator;
 
-    public RemoveFloatingDecoratorCmd(final WindowInfoImpl info) {
+    private RemoveFloatingDecoratorCmd(final WindowInfoImpl info) {
       super(myWindowManager.getCommandProcessor());
       myFloatingDecorator = getFloatingDecorator(info.getId());
       myId2FloatingDecorator.remove(info.getId());
@@ -1756,7 +1757,7 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
     private final String myId;
 
 
-    public ToolWindowFocusWatcher(final ToolWindowImpl toolWindow) {
+    private ToolWindowFocusWatcher(final ToolWindowImpl toolWindow) {
       myId = toolWindow.getId();
       install(toolWindow.getComponent());
     }
@@ -1928,7 +1929,6 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
     final ActionCallback result = new ActionCallback();
 
     if (!forced) {
-      myUnforcedRequestFocusCmd = command;
       myFocusRequests.add(command);
 
       SwingUtilities.invokeLater(new Runnable() {
@@ -2015,7 +2015,6 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
 
   private void forceFinishFocusSettledown(FocusCommand cmd, ActionCallback cmdCallback) {
     rejectCommand(cmd, cmdCallback);
-    myUnforcedRequestFocusCmd = null;
   }
 
   private boolean checkForRejectOrByPass(final FocusCommand cmd, final boolean forced, final ActionCallback result) {
@@ -2085,11 +2084,10 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
   }
 
   private void resetUnforcedCommand(FocusCommand cmd) {
-    myUnforcedRequestFocusCmd = null;
     myFocusRequests.remove(cmd);
   }
 
-  private boolean canExecuteOnInactiveApplication(FocusCommand cmd) {
+  private static boolean canExecuteOnInactiveApplication(FocusCommand cmd) {
     return !Patches.REQUEST_FOCUS_MAY_ACTIVATE_APP || cmd.canExecuteOnInactiveApp();
   }
 
@@ -2159,9 +2157,9 @@ public final class ToolWindowManagerImpl extends ToolWindowManagerEx implements
   }
 
   private static class EdtAlarm {
-    private Alarm myAlarm;
+    private final Alarm myAlarm;
 
-    public EdtAlarm(Disposable parent) {
+    private EdtAlarm(Disposable parent) {
       myAlarm = new Alarm(Alarm.ThreadToUse.OWN_THREAD, parent);
     }
 

platform/platform-impl/src/com/intellij/ui/content/impl/ContentManagerImpl.java

@@ -154,16 +154,13 @@ public class ContentManagerImpl implements ContentManager, PropertyChangeListene
   }
 
   private boolean removeContent(final Content content, boolean trackSelection, boolean dispose) {
-    if (getIndexOfContent(content) == -1) return false;
+    int indexToBeRemoved = getIndexOfContent(content);
+    if (indexToBeRemoved == -1) return false;
 
     try {
       Content selection = mySelection.isEmpty() ? null : mySelection.get(mySelection.size() - 1);
       int selectedIndex = selection != null ? myContents.indexOf(selection) : -1;
 
-      int indexToBeRemoved = myContents.indexOf(content);
-      if (indexToBeRemoved < 0) {
-        return false;
-      }
       if (!fireContentRemoveQuery(content, indexToBeRemoved, ContentManagerEvent.ContentOperation.undefined)) {
         return false;
       }
@@ -171,7 +168,6 @@ public class ContentManagerImpl implements ContentManager, PropertyChangeListene
         return false; // the content has already been invalidated by another thread or something
       }
 
-
       boolean wasSelected = isSelected(content);
       if (wasSelected) {
         removeFromSelection(content);

platform/platform-resources/src/componentSets/VCS.xml

@@ -39,6 +39,7 @@
     <component>
       <interface-class>com.intellij.openapi.vcs.changes.ChangeListManager</interface-class>
       <implementation-class>com.intellij.openapi.vcs.changes.ChangeListManagerImpl</implementation-class>
+      <skipForDefaultProject/>
       <option name="workspace" value="true"/>
     </component>
     <component>
@@ -50,6 +51,7 @@
       <interface-class>com.intellij.openapi.vcs.changes.VcsDirtyScopeManager</interface-class>
       <implementation-class>com.intellij.openapi.vcs.changes.VcsDirtyScopeManagerImpl</implementation-class>
       <option name="workspace" value="true"/>
+      <skipForDefaultProject/>
     </component>
     <component>
       <implementation-class>com.intellij.openapi.vcs.changes.patch.CreatePatchCommitExecutor</implementation-class>

platform/testFramework/src/com/intellij/testFramework/LightPlatformTestCase.java

@@ -90,6 +90,7 @@ public abstract class LightPlatformTestCase extends UsefulTestCase implements Da
   private static LightProjectDescriptor ourProjectDescriptor;
   private final Map<String, InspectionTool> myAvailableInspectionTools = new THashMap<String, InspectionTool>();
   private static boolean ourHaveShutdownHook;
+  private ThreadTracker myThreadTracker;
 
   /**
    * @return Project to be used in tests for example for project components retrieval.
@@ -271,6 +272,8 @@ public abstract class LightPlatformTestCase extends UsefulTestCase implements Da
     initApplication(this);
     doSetup(new SimpleLightProjectDescriptor(getModuleType(), getProjectJDK()), configureLocalInspectionTools(), myAvailableInspectionTools);
     storeSettings();
+
+    myThreadTracker = new ThreadTracker();
   }
 
   public static void doSetup(final LightProjectDescriptor descriptor,
@@ -366,8 +369,9 @@ public abstract class LightPlatformTestCase extends UsefulTestCase implements Da
     checkForSettingsDamage();
     doTearDown();
 
-
     super.tearDown();
+
+    myThreadTracker.checkLeak();
   }
 
   public static void doTearDown() throws Exception {
@@ -482,9 +486,7 @@ public abstract class LightPlatformTestCase extends UsefulTestCase implements Da
     if (dataId.equals(DataConstants.PROJECT)) {
       return ourProject;
     }
-    else {
-      return null;
-    }
+    return null;
   }
 
   protected Sdk getProjectJDK() {
@@ -589,8 +591,8 @@ public abstract class LightPlatformTestCase extends UsefulTestCase implements Da
   }
 
   private static class SimpleLightProjectDescriptor implements LightProjectDescriptor {
-    private ModuleType myModuleType;
-    private Sdk mySdk;
+    private final ModuleType myModuleType;
+    private final Sdk mySdk;
 
     SimpleLightProjectDescriptor(ModuleType moduleType, Sdk sdk) {
       myModuleType = moduleType;

platform/testFramework/src/com/intellij/testFramework/PlatformTestCase.java

@@ -51,6 +51,7 @@ import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
 import com.intellij.psi.codeStyle.CodeStyleSettings;
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
+import com.intellij.psi.impl.PsiDocumentManagerImpl;
 import com.intellij.util.PatchedWeakReference;
 import junit.framework.TestCase;
 import org.jetbrains.annotations.NonNls;
@@ -76,7 +77,7 @@ public abstract class PlatformTestCase extends UsefulTestCase implements DataPro
   protected Module myModule;
   protected static final Collection<File> myFilesToDelete = new HashSet<File>();
   protected boolean myAssertionsInTestDetected;
-  protected static final Logger LOG = Logger.getInstance("#com.intellij.testFramework.IdeaTestCase");
+  protected static final Logger LOG = Logger.getInstance("#com.intellij.testFramework.PlatformTestCase");
   public static Thread ourTestThread;
   private static TestCase ourTestCase = null;
   public static final long DEFAULT_TEST_TIME = 300L;
@@ -85,6 +86,7 @@ public abstract class PlatformTestCase extends UsefulTestCase implements DataPro
   private static final String ourOriginalTempDir = FileUtil.getTempDirectory();
   private EditorListenerTracker myEditorListenerTracker;
   private String myTempDirPath;
+  private ThreadTracker myThreadTracker;
 
   static {
     Logger.setFactory(TestLoggerFactory.getInstance());
@@ -132,6 +134,7 @@ public abstract class PlatformTestCase extends UsefulTestCase implements DataPro
     initApplication();
 
     myEditorListenerTracker = new EditorListenerTracker();
+    myThreadTracker = new ThreadTracker();
 
     setUpProject();
     storeSettings();
@@ -155,7 +158,6 @@ public abstract class PlatformTestCase extends UsefulTestCase implements DataPro
     assertNotNull("Cannot instantiate ProjectManager component", myProjectManager);
 
     File projectFile = getIprFile();
-    myFilesToDelete.add(projectFile);
     LocalFileSystem.getInstance().refreshIoFiles(myFilesToDelete);
 
     myProject = createProject(projectFile, getClass().getName() + "." + getName());
@@ -199,7 +201,9 @@ public abstract class PlatformTestCase extends UsefulTestCase implements DataPro
   }
 
   protected File getIprFile() throws IOException {
-    return File.createTempFile("temp_" + getName(), ProjectFileType.DOT_DEFAULT_EXTENSION);
+    File tempFile = FileUtil.createTempFile("temp_" + getName(), ProjectFileType.DOT_DEFAULT_EXTENSION);
+    myFilesToDelete.add(tempFile);
+    return tempFile;
   }
 
   protected void setUpModule() {
@@ -263,6 +267,8 @@ public abstract class PlatformTestCase extends UsefulTestCase implements DataPro
     if (myProject != null) {
       ((StartupManagerImpl)StartupManager.getInstance(myProject)).prepareForNextTest();
       LookupManager.getInstance(myProject).hideActiveLookup();
+      
+      ((PsiDocumentManagerImpl)PsiDocumentManager.getInstance(getProject())).clearUncommitedDocuments();
     }
 
     InspectionProfileManager.getInstance().deleteProfile(PROFILE);
@@ -322,6 +328,7 @@ public abstract class PlatformTestCase extends UsefulTestCase implements DataPro
 
       //cleanTheWorld();
       myEditorListenerTracker.checkListenersLeak();
+      myThreadTracker.checkLeak();
     }
     finally {
       myProjectManager = null;

platform/testFramework/src/com/intellij/testFramework/ThreadTracker.java

@@ -0,0 +1,89 @@
+package com.intellij.testFramework;
+
+import com.intellij.openapi.project.ProjectManager;
+import com.intellij.openapi.project.impl.ProjectManagerImpl;
+import gnu.trove.THashSet;
+import junit.framework.Assert;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ * @author cdr
+ */
+public class ThreadTracker {
+  private final Collection<Thread> before;
+  private final boolean myDefaultProjectInitialized;
+
+  public ThreadTracker() {
+    before = getThreads();
+    myDefaultProjectInitialized = ((ProjectManagerImpl)ProjectManager.getInstance()).isDefaultProjectInitialized();
+  }
+
+  private static Collection<Thread> getThreads() {
+    //todo enable
+    return Collections.emptyList(); //Thread.getAllStackTraces().keySet();
+  }
+
+  private static final Set<String> wellKnownOffenders = new THashSet<String>(){{
+    add("Alarm pool(own)");
+    add("Alarm pool(shared)");
+    add("ApplicationImpl pooled thread");
+    add("AWT-Shutdown");
+    add("AWT-Windows");
+    add("CompilerThread0");
+    add("Finalizer");
+    add("FS Synchronizer");
+    add("IDEA Test Case Thread");
+    add("Image Fetcher 0");
+    add("Java2D Disposer");
+    add("Low Memory Detector");
+    add("main");
+    add("Monitor Ctrl-Break");
+    add("Periodic tasks thread");
+    add("Reference Handler");
+    add("Signal Dispatcher");
+    add("SimpleTimer");
+    add("timed reference disposer");
+    add("timer-int"); //serverImpl
+    add("timer-sys"); //clientimpl
+    add("TimerQueue");
+    add("UserActivityMonitor thread");
+    add("VM Periodic Task Thread");
+    add("VM Thread");
+    add("YJPAgent-Telemetry");
+
+
+
+
+    add("Change List Updater");
+  }};
+  public void checkLeak() {
+    try {
+      if (myDefaultProjectInitialized != ((ProjectManagerImpl)ProjectManager.getInstance()).isDefaultProjectInitialized()) return;
+
+      Collection<Thread> after = new THashSet<Thread>(getThreads());
+      after.removeAll(before);
+
+      for (Thread thread : after) {
+        if (thread == Thread.currentThread()) continue;
+        ThreadGroup group = thread.getThreadGroup();
+        if (group != null && "system".equals(group.getName()))continue;
+        String name = thread.getName();
+        if (name.startsWith("AWT-EventQueue-0")) continue;
+        if (name.startsWith("JobScheduler pool ")) continue;
+        if (wellKnownOffenders.contains(name)) continue;
+
+        String trace = "Thread leaked: " + thread+": "+ name +";\n ";
+        for (final StackTraceElement stackTraceElement : thread.getStackTrace()) {
+          trace += " at "+stackTraceElement +"\n";
+        }
+        Assert.fail(trace);
+      }
+    }
+    finally {
+      before.clear();
+    }
+  }
+}

platform/testFramework/src/com/intellij/testFramework/fixtures/impl/HeavyIdeaTestFixtureImpl.java

@@ -4,6 +4,7 @@
 
 package com.intellij.testFramework.fixtures.impl;
 
+import com.intellij.codeInsight.completion.CompletionProgressIndicator;
 import com.intellij.codeInsight.completion.CompletionProgressIndicator;
 import com.intellij.ide.highlighter.ProjectFileType;
 import com.intellij.ide.startup.impl.StartupManagerImpl;
@@ -31,10 +32,13 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
+import com.intellij.psi.impl.PsiDocumentManagerImpl;
 import com.intellij.testFramework.EditorListenerTracker;
 import com.intellij.testFramework.PlatformTestCase;
+import com.intellij.testFramework.ThreadTracker;
 import com.intellij.testFramework.builders.ModuleFixtureBuilder;
 import com.intellij.testFramework.fixtures.HeavyIdeaTestFixture;
 import com.intellij.util.PathUtil;
@@ -64,6 +68,7 @@ class HeavyIdeaTestFixtureImpl extends BaseFixture implements HeavyIdeaTestFixtu
   private IdeaTestApplication myApplication;
   private final Set<ModuleFixtureBuilder> myModuleFixtureBuilders = new THashSet<ModuleFixtureBuilder>();
   private EditorListenerTracker myEditorListenerTracker;
+  private ThreadTracker myThreadTracker;
 
   protected void addModuleFixtureBuilder(ModuleFixtureBuilder builder) {
     myModuleFixtureBuilders.add(builder);
@@ -76,11 +81,13 @@ class HeavyIdeaTestFixtureImpl extends BaseFixture implements HeavyIdeaTestFixtu
     setUpProject();
 
     myEditorListenerTracker = new EditorListenerTracker();
+    myThreadTracker = new ThreadTracker();
   }
 
   public void tearDown() throws Exception {
     ((StartupManagerImpl)StartupManager.getInstance(getProject())).prepareForNextTest();
     checkAllTimersAreDisposed();
+    ((PsiDocumentManagerImpl)PsiDocumentManager.getInstance(getProject())).clearUncommitedDocuments();
 
     for (ModuleFixtureBuilder moduleFixtureBuilder: myModuleFixtureBuilders) {
       moduleFixtureBuilder.getFixture().tearDown();
@@ -122,7 +129,7 @@ class HeavyIdeaTestFixtureImpl extends BaseFixture implements HeavyIdeaTestFixtu
     super.tearDown();
 
     myEditorListenerTracker.checkListenersLeak();
-    
+    myThreadTracker.checkLeak();
   }
 
 

platform/vcs-api/src/com/intellij/openapi/vcs/VcsVFSListener.java

@@ -16,6 +16,7 @@
 
 package com.intellij.openapi.vcs;
 
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.command.CommandAdapter;
 import com.intellij.openapi.command.CommandEvent;
 import com.intellij.openapi.command.CommandProcessor;
@@ -33,13 +34,13 @@ import java.util.*;
 /**
  * @author yole
  */
-public abstract class VcsVFSListener {
+public abstract class VcsVFSListener implements Disposable {
   protected static class MovedFileInfo {
     public final String myOldPath;
     public String myNewPath;
     private final VirtualFile myFile;
 
-    public MovedFileInfo(VirtualFile file, final String newPath) {
+    protected MovedFileInfo(VirtualFile file, final String newPath) {
       myOldPath = file.getPath();
       myNewPath = newPath;
       myFile = file;
@@ -49,8 +50,6 @@ public abstract class VcsVFSListener {
   protected final Project myProject;
   protected final AbstractVcs myVcs;
   protected final ChangeListManager myChangeListManager;
-  protected final MyVirtualFileAdapter myVFSListener;
-  protected final MyCommandAdapter myCommandListener;
   protected final VcsShowConfirmationOption myAddOption;
   protected final VcsShowConfirmationOption myRemoveOption;
   protected final List<VirtualFile> myAddedFiles = new ArrayList<VirtualFile>();
@@ -65,29 +64,23 @@ public abstract class VcsVFSListener {
     myProject = project;
     myVcs = vcs;
     myChangeListManager = ChangeListManager.getInstance(project);
-    myVFSListener = new MyVirtualFileAdapter();
-    myCommandListener = new MyCommandAdapter();
+
+    final MyVirtualFileAdapter myVFSListener = new MyVirtualFileAdapter();
+    final MyCommandAdapter myCommandListener = new MyCommandAdapter();
 
     final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(project);
     myAddOption = vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.ADD, vcs);
     myRemoveOption = vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.REMOVE, vcs);
 
-    VirtualFileManager.getInstance().addVirtualFileListener(myVFSListener);
-    CommandProcessor.getInstance().addCommandListener(myCommandListener);
+    VirtualFileManager.getInstance().addVirtualFileListener(myVFSListener,this);
+    CommandProcessor.getInstance().addCommandListener(myCommandListener,this);
   }
 
   public void dispose() {
-    VirtualFileManager.getInstance().removeVirtualFileListener(myVFSListener);
-    CommandProcessor.getInstance().removeCommandListener(myCommandListener);
   }
 
   protected boolean isEventIgnored(final VirtualFileEvent event) {
-    if (event.isFromRefresh()) return true;
-    if (ProjectLevelVcsManager.getInstance(myProject).getVcsFor(event.getFile()) != myVcs) {
-      return true;
-    }
-
-    return false;
+    return event.isFromRefresh() || ProjectLevelVcsManager.getInstance(myProject).getVcsFor(event.getFile()) != myVcs;
   }
 
   protected void executeAdd() {

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ChangesViewManager.java

@@ -13,10 +13,11 @@ package com.intellij.openapi.vcs.changes;
 import com.intellij.ide.CommonActionsManager;
 import com.intellij.ide.TreeExpander;
 import com.intellij.ide.actions.ContextHelpAction;
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.actionSystem.*;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.ModalityState;
-import com.intellij.openapi.components.ProjectComponent;
+import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.project.DumbAware;
 import com.intellij.openapi.project.Project;
@@ -43,15 +44,15 @@ import javax.swing.*;
 import javax.swing.tree.DefaultMutableTreeNode;
 import java.awt.*;
 import java.awt.event.KeyEvent;
+import java.awt.event.InputEvent;
 import java.util.Collection;
 
-public class ChangesViewManager implements ProjectComponent, JDOMExternalizable {
+public class ChangesViewManager extends AbstractProjectComponent implements JDOMExternalizable {
   private boolean SHOW_FLATTEN_MODE = true;
   private boolean SHOW_IGNORED_MODE = false;
 
   private final ChangesListView myView;
   private JLabel myProgressLabel;
-  private final Project myProject;
 
   private final Alarm myRepaintAlarm;
 
@@ -77,7 +78,7 @@ public class ChangesViewManager implements ProjectComponent, JDOMExternalizable
   }
 
   public ChangesViewManager(Project project, ChangesViewContentManager contentManager) {
-    myProject = project;
+    super(project);
     myContentManager = contentManager;
     myView = new ChangesListView(project);
     Disposer.register(project, myView);
@@ -86,6 +87,11 @@ public class ChangesViewManager implements ProjectComponent, JDOMExternalizable
 
   public void projectOpened() {
     ChangeListManager.getInstance(myProject).addChangeListListener(myListener);
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        ChangeListManager.getInstance(myProject).removeChangeListListener(myListener);
+      }
+    });
     if (ApplicationManager.getApplication().isHeadlessEnvironment()) return;
     final Content content = ContentFactory.SERVICE.getInstance().createContent(createChangeViewComponent(), "Local", false);
     content.setCloseable(false);
@@ -105,8 +111,6 @@ public class ChangesViewManager implements ProjectComponent, JDOMExternalizable
   }
 
   public void projectClosed() {
-    ChangeListManager.getInstance(myProject).removeChangeListListener(myListener);
-
     myDisposed = true;
     myRepaintAlarm.cancelAllRequests();
   }
@@ -116,12 +120,6 @@ public class ChangesViewManager implements ProjectComponent, JDOMExternalizable
     return "ChangesViewManager";
   }
 
-  public void initComponent() {
-  }
-
-  public void disposeComponent() {
-  }
-
   private JComponent createChangeViewComponent() {
     SimpleToolWindowPanel panel = new SimpleToolWindowPanel(false, true);
 
@@ -134,7 +132,7 @@ public class ChangesViewManager implements ProjectComponent, JDOMExternalizable
     ActionManager.getInstance().getAction("ChangesView.Rename").registerCustomShortcutSet(CommonShortcuts.getRename(), panel);
 
     final CustomShortcutSet diffShortcut =
-      new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_D, SystemInfo.isMac ? KeyEvent.META_DOWN_MASK : KeyEvent.CTRL_DOWN_MASK));
+      new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_D, SystemInfo.isMac ? InputEvent.META_DOWN_MASK : InputEvent.CTRL_DOWN_MASK));
     ActionManager.getInstance().getAction("ChangesView.Diff").registerCustomShortcutSet(diffShortcut, panel);
 
     JPanel toolbarPanel = new JPanel(new BorderLayout());
@@ -148,8 +146,8 @@ public class ChangesViewManager implements ProjectComponent, JDOMExternalizable
     ToggleShowFlattenAction showFlattenAction = new ToggleShowFlattenAction();
     showFlattenAction.registerCustomShortcutSet(new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_P,
                                                                                              SystemInfo.isMac
-                                                                                             ? KeyEvent.META_DOWN_MASK
-                                                                                             : KeyEvent.CTRL_DOWN_MASK)),
+                                                                                             ? InputEvent.META_DOWN_MASK
+                                                                                             : InputEvent.CTRL_DOWN_MASK)),
                                                 panel);
     visualActionsGroup.add(showFlattenAction);
     visualActionsGroup.add(ActionManager.getInstance().getAction(IdeActions.ACTION_COPY));                                              
@@ -204,7 +202,7 @@ public class ChangesViewManager implements ProjectComponent, JDOMExternalizable
   }
 
   void refreshView() {
-    if (myDisposed || (! myProject.isInitialized()) || ApplicationManager.getApplication().isUnitTestMode()) return;
+    if (myDisposed || ! myProject.isInitialized() || ApplicationManager.getApplication().isUnitTestMode()) return;
     ChangeListManagerImpl changeListManager = ChangeListManagerImpl.getInstanceImpl(myProject);
     myView.updateModel(changeListManager.getChangeListsCopy(),
                        changeListManager.getUnversionedFiles(),
@@ -227,14 +225,8 @@ public class ChangesViewManager implements ProjectComponent, JDOMExternalizable
 
   public void selectFile(final VirtualFile vFile) {
     if (vFile == null) return;
-    Object objectToFind;
     Change change = ChangeListManager.getInstance(myProject).getChange(vFile);
-    if (change != null) {
-      objectToFind = change;
-    }
-    else {
-      objectToFind = vFile;
-    }
+    Object objectToFind = change != null ? change : vFile;
 
     DefaultMutableTreeNode root = (DefaultMutableTreeNode)myView.getModel().getRoot();
     DefaultMutableTreeNode node = TreeUtil.findNodeWithObject(root, objectToFind);

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/committed/IncomingChangesIndicator.java

@@ -4,6 +4,7 @@ import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.components.ProjectComponent;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.IconLoader;
 import com.intellij.openapi.vcs.VcsBundle;
 import com.intellij.openapi.vcs.changes.ui.ChangesViewContentManager;
@@ -12,6 +13,7 @@ import com.intellij.openapi.wm.StatusBar;
 import com.intellij.openapi.wm.ToolWindow;
 import com.intellij.openapi.wm.ToolWindowManager;
 import com.intellij.openapi.wm.WindowManager;
+import com.intellij.openapi.Disposable;
 import com.intellij.ui.SimpleColoredComponent;
 import com.intellij.util.messages.MessageBus;
 import org.jetbrains.annotations.NonNls;
@@ -52,10 +54,14 @@ public class IncomingChangesIndicator implements ProjectComponent {
     myStatusBar = WindowManager.getInstance().getStatusBar(myProject);
     myIndicatorComponent = new IndicatorComponent();
     myStatusBar.addCustomIndicationComponent(myIndicatorComponent);
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        myStatusBar.removeCustomIndicationComponent(myIndicatorComponent);
+      }
+    });
   }
 
   public void projectClosed() {
-    myStatusBar.removeCustomIndicationComponent(myIndicatorComponent);
   }
 
   @NonNls

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ui/ChangesViewContentManager.java

@@ -7,12 +7,11 @@ package com.intellij.openapi.vcs.changes.ui;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.ModalityState;
-import com.intellij.openapi.components.ProjectComponent;
+import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.project.DumbAwareRunnable;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.project.ProjectManager;
-import com.intellij.openapi.project.ProjectManagerAdapter;
 import com.intellij.openapi.startup.StartupManager;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.IconLoader;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.vcs.AbstractVcs;
@@ -36,17 +35,16 @@ import java.util.List;
 /**
  * @author yole
  */
-public class ChangesViewContentManager implements ProjectComponent {
+public class ChangesViewContentManager extends AbstractProjectComponent {
   public static final String TOOLWINDOW_ID = VcsBundle.message("changes.toolwindow.name");
   private static final Key<ChangesViewContentEP> myEPKey = Key.create("ChangesViewContentEP");
-  private ChangesViewContentManager.MyContentManagerListener myContentManagerListener;
+  private MyContentManagerListener myContentManagerListener;
   private final ProjectLevelVcsManager myVcsManager;
 
   public static ChangesViewContentManager getInstance(Project project) {
     return project.getComponent(ChangesViewContentManager.class);
   }
 
-  private final Project myProject;
   private ContentManager myContentManager;
   private ToolWindow myToolWindow;
   private final VcsListener myVcsListener = new MyVcsListener();
@@ -54,7 +52,7 @@ public class ChangesViewContentManager implements ProjectComponent {
   private final List<Content> myAddedContents = new ArrayList<Content>();
 
   public ChangesViewContentManager(final Project project, final ProjectLevelVcsManager vcsManager) {
-    myProject = project;
+    super(project);
     myVcsManager = vcsManager;
     myVcsChangeAlarm = new Alarm(Alarm.ThreadToUse.SWING_THREAD, project);
   }
@@ -71,12 +69,21 @@ public class ChangesViewContentManager implements ProjectComponent {
           myContentManager = myToolWindow.getContentManager();
           myContentManagerListener = new MyContentManagerListener();
           myContentManager.addContentManagerListener(myContentManagerListener);
+
           for(Content content: myAddedContents) {
             myContentManager.addContent(content);
           }
           myAddedContents.clear();
           myVcsManager.addVcsListener(myVcsListener);
-          ProjectManager.getInstance().addProjectManagerListener(myProject, new MyProjectManagerListener());
+
+          Disposer.register(myProject, new Disposable(){
+            public void dispose() {
+              myContentManager.removeContentManagerListener(myContentManagerListener);
+
+              myVcsManager.removeVcsListener(myVcsListener);
+            }
+          });
+
           loadExtensionTabs();
           if (myContentManager.getContentCount() > 0) {
             myContentManager.setSelectedContent(myContentManager.getContent(0));
@@ -139,12 +146,7 @@ public class ChangesViewContentManager implements ProjectComponent {
   }
 
   public void projectClosed() {
-    myVcsManager.removeVcsListener(myVcsListener);
     myVcsChangeAlarm.cancelAllRequests();
-    if (ApplicationManager.getApplication().isHeadlessEnvironment()) return;
-    if (myToolWindow != null) {
-      ToolWindowManager.getInstance(myProject).unregisterToolWindow(TOOLWINDOW_ID);
-    }
   }
 
   @NonNls @NotNull
@@ -161,12 +163,6 @@ public class ChangesViewContentManager implements ProjectComponent {
     }
   }
 
-  public void initComponent() {
-  }
-
-  public void disposeComponent() {
-  }
-
   public void removeContent(final Content content) {
     myContentManager.removeContent(content, true);
   }
@@ -215,7 +211,7 @@ public class ChangesViewContentManager implements ProjectComponent {
   private static class ContentStub extends JPanel {
     private final ChangesViewContentEP myEP;
 
-    public ContentStub(final ChangesViewContentEP EP) {
+    private ContentStub(final ChangesViewContentEP EP) {
       myEP = EP;
     }
 
@@ -237,13 +233,4 @@ public class ChangesViewContentManager implements ProjectComponent {
       }
     }
   }
-
-  private class MyProjectManagerListener extends ProjectManagerAdapter {
-    public void projectClosing(final Project project) {
-      if (myContentManager != null) {
-        myContentManager.removeContentManagerListener(myContentManagerListener);
-      }
-      ProjectManager.getInstance().removeProjectManagerListener(project, this);
-    }
-  }
 }

platform/vcs-impl/src/com/intellij/openapi/vcs/impl/LineStatusTrackerManager.java

@@ -26,6 +26,7 @@ import com.intellij.openapi.editor.ex.DocumentBulkUpdateListener;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.fileEditor.FileEditorManager;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vcs.AbstractVcs;
 import com.intellij.openapi.vcs.FileStatus;
 import com.intellij.openapi.vcs.FileStatusListener;
@@ -35,6 +36,7 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.VirtualFileAdapter;
 import com.intellij.openapi.vfs.VirtualFileEvent;
 import com.intellij.openapi.vfs.VirtualFileManager;
+import com.intellij.openapi.Disposable;
 import com.intellij.testFramework.LightVirtualFile;
 import com.intellij.util.Alarm;
 import com.intellij.util.containers.HashMap;
@@ -64,14 +66,6 @@ public class LineStatusTrackerManager implements ProjectComponent {
   @NonNls protected static final String IGNORE_CHANGEMARKERS_KEY = "idea.ignore.changemarkers";
   private final ProjectLevelVcsManagerImpl myVcsManager;
   private final VcsFileStatusProvider myStatusProvider;
-  private final MyFileStatusListener myFileStatusListener = new MyFileStatusListener();
-  private final EditorFactoryListener myEditorFactoryListener = new MyEditorFactoryListener();
-  private final MyVirtualFileListener myVirtualFileListener = new MyVirtualFileListener();
-  private final EditorColorsListener myEditorColorsListener = new EditorColorsListener() {
-    public void globalSchemeChange(EditorColorsScheme scheme) {
-      resetTrackersForOpenFiles();
-    }
-  };
 
   public LineStatusTrackerManager(final Project project, final ProjectLevelVcsManagerImpl vcsManager, final VcsFileStatusProvider statusProvider) {
     myProject = project;
@@ -92,11 +86,26 @@ public class LineStatusTrackerManager implements ProjectComponent {
   }
 
   public void projectOpened() {
+    final MyFileStatusListener myFileStatusListener = new MyFileStatusListener();
+    final EditorFactoryListener myEditorFactoryListener = new MyEditorFactoryListener();
+    final MyVirtualFileListener myVirtualFileListener = new MyVirtualFileListener();
+    final EditorColorsListener myEditorColorsListener = new EditorColorsListener() {
+      public void globalSchemeChange(EditorColorsScheme scheme) {
+        resetTrackersForOpenFiles();
+      }
+    };
+
     myLineStatusTrackers = new HashMap<Document, LineStatusTracker>();
-    FileStatusManager.getInstance(myProject).addFileStatusListener(myFileStatusListener);
+    FileStatusManager.getInstance(myProject).addFileStatusListener(myFileStatusListener, myProject);
     EditorFactory.getInstance().addEditorFactoryListener(myEditorFactoryListener);
-    VirtualFileManager.getInstance().addVirtualFileListener(myVirtualFileListener);
+    VirtualFileManager.getInstance().addVirtualFileListener(myVirtualFileListener,myProject);
     EditorColorsManager.getInstance().addEditorColorsListener(myEditorColorsListener);
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        EditorFactory.getInstance().removeEditorFactoryListener(myEditorFactoryListener);
+        EditorColorsManager.getInstance().removeEditorColorsListener(myEditorColorsListener);
+      }
+    });
   }
 
   public void projectClosed() {
@@ -128,11 +137,6 @@ public class LineStatusTrackerManager implements ProjectComponent {
       releaseTracker(tracker.getDocument());
     }
 
-    FileStatusManager.getInstance(myProject).removeFileStatusListener(myFileStatusListener);
-    EditorFactory.getInstance().removeEditorFactoryListener(myEditorFactoryListener);
-    VirtualFileManager.getInstance().removeVirtualFileListener(myVirtualFileListener);
-    EditorColorsManager.getInstance().removeEditorColorsListener(myEditorColorsListener);
-
     myLineStatusTrackers = null;
 }
 

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/XDebuggerManagerImpl.java

@@ -21,6 +21,7 @@ import com.intellij.openapi.fileEditor.FileEditorManagerAdapter;
 import com.intellij.openapi.fileEditor.FileEditorManager;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.impl.http.HttpVirtualFile;
+import com.intellij.openapi.Disposable;
 import com.intellij.util.containers.HashMap;
 import com.intellij.util.xmlb.annotations.Property;
 import com.intellij.util.messages.MessageBus;
@@ -55,18 +56,6 @@ public class XDebuggerManagerImpl extends XDebuggerManager
   private final ExecutionPointHighlighter myExecutionPointHighlighter;
   private XDebugSessionImpl myLastActiveSession;
 
-  private final RunContentListener myContentListener = new RunContentListener() {
-    public void contentSelected(RunContentDescriptor descriptor) {
-    }
-
-    public void contentRemoved(RunContentDescriptor descriptor) {
-      XDebugSessionTab sessionTab = mySessionTabs.remove(descriptor.getProcessHandler());
-      if (sessionTab != null) {
-        Disposer.dispose(sessionTab);
-      }
-    }
-  };
-
 
   public XDebuggerManagerImpl(final Project project, final StartupManager startupManager, MessageBus messageBus) {
     myProject = project;
@@ -91,14 +80,30 @@ public class XDebuggerManagerImpl extends XDebuggerManager
   }
 
   public void projectOpened() {
-    RunContentManager contentManager = ExecutionManager.getInstance(myProject).getContentManager();
+    final RunContentManager contentManager = ExecutionManager.getInstance(myProject).getContentManager();
     LOG.assertTrue(contentManager != null, "Content manager is null");
+    final RunContentListener myContentListener = new RunContentListener() {
+      public void contentSelected(RunContentDescriptor descriptor) {
+      }
+
+      public void contentRemoved(RunContentDescriptor descriptor) {
+        XDebugSessionTab sessionTab = mySessionTabs.remove(descriptor.getProcessHandler());
+        if (sessionTab != null) {
+          Disposer.dispose(sessionTab);
+        }
+      }
+    };
+
+
     contentManager.addRunContentListener(myContentListener, DefaultDebugExecutor.getDebugExecutorInstance());
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        contentManager.removeRunContentListener(myContentListener);
+      }
+    });
   }
 
   public void projectClosed() {
-    final RunContentManager contentManager = ExecutionManager.getInstance(myProject).getContentManager();
-    contentManager.removeRunContentListener(myContentListener);
   }
 
   public Project getProject() {
@@ -115,7 +120,6 @@ public class XDebuggerManagerImpl extends XDebuggerManager
   }
 
   public void disposeComponent() {
-    myBreakpointManager.dispose();
   }
 
   @NotNull

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointManagerImpl.java

@@ -33,7 +33,6 @@ public class XBreakpointManagerImpl implements XBreakpointManager, PersistentSta
   private final Project myProject;
   private final XDebuggerManagerImpl myDebuggerManager;
   private final XDependentBreakpointManager myDependentBreakpointManager;
-  private HttpVirtualFileListener myHttpVirtualFileListener;
 
   public XBreakpointManagerImpl(final Project project, final XDebuggerManagerImpl debuggerManager, StartupManager startupManager) {
     myProject = project;
@@ -42,12 +41,12 @@ public class XBreakpointManagerImpl implements XBreakpointManager, PersistentSta
     myDependentBreakpointManager = new XDependentBreakpointManager(this);
     myLineBreakpointManager = new XLineBreakpointManager(project, myDependentBreakpointManager, startupManager);
     if (!project.isDefault()) {
-      myHttpVirtualFileListener = new HttpVirtualFileListener() {
+      HttpVirtualFileListener httpVirtualFileListener = new HttpVirtualFileListener() {
         public void fileDownloaded(@NotNull final VirtualFile file) {
           updateBreakpointInFile(file);
         }
       };
-      HttpFileSystem.getInstance().addFileListener(myHttpVirtualFileListener);
+      HttpFileSystem.getInstance().addFileListener(httpVirtualFileListener, project);
     }
   }
 
@@ -65,13 +64,6 @@ public class XBreakpointManagerImpl implements XBreakpointManager, PersistentSta
     });
   }
 
-  public void dispose() {
-    myLineBreakpointManager.dispose();
-    if (!myProject.isDefault()) {
-      HttpFileSystem.getInstance().removeFileListener(myHttpVirtualFileListener);
-    }
-  }
-
   public XLineBreakpointManager getLineBreakpointManager() {
     return myLineBreakpointManager;
   }
@@ -89,7 +81,7 @@ public class XBreakpointManagerImpl implements XBreakpointManager, PersistentSta
   }
 
   @NotNull
-  public <T extends XBreakpointProperties> XBreakpoint<T> addBreakpoint(final XBreakpointType<XBreakpoint<T>,T> type, final @Nullable T properties) {
+  public <T extends XBreakpointProperties> XBreakpoint<T> addBreakpoint(final XBreakpointType<XBreakpoint<T>,T> type, @Nullable final T properties) {
     ApplicationManager.getApplication().assertWriteAccessAllowed();
     XBreakpointBase.BreakpointState<?,T,?> state = new XBreakpointBase.BreakpointState<XBreakpoint<T>,T,XBreakpointType<XBreakpoint<T>,T>>(true, type.getId());
     XBreakpointBase<?,T, ?> breakpoint = new XBreakpointBase<XBreakpoint<T>,T, XBreakpointBase.BreakpointState<?,T,?>>(type, this, properties, state);

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XLineBreakpointManager.java

@@ -2,8 +2,8 @@ package com.intellij.xdebugger.impl.breakpoints;
 
 import com.intellij.ide.startup.StartupManagerEx;
 import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.application.WriteAction;
 import com.intellij.openapi.application.Result;
+import com.intellij.openapi.application.WriteAction;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.EditorFactory;
@@ -13,34 +13,33 @@ import com.intellij.openapi.editor.markup.RangeHighlighter;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.startup.StartupManager;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.Disposable;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.util.containers.BidirectionalMap;
 import com.intellij.util.ui.update.MergingUpdateQueue;
 import com.intellij.util.ui.update.Update;
-import com.intellij.xdebugger.XDebuggerUtil;
 import com.intellij.xdebugger.XDebuggerManager;
+import com.intellij.xdebugger.XDebuggerUtil;
 import com.intellij.xdebugger.breakpoints.XBreakpoint;
 import gnu.trove.TIntHashSet;
 import org.jetbrains.annotations.NotNull;
 
 import java.awt.event.MouseEvent;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
-import java.util.ArrayList;
 
 /**
  * @author nik
  */
 public class XLineBreakpointManager {
   private final BidirectionalMap<XLineBreakpointImpl, Document> myBreakpoints = new BidirectionalMap<XLineBreakpointImpl, Document>();
-  private final MergingUpdateQueue myBreakpointsUpdateQueue = new MergingUpdateQueue("XLine breakpoints", 300, true, null);
-  private DocumentAdapter myDocumentListener;
+  private final MergingUpdateQueue myBreakpointsUpdateQueue;
   private final Project myProject;
   private final XDependentBreakpointManager myDependentBreakpointManager;
   private final StartupManagerEx myStartupManager;
-  private EditorMouseAdapter myEditorMouseListener;
-  private MyDependentBreakpointListener myDependentBreakpointListener;
 
   public XLineBreakpointManager(Project project, final XDependentBreakpointManager dependentBreakpointManager, final StartupManager startupManager) {
     myProject = project;
@@ -48,16 +47,22 @@ public class XLineBreakpointManager {
     myStartupManager = (StartupManagerEx)startupManager;
 
     if (!myProject.isDefault()) {
-      myDocumentListener = new MyDocumentListener();
-      myEditorMouseListener = new MyEditorMouseListener();
+      DocumentAdapter documentListener = new MyDocumentListener();
+      EditorMouseAdapter editorMouseListener = new MyEditorMouseListener();
 
       EditorEventMulticaster editorEventMulticaster = EditorFactory.getInstance().getEventMulticaster();
-      editorEventMulticaster.addDocumentListener(myDocumentListener);
-      editorEventMulticaster.addEditorMouseListener(myEditorMouseListener);
+      editorEventMulticaster.addDocumentListener(documentListener,project);
+      editorEventMulticaster.addEditorMouseListener(editorMouseListener, project);
 
-      myDependentBreakpointListener = new MyDependentBreakpointListener();
+      final MyDependentBreakpointListener myDependentBreakpointListener = new MyDependentBreakpointListener();
       myDependentBreakpointManager.addListener(myDependentBreakpointListener);
+      Disposer.register(project, new Disposable() {
+        public void dispose() {
+          myDependentBreakpointManager.removeListener(myDependentBreakpointListener);
+        }
+      });
     }
+    myBreakpointsUpdateQueue = new MergingUpdateQueue("XLine breakpoints", 300, true, null, project);
   }
 
   public void updateBreakpointsUI() {
@@ -118,16 +123,6 @@ public class XLineBreakpointManager {
     }.execute();
   }
 
-  public void dispose() {
-    if (!myProject.isDefault()) {
-      EditorEventMulticaster editorEventMulticaster = EditorFactory.getInstance().getEventMulticaster();
-      editorEventMulticaster.removeDocumentListener(myDocumentListener);
-      editorEventMulticaster.removeEditorMouseListener(myEditorMouseListener);
-      myDependentBreakpointManager.removeListener(myDependentBreakpointListener);
-    }
-    myBreakpointsUpdateQueue.dispose();
-  }
-
   public void breakpointChanged(final XLineBreakpointImpl breakpoint) {
     ApplicationManager.getApplication().assertIsDispatchThread();
     breakpoint.updateUI();

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/evaluate/quick/common/ValueLookupManager.java

@@ -34,11 +34,10 @@ public class ValueLookupManager implements EditorMouseMotionListener, ProjectCom
   }
 
   public void projectOpened() {
-    EditorFactory.getInstance().getEventMulticaster().addEditorMouseMotionListener(this);
+    EditorFactory.getInstance().getEventMulticaster().addEditorMouseMotionListener(this,myProject);
   }
 
   public void projectClosed() {
-    EditorFactory.getInstance().getEventMulticaster().removeEditorMouseMotionListener(this);
     myAlarm.cancelAllRequests();
   }
 

plugins/copyright/src/com/maddyhome/idea/copyright/CopyrightManager.java

@@ -53,9 +53,8 @@ import java.util.*;
     id = "default",
     file = "$PROJECT_FILE$"), @Storage(id = "dir", file = "$PROJECT_CONFIG_DIR$/copyright/", scheme = StorageScheme.DIRECTORY_BASED,
                                        stateSplitter = CopyrightManager.CopyrightStateSplitter.class)})
-public class CopyrightManager implements ProjectComponent, JDOMExternalizable, PersistentStateComponent<Element> {
+public class CopyrightManager extends AbstractProjectComponent implements JDOMExternalizable, PersistentStateComponent<Element> {
   private static final Logger LOG = Logger.getInstance("#" + CopyrightManager.class.getName());
-  private FileEditorManagerListener myListener = null;
   @Nullable
   private CopyrightProfile myDefaultCopyright = null;
 
@@ -65,10 +64,8 @@ public class CopyrightManager implements ProjectComponent, JDOMExternalizable, P
 
   private final Options myOptions = new Options();
 
-  private final Project myProject;
-
   public CopyrightManager(Project project) {
-    myProject = project;
+    super(project);
   }
 
   @NonNls
@@ -89,7 +86,7 @@ public class CopyrightManager implements ProjectComponent, JDOMExternalizable, P
 
   public void projectOpened() {
     if (myProject != null) {
-      myListener = new FileEditorManagerAdapter() {
+      FileEditorManagerListener listener = new FileEditorManagerAdapter() {
         public void fileOpened(FileEditorManager fileEditorManager, VirtualFile virtualFile) {
           if (virtualFile.isWritable() && NewFileTracker.getInstance().contains(virtualFile)) {
             NewFileTracker.getInstance().remove(virtualFile);
@@ -98,7 +95,7 @@ public class CopyrightManager implements ProjectComponent, JDOMExternalizable, P
               if (module != null) {
                 final PsiFile file = PsiManager.getInstance(myProject).findFile(virtualFile);
                 if (file != null) {
-                  ApplicationManager.getApplication().invokeLater(new Runnable(){
+                  ApplicationManager.getApplication().invokeLater(new Runnable() {
                     public void run() {
                       if (file.isValid() && file.isWritable()) {
                         new UpdateCopyrightProcessor(myProject, module, file).run();
@@ -112,13 +109,7 @@ public class CopyrightManager implements ProjectComponent, JDOMExternalizable, P
         }
       };
 
-      FileEditorManager.getInstance(myProject).addFileEditorManagerListener(myListener);
-    }
-  }
-
-  public void projectClosed() {
-    if (myProject != null && myListener != null) {
-      FileEditorManager.getInstance(myProject).removeFileEditorManagerListener(myListener);
+      FileEditorManager.getInstance(myProject).addFileEditorManagerListener(listener, myProject);
     }
   }
 
@@ -128,12 +119,6 @@ public class CopyrightManager implements ProjectComponent, JDOMExternalizable, P
     return "CopyrightManager";
   }
 
-  public void initComponent() {
-  }
-
-  public void disposeComponent() {
-  }
-
   public void readExternal(Element element) throws InvalidDataException {
     clearCopyrights();
     final Element module2copyright = element.getChild(MODULE2COPYRIGHT);

plugins/properties/src/com/intellij/lang/properties/PropertiesFilesManager.java

@@ -1,10 +1,12 @@
 package com.intellij.lang.properties;
 
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.components.ProjectComponent;
+import com.intellij.openapi.components.AbstractProjectComponent;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.project.DumbService;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.encoding.EncodingManager;
 import com.intellij.psi.search.GlobalSearchScope;
@@ -19,47 +21,48 @@ import java.util.Collection;
 /**
  * @author max
  */
-public class PropertiesFilesManager implements ProjectComponent {
-  private final Project myProject;
-  private final PropertyChangeListener myListener = new PropertyChangeListener() {
-    public void propertyChange(final PropertyChangeEvent evt) {
-      if (EncodingManager.PROP_NATIVE2ASCII_SWITCH.equals(evt.getPropertyName()) ||
-          EncodingManager.PROP_PROPERTIES_FILES_ENCODING.equals(evt.getPropertyName())
-        ) {
-        DumbService.getInstance(myProject).smartInvokeLater(new Runnable(){
-          public void run() {
-            ApplicationManager.getApplication().runWriteAction(new Runnable(){
-              public void run() {
-                if (myProject.isDisposed()) return;
-                Collection<VirtualFile> filesToRefresh = getAllPropertiesFiles();
-                VirtualFile[] virtualFiles = filesToRefresh.toArray(new VirtualFile[filesToRefresh.size()]);
-                FileDocumentManager.getInstance().saveAllDocuments();
-
-                //force to re-detect encoding
-                for (VirtualFile virtualFile : virtualFiles) {
-                  virtualFile.setCharset(null);
-                }
-                FileDocumentManager.getInstance().reloadFiles(virtualFiles);
-              }
-            });
-          }
-        });
-      }
-    }
-  };
-
+public class PropertiesFilesManager extends AbstractProjectComponent {
   public static PropertiesFilesManager getInstance(Project project) {
     return project.getComponent(PropertiesFilesManager.class);
   }
 
   public PropertiesFilesManager(Project project) {
-    myProject = project;
+    super(project);
   }
 
   public void projectOpened() {
-  }
+    final PropertyChangeListener myListener = new PropertyChangeListener() {
+      public void propertyChange(final PropertyChangeEvent evt) {
+        if (EncodingManager.PROP_NATIVE2ASCII_SWITCH.equals(evt.getPropertyName()) ||
+            EncodingManager.PROP_PROPERTIES_FILES_ENCODING.equals(evt.getPropertyName())
+          ) {
+          DumbService.getInstance(myProject).smartInvokeLater(new Runnable(){
+            public void run() {
+              ApplicationManager.getApplication().runWriteAction(new Runnable(){
+                public void run() {
+                  if (myProject.isDisposed()) return;
+                  Collection<VirtualFile> filesToRefresh = getAllPropertiesFiles();
+                  VirtualFile[] virtualFiles = filesToRefresh.toArray(new VirtualFile[filesToRefresh.size()]);
+                  FileDocumentManager.getInstance().saveAllDocuments();
 
-  public void projectClosed() {
+                  //force to re-detect encoding
+                  for (VirtualFile virtualFile : virtualFiles) {
+                    virtualFile.setCharset(null);
+                  }
+                  FileDocumentManager.getInstance().reloadFiles(virtualFiles);
+                }
+              });
+            }
+          });
+        }
+      }
+    };
+    EncodingManager.getInstance().addPropertyChangeListener(myListener);
+    Disposer.register(myProject, new Disposable() {
+      public void dispose() {
+        EncodingManager.getInstance().removePropertyChangeListener(myListener);
+      }
+    });
   }
 
   @NotNull
@@ -67,14 +70,6 @@ public class PropertiesFilesManager implements ProjectComponent {
     return "PropertiesFileManager";
   }
 
-  public void initComponent() {
-    EncodingManager.getInstance().addPropertyChangeListener(myListener);
-  }
-
-  public void disposeComponent() {
-    EncodingManager.getInstance().removePropertyChangeListener(myListener);
-  }
-
   public Collection<VirtualFile> getAllPropertiesFiles() {
     return FileBasedIndex.getInstance().getContainingFiles(PropertyFileIndex.NAME, PropertiesFileType.FILE_TYPE.getName(), GlobalSearchScope.allScope(myProject));
   }

plugins/ui-designer/src/com/intellij/uiDesigner/propertyInspector/UIDesignerToolWindowManager.java

@@ -45,7 +45,6 @@ public class UIDesignerToolWindowManager implements ProjectComponent {
   private ComponentTreeBuilder myComponentTreeBuilder;
   private PropertyInspector myPropertyInspector;
   private final FileEditorManager myFileEditorManager;
-  private final MyFileEditorManagerListener myListener;
   private ToolWindow myToolWindow;
   private boolean myToolWindowReady = false;
   private boolean myToolWindowDisposed = false;
@@ -53,8 +52,8 @@ public class UIDesignerToolWindowManager implements ProjectComponent {
   public UIDesignerToolWindowManager(final Project project, final FileEditorManager fileEditorManager) {
     myProject = project;
     myFileEditorManager = fileEditorManager;
-    myListener = new MyFileEditorManagerListener();
-    myFileEditorManager.addFileEditorManagerListener(myListener);
+    MyFileEditorManagerListener listener = new MyFileEditorManagerListener();
+    myFileEditorManager.addFileEditorManagerListener(listener,project);
   }
 
   public void projectOpened() {
@@ -82,15 +81,13 @@ public class UIDesignerToolWindowManager implements ProjectComponent {
     myToolWindowPanel.setSecondComponent(myPropertyInspector);
     myToolWindow = ToolWindowManager.getInstance(myProject).registerToolWindow(UIDesignerBundle.message("toolwindow.ui.designer"),
                                                                                myToolWindowPanel,
-                                                                               ToolWindowAnchor.LEFT);
+                                                                               ToolWindowAnchor.LEFT, myProject);
     myToolWindow.setIcon(IconLoader.getIcon("/com/intellij/uiDesigner/icons/toolWindowUIDesigner.png"));
     myToolWindow.setAvailable(false, null);
   }
 
   public void projectClosed() {
     if (myToolWindowPanel != null) {
-      ToolWindowManager.getInstance(myProject).unregisterToolWindow(UIDesignerBundle.message("toolwindow.ui.designer"));
-      myFileEditorManager.removeFileEditorManagerListener(myListener);
       if (myComponentTreeBuilder != null) {
         Disposer.dispose(myComponentTreeBuilder);
       }
@@ -111,7 +108,7 @@ public class UIDesignerToolWindowManager implements ProjectComponent {
   public void disposeComponent() {
   }
 
-  private MergingUpdateQueue myQueue = new MergingUpdateQueue("property.inspector", 200, true, null);
+  private final MergingUpdateQueue myQueue = new MergingUpdateQueue("property.inspector", 200, true, null);
 
   private void processFileEditorChange(final UIFormEditor newEditor) {
     myQueue.cancelAllUpdates();

refactoring/tests/com/intellij/refactoring/IntroduceFieldWitSetUpInitializationTest.java

@@ -29,8 +29,8 @@ import org.junit.Before;
 import java.io.File;
 
 public class IntroduceFieldWitSetUpInitializationTest extends CodeInsightTestCase {
-  protected Module createModule(final String path) {
-    final Module module = super.createModule(path);
+  protected Module createModule(final String name) {
+    final Module module = super.createModule(name);
     final ModifiableRootModel model = ModuleRootManager.getInstance(module).getModifiableModel();
     final LibraryTable.ModifiableModel modifiableModel = model.getModuleLibraryTable().getModifiableModel();
     final Library library = modifiableModel.createLibrary("junit");

xml/impl/src/com/intellij/javaee/PsiExternalResourceNotifier.java

@@ -1,32 +1,34 @@
 package com.intellij.javaee;
 
 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
-import com.intellij.openapi.components.ProjectComponent;
+import com.intellij.openapi.components.AbstractProjectComponent;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.Disposable;
 import com.intellij.psi.impl.PsiManagerEx;
 import org.jetbrains.annotations.NotNull;
 
 /**
  * @author yole
  */
-public class PsiExternalResourceNotifier implements ProjectComponent {
-  private final ExternalResourceListener myExternalResourceListener;
+public class PsiExternalResourceNotifier extends AbstractProjectComponent {
   private final PsiManagerEx myPsiManager;
   private final ExternalResourceManagerEx myExternalResourceManager;
   private final DaemonCodeAnalyzer myDaemonCodeAnalyzer;
 
   public PsiExternalResourceNotifier(PsiManagerEx psiManager, ExternalResourceManager externalResourceManager,
-                                     final DaemonCodeAnalyzer daemonCodeAnalyzer) {
+                                     final DaemonCodeAnalyzer daemonCodeAnalyzer, Project project) {
+    super(project);
     myPsiManager = psiManager;
     myExternalResourceManager = (ExternalResourceManagerEx)externalResourceManager;
     myDaemonCodeAnalyzer = daemonCodeAnalyzer;
-    myExternalResourceListener = new MyExternalResourceListener();
+    final ExternalResourceListener myExternalResourceListener = new MyExternalResourceListener();
     myExternalResourceManager.addExternalResourceListener(myExternalResourceListener);
-  }
-
-  public void projectOpened() {
-  }
-
-  public void projectClosed() {
+    Disposer.register(project, new Disposable() {
+      public void dispose() {
+        myExternalResourceManager.removeExternalResourceListener(myExternalResourceListener);
+      }
+    });
   }
 
   @NotNull
@@ -34,13 +36,6 @@ public class PsiExternalResourceNotifier implements ProjectComponent {
     return "PsiExternalResourceNotifier";
   }
 
-  public void initComponent() {
-  }
-
-  public void disposeComponent() {
-    myExternalResourceManager.removeExternalResourceListener(myExternalResourceListener);
-  }
-
   private class MyExternalResourceListener implements ExternalResourceListener {
     public void externalResourceChanged() {
       myPsiManager.physicalChange();