cppfool
diff --git a/‎core/src/main/java/com/google/net/stubby/ChannelImpl.java‎
Lines changed: 24 additions & 14 deletions b/‎core/src/main/java/com/google/net/stubby/ChannelImpl.java‎
Lines changed: 24 additions & 14 deletions
diff --git a/‎core/src/main/java/com/google/net/stubby/ServerCall.java‎
Lines changed: 0 additions & 12 deletions b/‎core/src/main/java/com/google/net/stubby/ServerCall.java‎
Lines changed: 0 additions & 12 deletions
diff --git a/‎core/src/main/java/com/google/net/stubby/ServerCallHandler.java‎
Lines changed: 2 additions & 1 deletion b/‎core/src/main/java/com/google/net/stubby/ServerCallHandler.java‎
Lines changed: 2 additions & 1 deletion
@@ -1,8 +1,9 @@
 package com.google.net.stubby;
 
 import com.google.common.base.Preconditions;
-import com.google.common.base.Throwables;
 import com.google.common.util.concurrent.AbstractService;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.SettableFuture;
@@ -161,19 +162,27 @@ private int available(InputStream is) {
       try {
         return is.available();
       } catch (IOException ex) {
-        throw Throwables.propagate(ex);
+        throw new RuntimeException(ex);
       }
     }
 
     @Override
     public void sendPayload(ReqT payload, SettableFuture<Void> accepted) {
       Preconditions.checkState(stream != null, "Not started");
-      InputStream payloadIs = method.streamRequest(payload);
-      if (accepted == null) {
-        stream.writeMessage(payloadIs, available(payloadIs), null);
-      } else {
-        inProcessFutures.add(accepted);
-        stream.writeMessage(payloadIs, available(payloadIs), new AcceptedRunnable(accepted));
+      boolean failed = true;
+      try {
+        InputStream payloadIs = method.streamRequest(payload);
+        if (accepted == null) {
+          stream.writeMessage(payloadIs, available(payloadIs), null);
+        } else {
+          inProcessFutures.add(accepted);
+          stream.writeMessage(payloadIs, available(payloadIs), new AcceptedRunnable(accepted));
+        }
+        failed = false;
+      } finally {
+        if (failed) {
+          cancel();
+        }
       }
       stream.flush();
     }
@@ -211,18 +220,19 @@ public void run() {
               if (theirs == null) {
                 ours.set(null);
               } else {
-                theirs.addListener(new Runnable() {
+                Futures.addCallback(theirs, new FutureCallback<Void>() {
                   @Override
-                  public void run() {
-                    // TODO(user): If their Future fails, should we Call.cancel()?
+                  public void onSuccess(Void result) {
                     ours.set(null);
                   }
+                  @Override
+                  public void onFailure(Throwable t) {
+                    ours.setException(t);
+                  }
                 }, MoreExecutors.directExecutor());
               }
             } catch (Throwable t) {
-              ours.set(null);
-              CallImpl.this.cancel();
-              Throwables.propagate(t);
+              ours.setException(t);
             }
           }
         });
 
@@ -32,18 +32,6 @@ public abstract class ServerCall<ResponseT> {
   // before client half closes. It may be that we treat such a case as an error. If we permit such
   // a case then we either get to generate a half close or purposefully omit it.
   public abstract static class Listener<RequestT> {
-    /**
-     * Called upon receiving all header information from the remote end-point.
-     * <p>This method should return quickly, as the same thread may be used to process other
-     * streams.
-     *
-     * @param headers the fully buffered received headers.
-     * @return a processing completion future, or {@code null} to indicate that processing of the
-     *         headers is immediately complete.
-     */
-    @Nullable
-    public abstract ListenableFuture<Void> headersRead(Metadata.Headers headers);
-
     /**
      * A request payload has been receiveed. For streaming calls, there may be zero payload
      * messages.
 
@@ -20,5 +20,6 @@ public interface ServerCallHandler<ReqT, RespT> {
    * @param call object for responding
    * @return listener for processing incoming messages for {@code call}
    */
-  ServerCall.Listener<ReqT> startCall(String fullMethodName, ServerCall<RespT> call);
+  ServerCall.Listener<ReqT> startCall(String fullMethodName, ServerCall<RespT> call,
+      Metadata.Headers headers);
 }
Original file line number	Diff line number	Diff line change
`@@ -20,5 +20,6 @@ public interface ServerCallHandler<ReqT, RespT> {`
`20`	`20`	`* @param call object for responding`
`21`	`21`	`* @return listener for processing incoming messages for {@code call}`
`22`	`22`	`*/`
`23`		`- ServerCall.Listener<ReqT> startCall(String fullMethodName, ServerCall<RespT> call);`
	`23`	`+ ServerCall.Listener<ReqT> startCall(String fullMethodName, ServerCall<RespT> call,`
	`24`	`+ Metadata.Headers headers);`
`24`	`25`	`}`