- switching data buffering only once per state change

- upon before file deletion event remove the file from myFilesToUpdate
- rename inner class and other cleanup

platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexImpl.java

@@ -160,10 +160,8 @@ public class FileBasedIndexImpl extends FileBasedIndex {
     connection.subscribe(PsiDocumentTransactionListener.TOPIC, new PsiDocumentTransactionListener() {
       @Override
       public void transactionStarted(@NotNull final Document doc, @NotNull final PsiFile file) {
-        if (file != null) {
-          myTransactionMap = myTransactionMap.plus(doc, file);
-          myUpToDateIndicesForUnsavedOrTransactedDocuments.clear();
-        }
+        myTransactionMap = myTransactionMap.plus(doc, file);
+        myUpToDateIndicesForUnsavedOrTransactedDocuments.clear();
       }
 
       @Override
@@ -1336,7 +1334,7 @@ public class FileBasedIndexImpl extends FileBasedIndex {
 
     if (!documents.isEmpty()) {
       // now index unsaved data
-      final StorageGuard.Holder guard = setDataBufferingEnabled(true);
+      final StorageGuard.StorageModeExitHandler guard = setDataBufferingEnabled(true);
       try {
         final Semaphore semaphore = myUnsavedDataIndexingSemaphores.get(indexId);
 
@@ -1515,20 +1513,26 @@ public class FileBasedIndexImpl extends FileBasedIndex {
   }
 
   private final StorageGuard myStorageLock = new StorageGuard();
+  private volatile boolean myPreviousDataBufferingState;
+  private final Object myBufferingStateUpdateLock = new Object();
 
   @NotNull
-  private StorageGuard.Holder setDataBufferingEnabled(final boolean enabled) {
-    final StorageGuard.Holder holder = myStorageLock.enter(enabled);
-    for (ID<?, ?> indexId : myIndices.keySet()) {
-      final MapReduceIndex index = (MapReduceIndex)getIndex(indexId);
-      assert index != null;
-      MemoryIndexStorage storage = (MemoryIndexStorage)index.getStorage();
-      if (storage.isBufferingEnabled() == enabled) {
-        break; // already set it
+  private StorageGuard.StorageModeExitHandler setDataBufferingEnabled(final boolean enabled) {
+    StorageGuard.StorageModeExitHandler storageModeExitHandler = myStorageLock.enter(enabled);
+
+    if (myPreviousDataBufferingState != enabled) {
+      synchronized (myBufferingStateUpdateLock) {
+        if (myPreviousDataBufferingState != enabled) {
+          for (ID<?, ?> indexId : myIndices.keySet()) {
+            final MapReduceIndex index = (MapReduceIndex)getIndex(indexId);
+            assert index != null;
+            ((MemoryIndexStorage)index.getStorage()).setBufferingEnabled(enabled);
+          }
+          myPreviousDataBufferingState = enabled;
+        }
       }
-      storage.setBufferingEnabled(enabled);
     }
-    return holder;
+    return storageModeExitHandler;
   }
 
   private void cleanupMemoryStorage() {
@@ -1770,7 +1774,7 @@ public class FileBasedIndexImpl extends FileBasedIndex {
       @Override
       public Boolean compute() {
         Boolean result;
-        final StorageGuard.Holder lock = setDataBufferingEnabled(false);
+        final StorageGuard.StorageModeExitHandler lock = setDataBufferingEnabled(false);
         try {
           result = update.compute();
         }
@@ -1857,11 +1861,6 @@ public class FileBasedIndexImpl extends FileBasedIndex {
       markDirty(event, false);
     }
 
-    @Override
-    public void fileDeleted(@NotNull final VirtualFileEvent event) {
-      myFilesToUpdate.remove(event.getFile()); // no need to update it anymore
-    }
-
     @Override
     public void fileCopied(@NotNull final VirtualFileCopyEvent event) {
       markDirty(event, false);
@@ -2023,6 +2022,7 @@ public class FileBasedIndexImpl extends FileBasedIndex {
             }
           }
         }
+        myFilesToUpdate.remove(file); // no need to update it anymore
       }
 
       Collection<ID<?, ?>> fileIndexedStatesToUpdate = ContainerUtil.intersection(nontrivialFileIndexedStates, myRequiringContentIndices);
@@ -2577,17 +2577,17 @@ public class FileBasedIndexImpl extends FileBasedIndex {
     private int myHolds = 0;
     private int myWaiters = 0;
 
-    public interface Holder {
+    public interface StorageModeExitHandler {
       void leave();
     }
 
-    private final Holder myTrueHolder = new Holder() {
+    private final StorageModeExitHandler myTrueStorageModeExitHandler = new StorageModeExitHandler() {
       @Override
       public void leave() {
         StorageGuard.this.leave(true);
       }
     };
-    private final Holder myFalseHolder = new Holder() {
+    private final StorageModeExitHandler myFalseStorageModeExitHandler = new StorageModeExitHandler() {
       @Override
       public void leave() {
         StorageGuard.this.leave(false);
@@ -2595,20 +2595,20 @@ public class FileBasedIndexImpl extends FileBasedIndex {
     };
 
     @NotNull
-    public synchronized Holder enter(boolean mode) {
+    private synchronized StorageModeExitHandler enter(boolean mode) {
       if (mode) {
         while (myHolds < 0) {
           doWait();
         }
         myHolds++;
-        return myTrueHolder;
+        return myTrueStorageModeExitHandler;
       }
       else {
         while (myHolds > 0) {
           doWait();
         }
         myHolds--;
-        return myFalseHolder;
+        return myFalseStorageModeExitHandler;
       }
     }
 

platform/lang-impl/src/com/intellij/util/indexing/MemoryIndexStorage.java

@@ -24,7 +24,6 @@ import org.jetbrains.annotations.NotNull;
 
 import java.io.IOException;
 import java.util.*;
-import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * This storage is needed for indexing yet unsaved data without saving those changes to 'main' backend storage
@@ -37,7 +36,7 @@ public class MemoryIndexStorage<Key, Value> implements IndexStorage<Key, Value>
   @NotNull
   private final IndexStorage<Key, Value> myBackendStorage;
   private final List<BufferingStateListener> myListeners = ContainerUtil.createLockFreeCopyOnWriteList();
-  private final AtomicBoolean myBufferingEnabled = new AtomicBoolean(false);
+  private boolean myBufferingEnabled;
 
   public interface BufferingStateListener {
     void bufferingStateChanged(boolean newState);
@@ -63,16 +62,17 @@ public class MemoryIndexStorage<Key, Value> implements IndexStorage<Key, Value>
   }
 
   public void setBufferingEnabled(boolean enabled) {
-    final boolean wasEnabled = myBufferingEnabled.getAndSet(enabled);
-    if (wasEnabled != enabled) {
-      for (BufferingStateListener listener : myListeners) {
-        listener.bufferingStateChanged(enabled);
-      }
+    final boolean wasEnabled = myBufferingEnabled;
+    assert wasEnabled != enabled;
+
+    myBufferingEnabled = enabled;
+    for (BufferingStateListener listener : myListeners) {
+      listener.bufferingStateChanged(enabled);
     }
   }
 
   public boolean isBufferingEnabled() {
-    return myBufferingEnabled.get();
+    return myBufferingEnabled;
   }
 
   public void clearMemoryMap() {
@@ -137,7 +137,7 @@ public class MemoryIndexStorage<Key, Value> implements IndexStorage<Key, Value>
 
   @Override
   public void addValue(final Key key, final int inputId, final Value value) throws StorageException {
-    if (myBufferingEnabled.get()) {
+    if (myBufferingEnabled) {
       getMemValueContainer(key).addValue(inputId, value);
       return;
     }
@@ -151,7 +151,7 @@ public class MemoryIndexStorage<Key, Value> implements IndexStorage<Key, Value>
 
   @Override
   public void removeAllValues(@NotNull Key key, int inputId) throws StorageException {
-    if (myBufferingEnabled.get()) {
+    if (myBufferingEnabled) {
       getMemValueContainer(key).removeAssociatedValue(inputId);
       return;
     }
@@ -190,7 +190,7 @@ public class MemoryIndexStorage<Key, Value> implements IndexStorage<Key, Value>
   @Override
   @NotNull
   public ValueContainer<Value> read(final Key key) throws StorageException {
-    if (myBufferingEnabled.get()) {
+    if (myBufferingEnabled) {
       final ValueContainer<Value> valueContainer = myMap.get(key);
       if (valueContainer != null) {
         return valueContainer;