QUIC - delete #ifdef USE_OPENSSL in unittests

net/quic/quic_chromium_client_session_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_chromium_client_session.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/rand_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/socket_performance_watcher.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/http/transport_security_state.h"
 #include "net/log/test_net_log.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/proof_verifier_chromium.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_flags.h"
 #include "net/quic/quic_packet_reader.h"
+#include "net/quic/quic_protocol.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_chromium_client_session_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simple_quic_framer.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/test/cert_test_util.h"
 #include "net/udp/datagram_client_socket.h"
 
@@ skipping 69 matching lines @@
   MockClock clock_;
   MockRandom random_;
   QuicConnectionVisitorInterface* visitor_;
   TestCompletionCallback callback_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicChromiumClientSessionTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
-#if defined(OPENSSL)
-
 TEST_P(QuicChromiumClientSessionTest, CryptoConnect) {
   CompleteCryptoHandshake();
 }
 
 TEST_P(QuicChromiumClientSessionTest, MaxNumStreams) {
   CompleteCryptoHandshake();
 
   std::vector<QuicReliableClientStream*> streams;
   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection; i++) {
     QuicReliableClientStream* stream = session_.CreateOutgoingDynamicStream();
     EXPECT_TRUE(stream);
     streams.push_back(stream);
   }
   EXPECT_FALSE(session_.CreateOutgoingDynamicStream());
 
+  EXPECT_EQ(kDefaultMaxStreamsPerConnection, session_.GetNumOpenStreams());
+
   // Close a stream and ensure I can now open a new one.
-  session_.CloseStream(streams[0]->id());
+  QuicStreamId stream_id = streams[0]->id();
+  session_.CloseStream(stream_id);
+
+  if (FLAGS_quic_count_unfinished_as_open_streams) {

[Ryan Hamilton, 2015/11/05 05:26:46]

Since this flag is true and we have no plans to make it false, I'd just make
this unconditional. (and below)

[ramant (doing other things), 2015/11/05 17:36:43]

Done.

+    EXPECT_FALSE(session_.CreateOutgoingDynamicStream());
+    QuicRstStreamFrame rst1(stream_id, QUIC_STREAM_NO_ERROR, 0);
+    session_.OnRstStream(rst1);
+  }
+  EXPECT_EQ(kDefaultMaxStreamsPerConnection - 1, session_.GetNumOpenStreams());
   EXPECT_TRUE(session_.CreateOutgoingDynamicStream());
 }
 
 TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) {
   CompleteCryptoHandshake();
 
   std::vector<QuicReliableClientStream*> streams;
   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection; i++) {
     QuicReliableClientStream* stream = session_.CreateOutgoingDynamicStream();
     EXPECT_TRUE(stream);
     streams.push_back(stream);
   }
 
   QuicReliableClientStream* stream;
   QuicChromiumClientSession::StreamRequest stream_request;
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING,
             stream_request.StartRequest(session_.GetWeakPtr(), &stream,
                                         callback.callback()));
 
   // Close a stream and ensure I can now open a new one.
-  session_.CloseStream(streams[0]->id());
+  QuicStreamId stream_id = streams[0]->id();
+  session_.CloseStream(stream_id);
+  if (FLAGS_quic_count_unfinished_as_open_streams) {
+    QuicRstStreamFrame rst1(stream_id, QUIC_STREAM_NO_ERROR, 0);
+    session_.OnRstStream(rst1);
+  }
   ASSERT_TRUE(callback.have_result());
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(stream != nullptr);
 }
 
 TEST_P(QuicChromiumClientSessionTest, GoAwayReceived) {
   CompleteCryptoHandshake();
 
   // After receiving a GoAway, I should no longer be able to create outgoing
   // streams.
@@ skipping 85 matching lines @@
   ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
 
   CompleteCryptoHandshake();
   session_.OnProofVerifyDetailsAvailable(details);
   QuicChromiumClientSessionPeer::SetHostname(&session_, "www.example.org");
   QuicChromiumClientSessionPeer::SetChannelIDSent(&session_, true);
 
   EXPECT_TRUE(session_.CanPool("mail.example.org", PRIVACY_MODE_DISABLED));
 }
 
-#endif
-
 }  // namespace
 }  // namespace test
 }  // namespace net