Rename QuicInMemoryCache to QuicHttpResponseCache.

net/tools/quic/quic_simple_server_session.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_session.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "net/quic/core/proto/cached_network_parameters.pb.h"
 #include "net/quic/core/quic_connection.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_spdy_session.h"
 #include "net/tools/quic/quic_simple_server_stream.h"
 #include "url/gurl.h"
 
 using std::string;
 
 namespace net {
 
 QuicSimpleServerSession::QuicSimpleServerSession(
     const QuicConfig& config,
     QuicConnection* connection,
     QuicSession::Visitor* visitor,
     QuicCryptoServerStream::Helper* helper,
     const QuicCryptoServerConfig* crypto_config,
     QuicCompressedCertsCache* compressed_certs_cache,
-    QuicInMemoryCache* in_memory_cache)
+    QuicHttpResponseCache* response_cache)
     : QuicServerSessionBase(config,
                             connection,
                             visitor,
                             helper,
                             crypto_config,
                             compressed_certs_cache),
       highest_promised_stream_id_(0),
-      in_memory_cache_(in_memory_cache) {}
+      response_cache_(response_cache) {}
 
 QuicSimpleServerSession::~QuicSimpleServerSession() {
   delete connection();
 }
 
 QuicCryptoServerStreamBase*
 QuicSimpleServerSession::CreateQuicCryptoServerStream(
     const QuicCryptoServerConfig* crypto_config,
     QuicCompressedCertsCache* compressed_certs_cache) {
   return new QuicCryptoServerStream(crypto_config, compressed_certs_cache,
@@ skipping 14 matching lines @@
     connection()->CloseConnection(
         QUIC_INVALID_STREAM_ID, "Client sent data on server push stream",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
   QuicSpdySession::OnStreamFrame(frame);
 }
 
 void QuicSimpleServerSession::PromisePushResources(
     const string& request_url,
-    const std::list<QuicInMemoryCache::ServerPushInfo>& resources,
+    const std::list<QuicHttpResponseCache::ServerPushInfo>& resources,
     QuicStreamId original_stream_id,
     const SpdyHeaderBlock& original_request_headers) {
   if (!server_push_enabled()) {
     return;
   }
 
-  for (QuicInMemoryCache::ServerPushInfo resource : resources) {
+  for (QuicHttpResponseCache::ServerPushInfo resource : resources) {
     SpdyHeaderBlock headers = SynthesizePushRequestHeaders(
         request_url, resource, original_request_headers);
     highest_promised_stream_id_ += 2;
     SendPushPromise(original_stream_id, highest_promised_stream_id_,
                     headers.Clone());
     promised_streams_.push_back(PromisedStreamInfo(
         std::move(headers), highest_promised_stream_id_, resource.priority));
   }
 
   // Procese promised push request as many as possible.
   HandlePromisedPushRequests();
 }
 
 QuicSpdyStream* QuicSimpleServerSession::CreateIncomingDynamicStream(
     QuicStreamId id) {
   if (!ShouldCreateIncomingDynamicStream(id)) {
     return nullptr;
   }
 
   QuicSpdyStream* stream =
-      new QuicSimpleServerStream(id, this, in_memory_cache_);
+      new QuicSimpleServerStream(id, this, response_cache_);
   ActivateStream(base::WrapUnique(stream));
   return stream;
 }
 
 QuicSimpleServerStream* QuicSimpleServerSession::CreateOutgoingDynamicStream(
     SpdyPriority priority) {
   if (!ShouldCreateOutgoingDynamicStream()) {
     return nullptr;
   }
 
   QuicSimpleServerStream* stream = new QuicSimpleServerStream(
-      GetNextOutgoingStreamId(), this, in_memory_cache_);
+      GetNextOutgoingStreamId(), this, response_cache_);
   stream->SetPriority(priority);
   ActivateStream(base::WrapUnique(stream));
   return stream;
 }
 
 void QuicSimpleServerSession::CloseStreamInner(QuicStreamId stream_id,
                                                bool locally_reset) {
   QuicSpdySession::CloseStreamInner(stream_id, locally_reset);
   HandlePromisedPushRequests();
 }
@@ skipping 21 matching lines @@
     DCHECK(frame.stream_id >= next_outgoing_stream_id());
     size_t index = (frame.stream_id - next_outgoing_stream_id()) / 2;
     DCHECK(index <= promised_streams_.size());
     promised_streams_[index].is_cancelled = true;
     connection()->SendRstStream(frame.stream_id, QUIC_RST_ACKNOWLEDGEMENT, 0);
   }
 }
 
 SpdyHeaderBlock QuicSimpleServerSession::SynthesizePushRequestHeaders(
     string request_url,
-    QuicInMemoryCache::ServerPushInfo resource,
+    QuicHttpResponseCache::ServerPushInfo resource,
     const SpdyHeaderBlock& original_request_headers) {
   GURL push_request_url = resource.request_url;
   string path = push_request_url.path();
 
   SpdyHeaderBlock spdy_headers = original_request_headers.Clone();
   // :authority could be different from original request.
   spdy_headers[":authority"] = push_request_url.host();
   spdy_headers[":path"] = path;
   // Push request always use GET.
   spdy_headers[":method"] = "GET";
@@ skipping 37 matching lines @@
     DVLOG(1) << "created server push stream " << promised_stream->id();
 
     SpdyHeaderBlock request_headers(std::move(promised_info.request_headers));
 
     promised_streams_.pop_front();
     promised_stream->PushResponse(std::move(request_headers));
   }
 }
 
 }  // namespace net