Rename QuicSpdyServerStream to QuicSimpleServerStream. No behavior change.

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_spdy_server_stream.h"
+#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"
 
 using base::StringPiece;
 using base::StringToInt;
 using std::string;
 
 namespace net {
 namespace tools {
 
-QuicSpdyServerStream::QuicSpdyServerStream(QuicStreamId id,
-                                           QuicSpdySession* session)
+QuicSimpleServerStream::QuicSimpleServerStream(QuicStreamId id,
+                                               QuicSpdySession* session)
     : QuicSpdyStream(id, session), content_length_(-1) {}
 
-QuicSpdyServerStream::~QuicSpdyServerStream() {
-}
+QuicSimpleServerStream::~QuicSimpleServerStream() {}
 
-void QuicSpdyServerStream::OnInitialHeadersComplete(bool fin,
-                                                    size_t frame_len) {
+void QuicSimpleServerStream::OnInitialHeadersComplete(bool fin,
+                                                      size_t frame_len) {
   QuicSpdyStream::OnInitialHeadersComplete(fin, frame_len);
   if (!SpdyUtils::ParseHeaders(decompressed_headers().data(),
                                decompressed_headers().length(),
                                &content_length_, &request_headers_)) {
     DVLOG(1) << "Invalid headers";
     SendErrorResponse();
   }
   MarkHeadersConsumed(decompressed_headers().length());
 }
 
-void QuicSpdyServerStream::OnTrailingHeadersComplete(bool fin,
-                                                     size_t frame_len) {
+void QuicSimpleServerStream::OnTrailingHeadersComplete(bool fin,
+                                                       size_t frame_len) {
   LOG(DFATAL) << "Server does not support receiving Trailers.";
   SendErrorResponse();
 }
 
-void QuicSpdyServerStream::OnDataAvailable() {
+void QuicSimpleServerStream::OnDataAvailable() {
   while (HasBytesToRead()) {
     struct iovec iov;
     if (GetReadableRegions(&iov, 1) == 0) {
       // No more data to read.
       break;
     }
     DVLOG(1) << "Processed " << iov.iov_len << " bytes for stream " << id();
     body_.append(static_cast<char*>(iov.iov_base), iov.iov_len);
 
     if (content_length_ >= 0 &&
@@ skipping 28 matching lines @@
       content_length_ != static_cast<int>(body_.size())) {
     DVLOG(1) << "Content length (" << content_length_ << ") != body size ("
              << body_.size() << ").";
     SendErrorResponse();
     return;
   }
 
   SendResponse();
 }
 
-void QuicSpdyServerStream::SendResponse() {
+void QuicSimpleServerStream::SendResponse() {
   if (!ContainsKey(request_headers_, ":authority") ||
       !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 =
       QuicInMemoryCache::GetInstance()->GetResponse(
@@ skipping 40 matching lines @@
                    << " result in response code " << response_code;
       Reset(QUIC_STREAM_CANCELLED);
       return;
     }
   }
   DVLOG(1) << "Sending response for stream " << id();
   SendHeadersAndBodyAndTrailers(response->headers(), response->body(),
                                 response->trailers());
 }
 
-void QuicSpdyServerStream::SendErrorResponse() {
+void QuicSimpleServerStream::SendErrorResponse() {
   DVLOG(1) << "Sending error response for stream " << id();
   SpdyHeaderBlock headers;
   headers[":status"] = "500";
   headers["content-length"] = base::UintToString(strlen(kErrorResponseBody));
   SendHeadersAndBody(headers, kErrorResponseBody);
 }
 
-void QuicSpdyServerStream::SendHeadersAndBody(
+void QuicSimpleServerStream::SendHeadersAndBody(
     const SpdyHeaderBlock& response_headers,
     StringPiece body) {
   SendHeadersAndBodyAndTrailers(response_headers, body, SpdyHeaderBlock());
 }
 
-void QuicSpdyServerStream::SendHeadersAndBodyAndTrailers(
+void QuicSimpleServerStream::SendHeadersAndBodyAndTrailers(
     const SpdyHeaderBlock& response_headers,
     StringPiece body,
     const SpdyHeaderBlock& response_trailers) {
   // This server only supports SPDY and HTTP, and neither handles bidirectional
   // streaming.
   if (!reading_stopped()) {
     StopReading();
   }
 
   // Send the headers, with a FIN if there's nothing else to send.
@@ skipping 15 matching lines @@
     // Nothing else to send.
     return;
   }
 
   // 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 QuicSpdyServerStream::kErrorResponseBody = "bad";
+const char* const QuicSimpleServerStream::kErrorResponseBody = "bad";
 
 }  // namespace tools
 }  // namespace net