Land Recent QUIC Changes.

net/tools/quic/test_tools/quic_test_client.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/test_tools/quic_test_client.h"
 
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_result.h"
@@ skipping 197 matching lines @@
   stream_ = NULL;  // Always force creation of a stream for SendMessage.
 
   // If we're not connected, try to find an sni hostname.
   if (!connected()) {
     GURL url(message.headers()->request_uri().as_string());
     if (!url.host().empty()) {
       client_->set_server_hostname(url.host());
     }
   }
 
-  QuicReliableClientStream* stream = GetOrCreateStream();
+  QuicSpdyClientStream* stream = GetOrCreateStream();
   if (!stream) { return 0; }
 
   scoped_ptr<BalsaHeaders> munged_headers(MungeHeaders(message.headers(),
                                           secure_));
   ssize_t ret = GetOrCreateStream()->SendRequest(
       munged_headers.get() ? *munged_headers.get() : *message.headers(),
       message.body(),
       message.has_complete_message());
   WaitForWriteToFlush();
   return ret;
 }
 
 ssize_t QuicTestClient::SendData(string data, bool last_data) {
-  QuicReliableClientStream* stream = GetOrCreateStream();
+  QuicSpdyClientStream* stream = GetOrCreateStream();
   if (!stream) { return 0; }
   GetOrCreateStream()->SendBody(data, last_data);
   WaitForWriteToFlush();
   return data.length();
 }
 
 string QuicTestClient::SendCustomSynchronousRequest(
     const HTTPMessage& message) {
   SendMessage(message);
   WaitForResponse();
   return response_;
 }
 
 string QuicTestClient::SendSynchronousRequest(const string& uri) {
   if (SendRequest(uri) == 0) {
     DLOG(ERROR) << "Failed the request for uri:" << uri;
     return "";
   }
   WaitForResponse();
   return response_;
 }
 
-QuicReliableClientStream* QuicTestClient::GetOrCreateStream() {
+QuicSpdyClientStream* QuicTestClient::GetOrCreateStream() {
   if (!connect_attempted_ || auto_reconnect_) {
     if (!connected()) {
       Connect();
     }
     if (!connected()) {
       return NULL;
     }
   }
   if (!stream_) {
     stream_ = client_->CreateReliableClientStream();
@@ skipping 128 matching lines @@
 }
 
 size_t QuicTestClient::bytes_read() const {
   return bytes_read_;
 }
 
 size_t QuicTestClient::bytes_written() const {
   return bytes_written_;
 }
 
-void QuicTestClient::OnClose(ReliableQuicStream* stream) {
+void QuicTestClient::OnClose(QuicDataStream* stream) {
   if (stream_ != stream) {
     return;
   }
   if (buffer_body()) {
     // TODO(fnk): The stream still buffers the whole thing. Fix that.
     response_ = stream_->data();
   }
   response_complete_ = true;
   response_headers_complete_ = stream_->headers_decompressed();
   headers_.CopyFrom(stream_->headers());
@@ skipping 16 matching lines @@
 
 void QuicTestClient::WaitForWriteToFlush() {
   while (connected() && client()->session()->HasQueuedData()) {
     client_->WaitForEvents();
   }
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net