relnote: Implement server push methods in QuicSimpleServerSession. Only modify toy Quic server, not…

net/tools/quic/quic_simple_server_stream.cc

 // Copyright (c) 2012 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/tools/quic/quic_simple_server_stream.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "net/quic/quic_flags.h"
-#include "net/quic/quic_spdy_session.h"
 #include "net/quic/quic_spdy_stream.h"
 #include "net/quic/spdy_utils.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/tools/quic/quic_in_memory_cache.h"
+#include "net/tools/quic/quic_simple_server_session.h"
 
 using base::StringPiece;
 using base::StringToInt;
 using std::string;
 
 namespace net {
 namespace tools {
 
 QuicSimpleServerStream::QuicSimpleServerStream(QuicStreamId id,
                                                QuicSpdySession* session)
@@ skipping 108 matching lines @@
     return;
   }
 
   if (response->response_type() == QuicInMemoryCache::IGNORE_REQUEST) {
     DVLOG(1) << "Special response: ignoring request.";
     return;
   }
 
   // Examing response status, if it was not pure integer as typical h2 response
   // status, send error response.
-  string request_url = request_headers_[":scheme"].as_string() + "://" +
-                       request_headers_[":authority"].as_string() +
-                       request_headers_[":path"].as_string();
+  string request_url;
+  if (!request_headers_[":scheme"].as_string().empty()) {
+    request_url = request_headers_[":scheme"].as_string() +"://" +
+                  request_headers_[":authority"].as_string() +
+                  request_headers_[":path"].as_string();
+  } else {
+    request_url = request_headers_[":authority"].as_string() +
+                  request_headers_[":path"].as_string();
+  }
   int response_code;
   SpdyHeaderBlock response_headers = response->headers();
   if (!base::StringToInt(response_headers[":status"], &response_code)) {
     DVLOG(1) << "Illegal (non-integer) response :status from cache: "
              << response_headers[":status"].as_string() << " for request "
              << request_url;
     SendErrorResponse();
     return;
   }
 
   if (id() % 2 == 0) {
     // A server initiated stream is only used for a server push response,
     // and only 200 and 30X response codes are supported for server push.
     // This behavior mirrors the HTTP/2 implementation.
     bool is_redirection = response_code / 100 == 3;
     if (response_code != 200 && !is_redirection) {
       LOG(WARNING) << "Response to server push request " << request_url
                    << " result in response code " << response_code;
       Reset(QUIC_STREAM_CANCELLED);
       return;
     }
   }
+  list<QuicInMemoryCache::ServerPushInfo> resources =
+      QuicInMemoryCache::GetInstance()->GetServerPushResources(request_url);
+  DVLOG(1) << "Found " << resources.size() << " push resources for stream "
+           << id();
+
+  if (!resources.empty()) {
+    QuicSimpleServerSession* session =
+        static_cast<QuicSimpleServerSession*>(spdy_session());
+    session->PromisePushResources(request_url, resources, id(),
+                                  request_headers_);
+  }
+
   DVLOG(1) << "Sending response for stream " << id();
   SendHeadersAndBodyAndTrailers(response->headers(), response->body(),
                                 response->trailers());
 }
 
 void QuicSimpleServerStream::SendErrorResponse() {
   DVLOG(1) << "Sending error response for stream " << id();
   SpdyHeaderBlock headers;
   headers[":status"] = "500";
   headers["content-length"] = base::UintToString(strlen(kErrorResponseBody));
@@ skipping 39 matching lines @@
   // Send the trailers. A FIN is always sent with trailers.
   DVLOG(1) << "Writing trailers (fin = true): "
            << response_trailers.DebugString();
   WriteTrailers(response_trailers, nullptr);
 }
 
 const char* const QuicSimpleServerStream::kErrorResponseBody = "bad";
 
 }  // namespace tools
 }  // namespace net