Add OpaqueStreamRef constructor (#325)

Closes #318

src/proto/streams/streams.rs

@@ -482,30 +482,15 @@ where
     }
 
     pub fn next_incoming(&mut self) -> Option<StreamRef<B>> {
-        let key = {
         let mut me = self.inner.lock().unwrap();
         let me = &mut *me;
-
+        let key = me.actions.recv.next_incoming(&mut me.store);
-            match me.actions.recv.next_incoming(&mut me.store) {
-                Some(key) => {
-                    let mut stream = me.store.resolve(key);
-                    trace!("next_incoming; id={:?}, state={:?}", stream.id, stream.state);
-                    // Increment the ref count
-                    stream.ref_inc();
-
-                    // Return the key
-                    Some(key)
-                },
-                None => None,
-            }
-        };
 
         key.map(|key| {
+            let stream = &mut me.store.resolve(key);
+            trace!("next_incoming; id={:?}, state={:?}", stream.id, stream.state);
             StreamRef {
-                opaque: OpaqueStreamRef {
+                opaque: OpaqueStreamRef::new(self.inner.clone(), stream),
-                    inner: self.inner.clone(),
-                    key,
-                },
                 send_buffer: self.send_buffer.clone(),
             }
         })
@@ -586,7 +571,6 @@ where
         // implicitly closes the earlier stream IDs.
         //
         // See: carllerche/h2#11
-        let key = {
         let mut me = self.inner.lock().unwrap();
         let me = &mut *me;
 
@@ -651,17 +635,11 @@ where
         // closed state.
         debug_assert!(!stream.state.is_closed());
 
-            // Increment the stream ref count as we will be returning a handle.
-            stream.ref_inc();
-
-            stream.key()
-        };
-
         Ok(StreamRef {
-            opaque: OpaqueStreamRef {
+            opaque: OpaqueStreamRef::new(
-                inner: self.inner.clone(),
+                self.inner.clone(),
-                key: key,
+                &mut stream,
-            },
+            ),
             send_buffer: self.send_buffer.clone(),
         })
     }
@@ -973,6 +951,12 @@ impl<B> Clone for StreamRef<B> {
 // ===== impl OpaqueStreamRef =====
 
 impl OpaqueStreamRef {
+    fn new(inner: Arc<Mutex<Inner>>, stream: &mut store::Ptr) -> OpaqueStreamRef {
+        stream.ref_inc();
+        OpaqueStreamRef {
+            inner, key: stream.key()
+        }
+    }
     /// Called by a client to check for a received response.
     pub fn poll_response(&mut self) -> Poll<Response<()>, proto::Error> {
         let mut me = self.inner.lock().unwrap();
@@ -994,11 +978,8 @@ impl OpaqueStreamRef {
             try_ready!(me.actions.recv.poll_pushed(&mut stream))
         };
         Ok(Async::Ready(res.map(|(h, key)| {
-            me.store.resolve(key).ref_inc();
             let opaque_ref =
-                OpaqueStreamRef {
+                OpaqueStreamRef::new(self.inner.clone(), &mut me.store.resolve(key));
-                    inner: self.inner.clone(), key,
-                };
             (h, opaque_ref)
         })))
     }