Implement server push protocol 2.

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 244 matching lines @@
 }
 
 int SpdyHttpStream::SendRequest(const std::string& /*headers_string*/,
                                 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_->pushed() && stream_->response_complete()) {
     if (stream_->response_status() == OK)
       return ERR_FAILED;
     else
       return stream_->response_status();
   }
 
   // SendRequest can be called in two cases.
   //
   // a) A client initiated request. In this case, |response_info_| should be
   //    NULL to start with.
   // b) A client request which matches a response that the server has already
-  //    pushed.  In this case, the value of |*push_response_info_| is copied
-  //    over to the new response object |*response|.  |push_response_info_| is
-  //    deleted, and |response_info_| is reset |response|.
+  //    pushed.
   if (push_response_info_.get()) {
-    *response = *push_response_info_;
+    *response = *(push_response_info_.get());
     push_response_info_.reset();
-    response_info_ = NULL;
   }
+  else
+    DCHECK_EQ(static_cast<HttpResponseInfo*>(NULL), response_info_);
 
-  DCHECK_EQ(static_cast<HttpResponseInfo*>(NULL), response_info_);
   response_info_ = response;
 
   bool has_upload_data = request_body_stream_.get() != NULL;
   int result = stream_->DoSendRequest(has_upload_data);
   if (result == ERR_IO_PENDING) {
     CHECK(!user_callback_);
     user_callback_ = callback;
   }
   return result;
 }
@@ skipping 157 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