From ed4dd08df1f9f3f9258aaf41195f2cdfe7ff0f5d Mon Sep 17 00:00:00 2001
From: Eugene Zhuravlev <jeka@intellij.com>
Date: Mon, 30 Jan 2012 16:43:58 +0100
Subject: [PATCH] debugger event queue: more robust command cancellation when
 queue is closed

---
 .../engine/DebuggerManagerThreadImpl.java     | 18 ++++++++----------
 .../intellij/debugger/impl/EventQueue.java    | 19 ++++++++++---------
 .../impl/EventQueueClosedException.java       |  4 ++++
 .../debugger/impl/InvokeAndWaitThread.java    |  8 ++++----
 .../intellij/debugger/impl/InvokeThread.java  |  8 ++++----
 5 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/DebuggerManagerThreadImpl.java b/java/debugger/impl/src/com/intellij/debugger/engine/DebuggerManagerThreadImpl.java
index 027b82b25641..f5569d5bdb1f 100644
--- a/java/debugger/impl/src/com/intellij/debugger/engine/DebuggerManagerThreadImpl.java
+++ b/java/debugger/impl/src/com/intellij/debugger/engine/DebuggerManagerThreadImpl.java
@@ -73,22 +73,20 @@ public class DebuggerManagerThreadImpl extends InvokeAndWaitThread<DebuggerComma
     }
   }
 
-  public void pushBack(DebuggerCommandImpl managerCommand) {
-    if(myEvents.isClosed()) {
+  public boolean pushBack(DebuggerCommandImpl managerCommand) {
+    final boolean pushed = super.pushBack(managerCommand);
+    if (!pushed) {
       managerCommand.notifyCancelled();
     }
-    else {
-      super.pushBack(managerCommand);
-    }
+    return pushed;
   }
 
-  public void schedule(DebuggerCommandImpl managerCommand) {
-    if(myEvents.isClosed()) {
+  public boolean schedule(DebuggerCommandImpl managerCommand) {
+    final boolean scheduled = super.schedule(managerCommand);
+    if (!scheduled) {
       managerCommand.notifyCancelled();
     }
-    else {
-      super.schedule(managerCommand);
-    }
+    return scheduled;
   }
 
   /**
diff --git a/java/debugger/impl/src/com/intellij/debugger/impl/EventQueue.java b/java/debugger/impl/src/com/intellij/debugger/impl/EventQueue.java
index d222c97888d9..a7bd73ae541a 100644
--- a/java/debugger/impl/src/com/intellij/debugger/impl/EventQueue.java
+++ b/java/debugger/impl/src/com/intellij/debugger/impl/EventQueue.java
@@ -45,36 +45,42 @@ public class EventQueue<E> {
     }
   }
 
-  public void pushBack(@NotNull E event, int priority) {
+  public boolean pushBack(@NotNull E event, int priority) {
     if(LOG.isDebugEnabled()) {
       LOG.debug("pushBack event " + event);
     }
 
     myLock.lock();
     try {
-      assertOpen();
+      if (isClosed()) {
+        return false;
+      }
       getEventsList(priority).addFirst(event);
       myEventsAvailable.signalAll();
     }
     finally {
       myLock.unlock();
     }
+    return true;
   }
 
-  public void put(@NotNull E event, int priority) {
+  public boolean put(@NotNull E event, int priority) {
     if(LOG.isDebugEnabled()) {
       LOG.debug("put event " + event);
     }
 
     myLock.lock();
     try {
-      assertOpen();
+      if (isClosed()) {
+        return false;
+      }
       getEventsList(priority).offer(event);
       myEventsAvailable.signalAll();
     }
     finally {
       myLock.unlock();
     }
+    return true;
   }
 
   private LinkedList<E> getEventsList(final int priority) {
@@ -84,7 +90,6 @@ public class EventQueue<E> {
   public void close(){
     myLock.lock();
     try {
-      assertOpen();
       myIsClosed = true;
       myEventsAvailable.signalAll();
     }
@@ -93,10 +98,6 @@ public class EventQueue<E> {
     }
   }
 
-  private void assertOpen() {
-    if (myIsClosed) throw new AssertionError("Already closed");
-  }
-
   private E getEvent() throws EventQueueClosedException {
     myLock.lock();
     try {
diff --git a/java/debugger/impl/src/com/intellij/debugger/impl/EventQueueClosedException.java b/java/debugger/impl/src/com/intellij/debugger/impl/EventQueueClosedException.java
index be0cd485b30b..d58b663f522a 100644
--- a/java/debugger/impl/src/com/intellij/debugger/impl/EventQueueClosedException.java
+++ b/java/debugger/impl/src/com/intellij/debugger/impl/EventQueueClosedException.java
@@ -19,4 +19,8 @@ package com.intellij.debugger.impl;
  * @author lex
  */
 public class EventQueueClosedException extends Exception {
+  @Override
+  public Throwable fillInStackTrace() {
+    return this;
+  }
 }
diff --git a/java/debugger/impl/src/com/intellij/debugger/impl/InvokeAndWaitThread.java b/java/debugger/impl/src/com/intellij/debugger/impl/InvokeAndWaitThread.java
index 3278e59f1764..3576c86b4f65 100644
--- a/java/debugger/impl/src/com/intellij/debugger/impl/InvokeAndWaitThread.java
+++ b/java/debugger/impl/src/com/intellij/debugger/impl/InvokeAndWaitThread.java
@@ -28,12 +28,12 @@ public abstract class InvokeAndWaitThread<E extends DebuggerTask> extends Invoke
    * !!! Do not remove this code !!!
    * Otherwise it will be impossible to override schedule method
    */
-  public void schedule(E e) {
-    super.schedule(e);
+  public boolean schedule(E e) {
+    return super.schedule(e);
   }
 
-  public void pushBack(E e) {
-    super.pushBack(e);
+  public boolean pushBack(E e) {
+    return super.pushBack(e);
   }
 
   public void invokeAndWait(final E runnable) {
diff --git a/java/debugger/impl/src/com/intellij/debugger/impl/InvokeThread.java b/java/debugger/impl/src/com/intellij/debugger/impl/InvokeThread.java
index b3ddf3a90ed2..e8835275f907 100644
--- a/java/debugger/impl/src/com/intellij/debugger/impl/InvokeThread.java
+++ b/java/debugger/impl/src/com/intellij/debugger/impl/InvokeThread.java
@@ -172,18 +172,18 @@ public abstract class InvokeThread<E extends PrioritizedTask> {
     return request != null? request.getOwner() : null;
   }
 
-  public void schedule(E r) {
+  public boolean schedule(E r) {
     if(LOG.isDebugEnabled()) {
       LOG.debug("schedule " + r + " in " + this);
     }
-    myEvents.put(r, r.getPriority().ordinal());
+    return myEvents.put(r, r.getPriority().ordinal());
   }
 
-  public void pushBack(E r) {
+  public boolean pushBack(E r) {
     if(LOG.isDebugEnabled()) {
       LOG.debug("pushBack " + r + " in " + this);
     }
-    myEvents.pushBack(r, r.getPriority().ordinal());
+    return myEvents.pushBack(r, r.getPriority().ordinal());
   }
 
   protected void switchToRequest(WorkerThreadRequest newWorkerThread) {