Refactor SpdyHttpStream to implement HttpStream. Required adding a new...

net/spdy/spdy_http_stream.cc

 // Copyright (c) 2010 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/spdy/spdy_http_stream.h"
 
 #include <algorithm>
 #include <list>
 #include <string>
 
@@ skipping 111 matching lines @@
     (*headers)["cache-control"] = "no-cache";
   } else if (info.load_flags & net::LOAD_VALIDATE_CACHE) {
     (*headers)["cache-control"] = "max-age=0";
   }
 }
 
 }  // anonymous namespace
 
 namespace net {
 
-SpdyHttpStream::SpdyHttpStream()
+SpdyHttpStream::SpdyHttpStream(SpdySession* spdy_session)
     : ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_factory_(this)),
       stream_(NULL),
-      spdy_session_(NULL),
+      spdy_session_(spdy_session),
       response_info_(NULL),
       download_finished_(false),
       user_callback_(NULL),
       user_buffer_len_(0),
       buffered_read_callback_pending_(false),
       more_read_data_pending_(false) { }
 
 SpdyHttpStream::~SpdyHttpStream() {
   if (stream_)
     stream_->DetachDelegate();
 }
 
-int SpdyHttpStream::InitializeStream(
-    SpdySession* spdy_session,
-    const HttpRequestInfo& request_info,
-    const BoundNetLog& stream_net_log,
-    CompletionCallback* callback) {
-  spdy_session_ = spdy_session;
+int SpdyHttpStream::InitializeStream(const HttpRequestInfo* request_info,
+                                     const BoundNetLog& stream_net_log,
+                                     CompletionCallback* callback) {
   request_info_ = request_info;
-  if (request_info_.method == "GET") {
-    int error = spdy_session_->GetPushStream(request_info.url, &stream_,
+  if (request_info_->method == "GET") {
+    int error = spdy_session_->GetPushStream(request_info_->url, &stream_,
                                              stream_net_log);
     if (error != OK)
       return error;
   }
 
   if (stream_.get())
     return OK;
   else
-    return spdy_session_->CreateStream(request_info_.url,
-                                       request_info_.priority, &stream_,
+    return spdy_session_->CreateStream(request_info_->url,
+                                       request_info_->priority, &stream_,
                                        stream_net_log, callback);
 }
 
-void SpdyHttpStream::InitializeRequest(
-    base::Time request_time,
-    UploadDataStream* upload_data) {
-  CHECK(stream_.get());
-  stream_->SetDelegate(this);
-  linked_ptr<spdy::SpdyHeaderBlock> headers(new spdy::SpdyHeaderBlock);
-  CreateSpdyHeadersFromHttpRequest(request_info_, headers.get());
-  stream_->set_spdy_headers(headers);
-
-  stream_->SetRequestTime(request_time);
-  // This should only get called in the case of a request occuring
-  // during server push that has already begun but hasn't finished,
-  // so we set the response's request time to be the actual one
-  if (response_info_)
-    response_info_->request_time = request_time;
-
-  CHECK(!request_body_stream_.get());
-  if (upload_data) {
-    if (upload_data->size())
-      request_body_stream_.reset(upload_data);
-    else
-      delete upload_data;
-  }
-}
-
 const HttpResponseInfo* SpdyHttpStream::GetResponseInfo() const {
   return response_info_;
 }
 
 uint64 SpdyHttpStream::GetUploadProgress() const {
   if (!request_body_stream_.get())
     return 0;
 
   return request_body_stream_->position();
 }
@@ skipping 50 matching lines @@
   CHECK(!user_callback_);
   CHECK(!user_buffer_);
   CHECK_EQ(0, user_buffer_len_);
 
   user_callback_ = callback;
   user_buffer_ = buf;
   user_buffer_len_ = buf_len;
   return ERR_IO_PENDING;
 }
 
-int SpdyHttpStream::SendRequest(HttpResponseInfo* response,
+int SpdyHttpStream::SendRequest(const std::string& /*headers_string*/,

[vandebo (ex-Chrome), 2010/07/28 23:30:39]

My mistake, it's in the headers that we comment it out.

+                                UploadDataStream* request_body,
+                                HttpResponseInfo* response,
                                 CompletionCallback* callback) {
+  base::Time request_time = base::Time::Now();
+  CHECK(stream_.get());
+
+  stream_->SetDelegate(this);
+  linked_ptr<spdy::SpdyHeaderBlock> headers(new spdy::SpdyHeaderBlock);
+  CreateSpdyHeadersFromHttpRequest(*request_info_, headers.get());
+  stream_->set_spdy_headers(headers);
+
+  stream_->SetRequestTime(request_time);
+  // This should only get called in the case of a request occurring
+  // during server push that has already begun but hasn't finished,
+  // so we set the response's request time to be the actual one
+  if (response_info_)
+    response_info_->request_time = request_time;
+
+  CHECK(!request_body_stream_.get());
+  if (request_body) {
+    if (request_body->size())
+      request_body_stream_.reset(request_body);
+    else
+      delete request_body;
+  }
+
   CHECK(callback);
   CHECK(!stream_->cancelled());
   CHECK(response);
 
   if (stream_->response_complete()) {
     if (stream_->response_status() == OK)
       return ERR_FAILED;
     else
       return stream_->response_status();
   }
@@ skipping 59 matching lines @@
     push_response_info_.reset(new HttpResponseInfo);
     response_info_ = push_response_info_.get();
   }
 
   if (!SpdyHeadersToHttpResponse(response, response_info_)) {
     status = ERR_INVALID_RESPONSE;
   } else {
     stream_->GetSSLInfo(&response_info_->ssl_info,
                         &response_info_->was_npn_negotiated);
     response_info_->request_time = stream_->GetRequestTime();
-    response_info_->vary_data.Init(request_info_, *response_info_->headers);
+    response_info_->vary_data.Init(*request_info_, *response_info_->headers);
     // TODO(ahendrickson): This is recorded after the entire SYN_STREAM control
     // frame has been received and processed.  Move to framer?
     response_info_->response_time = response_time;
   }
 
   if (user_callback_)
     DoCallback(status);
   return status;
 }
 
@@ skipping 97 matching lines @@
   CHECK_NE(rv, ERR_IO_PENDING);
   CHECK(user_callback_);
 
   // Since Run may result in being called back, clear user_callback_ in advance.
   CompletionCallback* c = user_callback_;
   user_callback_ = NULL;
   c->Run(rv);
 }
 
 }  // namespace net