vcs: add simplier interface for BackgroundableActionEnabledHandler

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

@@ -15,30 +15,27 @@
  */
 package com.intellij.openapi.vcs.impl;
 
-import com.intellij.openapi.application.ApplicationManager;
-
-import java.util.HashSet;
-import java.util.Set;
+import com.intellij.openapi.project.Project;
 
+@Deprecated
 public class BackgroundableActionEnabledHandler {
-  private final Set<Object> myInProgress;
+  private final Project myProject;
+  private final VcsBackgroundableActions myAction;
 
-  public BackgroundableActionEnabledHandler() {
-    myInProgress = new HashSet<Object>();
+  BackgroundableActionEnabledHandler(Project project, VcsBackgroundableActions action) {
+    myProject = project;
+    myAction = action;
   }
 
   public void register(final Object path) {
-    ApplicationManager.getApplication().assertIsDispatchThread();
-    myInProgress.add(path);
+    BackgroundableActionLock.lock(myProject, myAction, path);
   }
 
   public boolean isInProgress(final Object path) {
-    ApplicationManager.getApplication().assertIsDispatchThread();
-    return myInProgress.contains(path);
+    return BackgroundableActionLock.isLocked(myProject, myAction, path);
   }
 
   public void completed(final Object path) {
-    ApplicationManager.getApplication().assertIsDispatchThread();
-    myInProgress.remove(path);
+    BackgroundableActionLock.unlock(myProject, myAction, path);
   }
 }

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2000-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.openapi.vcs.impl;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vcs.ProjectLevelVcsManager;
+import org.jetbrains.annotations.CalledInAwt;
+import org.jetbrains.annotations.NotNull;
+
+public class BackgroundableActionLock {
+  @NotNull private final Project myProject;
+  @NotNull private final Object[] myKeys;
+
+  BackgroundableActionLock(@NotNull Project project, @NotNull final Object[] keys) {
+    myProject = project;
+    myKeys = keys;
+  }
+
+  @CalledInAwt
+  public boolean isLocked() {
+    return isLocked(myProject, myKeys);
+  }
+
+  @CalledInAwt
+  public void lock() {
+    lock(myProject, myKeys);
+  }
+
+  @CalledInAwt
+  public void unlock() {
+    unlock(myProject, myKeys);
+  }
+
+
+  @NotNull
+  public static BackgroundableActionLock getLock(@NotNull Project project, @NotNull Object... keys) {
+    return new BackgroundableActionLock(project, keys);
+  }
+
+  @CalledInAwt
+  public static boolean isLocked(@NotNull Project project, @NotNull Object... keys) {
+    return getManager(project).isBackgroundTaskRunning(keys);
+  }
+
+  @CalledInAwt
+  public static void lock(@NotNull Project project, @NotNull Object... keys) {
+    getManager(project).startBackgroundTask(keys);
+  }
+
+  @CalledInAwt
+  public static void unlock(@NotNull Project project, @NotNull Object... keys) {
+    getManager(project).stopBackgroundTask(keys);
+  }
+
+  @NotNull
+  private static ProjectLevelVcsManagerImpl getManager(@NotNull Project project) {
+    return (ProjectLevelVcsManagerImpl)ProjectLevelVcsManager.getInstance(project);
+  }
+}

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

@@ -70,10 +70,8 @@ import com.intellij.util.text.DateFormatUtil;
 import org.jdom.Attribute;
 import org.jdom.DataConversionException;
 import org.jdom.Element;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.annotations.TestOnly;
+import org.jetbrains.annotations.CalledInAwt;
+import org.jetbrains.annotations.*;
 
 import javax.swing.*;
 import java.awt.*;
@@ -119,7 +117,7 @@ public class ProjectLevelVcsManagerImpl extends ProjectLevelVcsManagerEx impleme
 
   private volatile int myBackgroundOperationCounter = 0;
 
-  private final Map<VcsBackgroundableActions, BackgroundableActionEnabledHandler> myBackgroundableActionHandlerMap;
+  private final Set<ActionKey> myBackgroundRunningTasks = ContainerUtil.newHashSet();
 
   private final List<Pair<String, ConsoleViewContentType>> myPendingOutput = ContainerUtil.newArrayList();
 
@@ -139,7 +137,6 @@ public class ProjectLevelVcsManagerImpl extends ProjectLevelVcsManagerEx impleme
 
     myDefaultVcsRootPolicy = DefaultVcsRootPolicy.getInstance(project);
 
-    myBackgroundableActionHandlerMap = new EnumMap<VcsBackgroundableActions, BackgroundableActionEnabledHandler>(VcsBackgroundableActions.class);
     myInitialization = new VcsInitialization(myProject);
     myMappings = new NewMappings(myProject, myMessageBus, this, manager);
     myMappingsToRoots = new MappingsToRoots(myMappings, myProject);
@@ -814,15 +811,31 @@ public class ProjectLevelVcsManagerImpl extends ProjectLevelVcsManagerEx impleme
     return myMappings.haveDefaultMapping();
   }
 
+  /**
+   * @deprecated {@link BackgroundableActionLock}
+   */
+  @Deprecated
   public BackgroundableActionEnabledHandler getBackgroundableActionHandler(final VcsBackgroundableActions action) {
     ApplicationManager.getApplication().assertIsDispatchThread();
+    return new BackgroundableActionEnabledHandler(myProject, action);
+  }
 
-    BackgroundableActionEnabledHandler result = myBackgroundableActionHandlerMap.get(action);
-    if (result == null) {
-      result = new BackgroundableActionEnabledHandler();
-      myBackgroundableActionHandlerMap.put(action, result);
-    }
-    return result;
+  @CalledInAwt
+  boolean isBackgroundTaskRunning(@NotNull Object... keys) {
+    ApplicationManager.getApplication().assertIsDispatchThread();
+    return myBackgroundRunningTasks.contains(new ActionKey(keys));
+  }
+
+  @CalledInAwt
+  void startBackgroundTask(@NotNull Object... keys) {
+    ApplicationManager.getApplication().assertIsDispatchThread();
+    LOG.assertTrue(myBackgroundRunningTasks.add(new ActionKey(keys)));
+  }
+
+  @CalledInAwt
+  void stopBackgroundTask(@NotNull Object... keys) {
+    ApplicationManager.getApplication().assertIsDispatchThread();
+    LOG.assertTrue(myBackgroundRunningTasks.remove(new ActionKey(keys)));
   }
 
   public void addInitializationRequest(final VcsInitObject vcsInitObject, final Runnable runnable) {
@@ -909,4 +922,28 @@ public class ProjectLevelVcsManagerImpl extends ProjectLevelVcsManagerEx impleme
   public void waitForInitialized() {
     myInitialization.waitForInitialized();
   }
+
+  private static class ActionKey {
+    private final Object[] myObjects;
+
+    public ActionKey(@NotNull Object... objects) {
+      myObjects = objects;
+    }
+
+    @Override
+    public final boolean equals(Object o) {
+      if (o == null || getClass() != o.getClass()) return false;
+      return Arrays.equals(myObjects, ((ActionKey)o).myObjects);
+    }
+
+    @Override
+    public final int hashCode() {
+      return Arrays.hashCode(myObjects);
+    }
+
+    @Override
+    public String toString() {
+      return getClass() + " - " + Arrays.toString(myObjects);
+    }
+  }
 }