Implement Drain() on HttpPipelinedStream.

net/http/http_pipelined_connection_impl.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_pipelined_connection_impl.h"
 
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_pipelined_stream.h"
 #include "net/http/http_request_info.h"
+#include "net/http/http_response_body_drainer.h"
+#include "net/http/http_response_headers.h"
 #include "net/http/http_stream_parser.h"
 #include "net/socket/client_socket_handle.h"
 
 namespace net {
 
 HttpPipelinedConnectionImpl::HttpPipelinedConnectionImpl(
     ClientSocketHandle* connection,
     HttpPipelinedConnection::Delegate* delegate,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
@@ skipping 577 matching lines @@
 
 void HttpPipelinedConnectionImpl::GetSSLCertRequestInfo(
     int pipeline_id,
     SSLCertRequestInfo* cert_request_info) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK(stream_info_map_[pipeline_id].parser.get());
   return stream_info_map_[pipeline_id].parser->GetSSLCertRequestInfo(
       cert_request_info);
 }
 
+void HttpPipelinedConnectionImpl::Drain(HttpPipelinedStream* stream,
+                                        HttpNetworkSession* session) {
+  HttpResponseHeaders* headers = stream->GetResponseInfo()->headers;
+  if (!stream->CanFindEndOfResponse() || headers->IsChunkEncoded()) {

[mmenke, 2011/11/30 00:52:59]

One more comment.  Feel free to worry about it later.  I'm pretty sure we can
end up here and be not usable (Maybe another request was pending?).  If so, we
can probably just delete the stream, too.

[James Simonsen, 2011/11/30 19:39:14]

Done.

+    // TODO(simonjam): Drain chunk-encoded responses if they're relatively
+    // common.
+    stream->Close(true);
+    delete stream;
+    return;
+  }
+  HttpResponseBodyDrainer* drainer = new HttpResponseBodyDrainer(stream);
+  drainer->StartWithSize(session, headers->GetContentLength());
+  // |drainer| will delete itself when done.
+}
+
 void HttpPipelinedConnectionImpl::QueueUserCallback(
     int pipeline_id,
     OldCompletionCallback* callback,
     int rv,
     const tracked_objects::Location& from_here) {
   CHECK(!stream_info_map_[pipeline_id].pending_user_callback);
   stream_info_map_[pipeline_id].pending_user_callback = callback;
   MessageLoop::current()->PostTask(
       from_here,
       method_factory_.NewRunnableMethod(
@@ skipping 50 matching lines @@
 HttpPipelinedConnectionImpl::StreamInfo::StreamInfo()
     : read_headers_callback(NULL),
       pending_user_callback(NULL),
       state(STREAM_CREATED) {
 }
 
 HttpPipelinedConnectionImpl::StreamInfo::~StreamInfo() {
 }
 
 }  // namespace net