Add a QuicHttpStream class.

net/quic/quic_reliable_client_stream.cc

Index: net/quic/quic_reliable_client_stream.cc
diff --git a/net/quic/quic_reliable_client_stream.cc b/net/quic/quic_reliable_client_stream.cc
index 09fb01ef6c9fb114b07b062ffd00091f1df7fdbe..ccbf9e69e6e333f43f77f2bde42eebdffa989f93 100644
--- a/net/quic/quic_reliable_client_stream.cc
+++ b/net/quic/quic_reliable_client_stream.cc
@@ -5,19 +5,26 @@
 #include "net/quic/quic_reliable_client_stream.h"
 
 #include "net/base/net_errors.h"
+#include "net/quic/quic_session.h"
 
 namespace net {
 
 QuicReliableClientStream::QuicReliableClientStream(QuicStreamId id,
                                                    QuicSession* session)
-    : ReliableQuicStream(id, session) {
+    : ReliableQuicStream(id, session),
+      delegate_(NULL) {
 }
 
 QuicReliableClientStream::~QuicReliableClientStream() {
+  if (delegate_) {
+    delegate_->OnClose(error());
+  }
 }
 
 uint32 QuicReliableClientStream::ProcessData(const char* data,
                                              uint32 data_len) {
+  // TODO(rch): buffere data if we don't have a delegate.
+  DCHECK(delegate_);
   int rv = delegate_->OnDataReceived(data, data_len);
   if (rv != OK) {
     DLOG(ERROR) << "Delegate refused data, rv: " << rv;
@@ -28,12 +35,25 @@ uint32 QuicReliableClientStream::ProcessData(const char* data,
 }
 
 void QuicReliableClientStream::TerminateFromPeer(bool half_close) {
-  delegate_->OnClose(error());
+  if (delegate_) {
+    delegate_->OnClose(error());
+    delegate_ = NULL;
+  }
 }
 
 void QuicReliableClientStream::SetDelegate(
     QuicReliableClientStream::Delegate* delegate) {
+  DCHECK((!delegate_ && delegate) || (delegate_ && !delegate));
   delegate_ = delegate;
 }
 
+IPEndPoint QuicReliableClientStream::GetPeerAddress() {
+  return session()->connection()->peer_address();
+}
+
+int QuicReliableClientStream::WriteData(base::StringPiece data,
+                                        bool fin) {
+  return ReliableQuicStream::WriteData(data, fin);

[willchan no longer on Chromium, 2012/11/21 22:55:05]

This looks weird. Why are we overriding to just call the parent class's
implementation? If we expect to modify the implementation later, then this will
become more like implementation inheritance instead of composition. It's setting
off a code smell for me. Just calling this out so you're aware of it.

[Ryan Hamilton, 2012/11/21 23:06:35]

I overrode it so that I could make it public.  Would you prefer I make the base
class method public instead?

+}
+
 }  // namespace net