src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/RawChannelImpl.java

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this

@@ -30,30 +30,33 @@
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.channels.SelectableChannel;
 import java.nio.channels.SocketChannel;
+import java.util.function.Supplier;
 
 /*
  * Each RawChannel corresponds to a TCP connection (SocketChannel) but is
  * connected to a Selector and an ExecutorService for invoking the send and
  * receive callbacks. Also includes SSL processing.
  */
 final class RawChannelImpl implements RawChannel {
 
     private final HttpClientImpl client;
-    private final HttpConnection connection;
+    private final HttpConnection.DetachedConnectionChannel detachedChannel;
     private final Object         initialLock = new Object();
-    private ByteBuffer           initial;
+    private Supplier<ByteBuffer> initial;
 
     RawChannelImpl(HttpClientImpl client,
                    HttpConnection connection,
-                   ByteBuffer initial)
+                   Supplier<ByteBuffer> initial)
             throws IOException
     {
         this.client = client;
-        this.connection = connection;
+        this.detachedChannel = connection.detachChannel();
+        this.initial = initial;
+
         SocketChannel chan = connection.channel();
         client.cancelRegistration(chan);
         // Constructing a RawChannel is supposed to have a "hand over"
         // semantics, in other words if construction fails, the channel won't be
         // needed by anyone, in which case someone still needs to close it

@@ -62,33 +65,29 @@
         } catch (IOException e) {
             try {
                 chan.close();
             } catch (IOException e1) {
                 e.addSuppressed(e1);
+            } finally {
+                detachedChannel.close();
             }
             throw e;
         }
-        // empty the initial buffer into our own copy.
-        synchronized (initialLock) {
-            this.initial = initial.hasRemaining()
-                    ? Utils.copy(initial)
-                    : Utils.EMPTY_BYTEBUFFER;
-        }
     }
 
     private class NonBlockingRawAsyncEvent extends AsyncEvent {
 
         private final RawEvent re;
 
         NonBlockingRawAsyncEvent(RawEvent re) {
-            super(0); // !BLOCKING & !REPEATING
+            // !BLOCKING & !REPEATING
             this.re = re;
         }
 
         @Override
         public SelectableChannel channel() {
-            return connection.channel();
+            return detachedChannel.channel();
         }
 
         @Override
         public int interestOps() {
             return re.interestOps();

@@ -98,51 +97,62 @@
         public void handle() {
             re.handle();
         }
 
         @Override
-        public void abort() { }
+        public void abort(IOException ioe) { }
     }
 
     @Override
     public void registerEvent(RawEvent event) throws IOException {
         client.registerEvent(new NonBlockingRawAsyncEvent(event));
     }
 
     @Override
     public ByteBuffer read() throws IOException {
-        assert !connection.channel().isBlocking();
-        return connection.read();
+        assert !detachedChannel.channel().isBlocking();
+        // connection.read() will no longer be available.
+        return detachedChannel.read();
     }
 
     @Override
     public ByteBuffer initialByteBuffer() {
         synchronized (initialLock) {
             if (initial == null) {
                 throw new IllegalStateException();
             }
-            ByteBuffer ref = initial;
+            ByteBuffer ref = initial.get();
+            ref = ref.hasRemaining() ? Utils.copy(ref)
+                    : Utils.EMPTY_BYTEBUFFER;
             initial = null;
             return ref;
         }
     }
 
     @Override
     public long write(ByteBuffer[] src, int offset, int len) throws IOException {
-        return connection.write(src, offset, len);
+        // this makes the whitebox driver test fail.
+        return detachedChannel.write(src, offset, len);
     }
 
     @Override
     public void shutdownInput() throws IOException {
-        connection.shutdownInput();
+        detachedChannel.shutdownInput();
     }
 
     @Override
     public void shutdownOutput() throws IOException {
-        connection.shutdownOutput();
+        detachedChannel.shutdownOutput();
     }
 
     @Override
     public void close() throws IOException {
-        connection.close();
+        detachedChannel.close();
     }
+
+    @Override
+    public String toString() {
+        return super.toString()+"("+ detachedChannel.toString() + ")";
+    }
+
+
 }