Rename chromium-specific QUIC classes.

net/quic/quic_http_stream_test.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/quic/quic_http_stream.h"
 
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/net_errors.h"
 #include "net/base/socket_performance_watcher.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/transport_security_state.h"
 #include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_server_info.h"
 #include "net/quic/quic_chromium_client_session.h"
+#include "net/quic/quic_chromium_client_stream.h"
+#include "net/quic/quic_chromium_connection_helper.h"
 #include "net/quic/quic_connection.h"
-#include "net/quic/quic_connection_helper.h"
 #include "net/quic/quic_default_packet_writer.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_packet_reader.h"
-#include "net/quic/quic_reliable_client_stream.h"
 #include "net/quic/quic_write_blocked_list.h"
 #include "net/quic/spdy_utils.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_packet_maker.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/test_task_runner.h"
@@ skipping 15 matching lines @@
 
 const char kUploadData[] = "Really nifty data!";
 const char kDefaultServerHostName[] = "www.google.com";
 const uint16_t kDefaultServerPort = 80;
 
 class TestQuicConnection : public QuicConnection {
  public:
   TestQuicConnection(const QuicVersionVector& versions,
                      QuicConnectionId connection_id,
                      IPEndPoint address,
-                     QuicConnectionHelper* helper,
+                     QuicChromiumConnectionHelper* helper,
                      QuicPacketWriter* writer)
       : QuicConnection(connection_id,
                        address,
                        helper,
                        writer,
                        true /* owns_writer */,
                        Perspective::IS_CLIENT,
                        versions) {}
 
   void SetSendAlgorithm(SendAlgorithmInterface* send_algorithm) {
@@ skipping 14 matching lines @@
     Close(false);
   }
 
   void OnDataAvailable() override { Close(false); }
 };
 
 }  // namespace
 
 class QuicHttpStreamPeer {
  public:
-  static QuicReliableClientStream* GetQuicReliableClientStream(
+  static QuicChromiumClientStream* GetQuicChromiumClientStream(
       QuicHttpStream* stream) {
     return stream->stream_;
   }
 
   static bool WasHandshakeConfirmed(QuicHttpStream* stream) {
     return stream->was_handshake_confirmed_;
   }
 
   static void SetHandshakeConfirmed(QuicHttpStream* stream, bool confirmed) {
     stream->was_handshake_confirmed_ = confirmed;
@@ skipping 79 matching lines @@
         .WillRepeatedly(Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
         .WillRepeatedly(Return(kMaxPacketSize));
     EXPECT_CALL(*send_algorithm_, PacingRate())
         .WillRepeatedly(Return(QuicBandwidth::Zero()));
     EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _))
         .WillRepeatedly(Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
         .WillRepeatedly(Return(QuicBandwidth::Zero()));
     EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
-    helper_.reset(
-        new QuicConnectionHelper(runner_.get(), &clock_, &random_generator_));
+    helper_.reset(new QuicChromiumConnectionHelper(runner_.get(), &clock_,
+                                                   &random_generator_));
     connection_ = new TestQuicConnection(
         SupportedVersions(GetParam()), connection_id_, peer_addr_,
         helper_.get(), new QuicDefaultPacketWriter(socket));
     connection_->set_visitor(&visitor_);
     connection_->SetSendAlgorithm(send_algorithm_);
     session_.reset(new QuicChromiumClientSession(
         connection_, scoped_ptr<DatagramClientSocket>(socket),
         /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
         &transport_security_state_, make_scoped_ptr((QuicServerInfo*)nullptr),
         QuicServerId(kDefaultServerHostName, kDefaultServerPort,
@@ skipping 82 matching lines @@
                                 !kIncludeCongestionFeedback);
   }
 
   BoundNetLog net_log_;
   bool use_closing_stream_;
   MockSendAlgorithm* send_algorithm_;
   scoped_refptr<TestTaskRunner> runner_;
   scoped_ptr<MockWrite[]> mock_writes_;
   MockClock clock_;
   TestQuicConnection* connection_;
-  scoped_ptr<QuicConnectionHelper> helper_;
+  scoped_ptr<QuicChromiumConnectionHelper> helper_;
   testing::StrictMock<MockConnectionVisitor> visitor_;
   scoped_ptr<QuicHttpStream> stream_;
   TransportSecurityState transport_security_state_;
   scoped_ptr<QuicChromiumClientSession> session_;
   QuicCryptoClientConfig crypto_config_;
   TestCompletionCallback callback_;
   HttpRequestInfo request_;
   HttpRequestHeaders headers_;
   HttpResponseInfo response_;
   scoped_refptr<IOBufferWithSize> read_buffer_;
@@ skipping 545 matching lines @@
   use_closing_stream_ = true;
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM, net_log_,
                                           callback_.callback()));
 
   // Check that priority is highest.
-  QuicReliableClientStream* reliable_stream =
-      QuicHttpStreamPeer::GetQuicReliableClientStream(stream_.get());
+  QuicChromiumClientStream* reliable_stream =
+      QuicHttpStreamPeer::GetQuicChromiumClientStream(stream_.get());
   DCHECK(reliable_stream);
   DCHECK_EQ(kV3HighestPriority, reliable_stream->Priority());
 
   EXPECT_EQ(OK,
             stream_->SendRequest(headers_, &response_, callback_.callback()));
 
   // Check that priority has now dropped back to MEDIUM.
   DCHECK_EQ(MEDIUM,
             ConvertQuicPriorityToRequestPriority(reliable_stream->Priority()));
 
@@ skipping 27 matching lines @@
 
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM, net_log_,
                                           callback_.callback()));
 
   // Check that priority is highest.
-  QuicReliableClientStream* reliable_stream =
-      QuicHttpStreamPeer::GetQuicReliableClientStream(stream_.get());
+  QuicChromiumClientStream* reliable_stream =
+      QuicHttpStreamPeer::GetQuicChromiumClientStream(stream_.get());
   DCHECK(reliable_stream);
-  QuicReliableClientStream::Delegate* delegate = reliable_stream->GetDelegate();
+  QuicChromiumClientStream::Delegate* delegate = reliable_stream->GetDelegate();
   DCHECK(delegate);
   DCHECK_EQ(kV3HighestPriority, reliable_stream->Priority());
 
   // Set Delegate to nullptr and make sure Priority returns highest
   // priority.
   reliable_stream->SetDelegate(nullptr);
   DCHECK_EQ(kV3HighestPriority, reliable_stream->Priority());
   reliable_stream->SetDelegate(delegate);
 
   EXPECT_EQ(0, stream_->GetTotalSentBytes());
   EXPECT_EQ(0, stream_->GetTotalReceivedBytes());
 }
 
 }  // namespace test
 }  // namespace net