Landing Recent QUIC changes until Fri Nov 18 23:21:04 2016 +0000

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 <list>
 #include <utility>
 
 #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/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_spdy_stream.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/spdy/spdy_protocol.h"
-#include "net/tools/quic/quic_in_memory_cache.h"
+#include "net/tools/quic/quic_http_response_cache.h"
 #include "net/tools/quic/quic_simple_server_session.h"
 
 using base::StringPiece;
 using base::StringToInt;
 using std::string;
 
 namespace net {
 
 QuicSimpleServerStream::QuicSimpleServerStream(
     QuicStreamId id,
     QuicSpdySession* session,
-    QuicInMemoryCache* in_memory_cache)
+    QuicHttpResponseCache* response_cache)
     : QuicSpdyStream(id, session),
       content_length_(-1),
-      in_memory_cache_(in_memory_cache) {}
+      response_cache_(response_cache) {}
 
 QuicSimpleServerStream::~QuicSimpleServerStream() {}
 
 void QuicSimpleServerStream::OnInitialHeadersComplete(
     bool fin,
     size_t frame_len,
     const QuicHeaderList& header_list) {
   QuicSpdyStream::OnInitialHeadersComplete(fin, frame_len, header_list);
   if (!SpdyUtils::CopyAndValidateHeaders(header_list, &content_length_,
                                          &request_headers_)) {
@@ skipping 77 matching lines @@
   }
 
   if (!base::ContainsKey(request_headers_, ":authority") ||
       !base::ContainsKey(request_headers_, ":path")) {
     DVLOG(1) << "Request headers do not contain :authority or :path.";
     SendErrorResponse();
     return;
   }
 
   // Find response in cache. If not found, send error response.
-  const QuicInMemoryCache::Response* response = nullptr;
+  const QuicHttpResponseCache::Response* response = nullptr;
   auto authority = request_headers_.find(":authority");
   auto path = request_headers_.find(":path");
   if (authority != request_headers_.end() && path != request_headers_.end()) {
-    response = in_memory_cache_->GetResponse(authority->second, path->second);
+    response = response_cache_->GetResponse(authority->second, path->second);
   }
   if (response == nullptr) {
     DVLOG(1) << "Response not found in cache.";
     SendNotFoundResponse();
     return;
   }
 
-  if (response->response_type() == QuicInMemoryCache::CLOSE_CONNECTION) {
+  if (response->response_type() == QuicHttpResponseCache::CLOSE_CONNECTION) {
     DVLOG(1) << "Special response: closing connection.";
     CloseConnectionWithDetails(QUIC_NO_ERROR, "Toy server forcing close");
     return;
   }
 
-  if (response->response_type() == QuicInMemoryCache::IGNORE_REQUEST) {
+  if (response->response_type() == QuicHttpResponseCache::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_[":authority"].as_string() +
                        request_headers_[":path"].as_string();
   int response_code;
   const SpdyHeaderBlock& response_headers = response->headers();
@@ skipping 15 matching lines @@
     // 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;
     }
   }
-  std::list<QuicInMemoryCache::ServerPushInfo> resources =
-      in_memory_cache_->GetServerPushResources(request_url);
+  std::list<QuicHttpResponseCache::ServerPushInfo> resources =
+      response_cache_->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_);
   }
 
@@ skipping 59 matching lines @@
   DVLOG(1) << "Writing trailers (fin = true): "
            << response_trailers.DebugString();
   WriteTrailers(std::move(response_trailers), nullptr);
 }
 
 const char* const QuicSimpleServerStream::kErrorResponseBody = "bad";
 const char* const QuicSimpleServerStream::kNotFoundResponseBody =
     "file not found";
 
 }  // namespace net