Pool 64 bits of entropy instead of calling OpenSSL's RNG for one bit

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 <vector>
 
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 118 matching lines @@
     IoMode mode;
     QuicEncryptedPacket* packet;
   };
 
   QuicHttpStreamTest()
       : net_log_(BoundNetLog()),
         use_closing_stream_(false),
         read_buffer_(new IOBufferWithSize(4096)),
         guid_(2),
         framer_(QuicSupportedVersions(), QuicTime::Zero(), false),
-        creator_(guid_, &framer_, &random_, false) {
+        random_generator_(0),
+        creator_(guid_, &framer_, &random_generator_, false) {
     IPAddressNumber ip;
     CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
     peer_addr_ = IPEndPoint(ip, 443);
     self_addr_ = IPEndPoint(ip, 8435);
   }
 
   ~QuicHttpStreamTest() {
     session_->CloseSessionOnError(ERR_ABORTED);
     for (size_t i = 0; i < writes_.size(); i++) {
       delete writes_[i].packet;
@@ skipping 148 matching lines @@
     return ConstructPacket(header_, QuicFrame(&rst));
   }
 
   BoundNetLog net_log_;
   bool use_closing_stream_;
   MockSendAlgorithm* send_algorithm_;
   TestReceiveAlgorithm* receive_algorithm_;
   scoped_refptr<TestTaskRunner> runner_;
   scoped_ptr<MockWrite[]> mock_writes_;
   MockClock clock_;
-  MockRandom random_generator_;
   TestQuicConnection* connection_;
   scoped_ptr<QuicConnectionHelper> helper_;
   testing::StrictMock<MockConnectionVisitor> visitor_;
   scoped_ptr<QuicHttpStream> stream_;
   scoped_ptr<QuicDefaultPacketWriter> writer_;
   scoped_ptr<QuicClientSession> session_;
   QuicCryptoClientConfig crypto_config_;
   TestCompletionCallback callback_;
   HttpRequestInfo request_;
   HttpRequestHeaders headers_;
@@ skipping 22 matching lines @@
     scoped_ptr<QuicPacket> packet(
         framer_.BuildUnsizedDataPacket(header_, frames).packet);
     return framer_.EncryptPacket(
         ENCRYPTION_NONE, header.packet_sequence_number, *packet);
   }
 
   const QuicGuid guid_;
   QuicFramer framer_;
   IPEndPoint self_addr_;
   IPEndPoint peer_addr_;
-  MockRandom random_;
+  MockRandom random_generator_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   QuicPacketCreator creator_;
   QuicPacketHeader header_;
   scoped_ptr<StaticSocketDataProvider> socket_data_;
   std::vector<PacketToWrite> writes_;
 };
 
 TEST_F(QuicHttpStreamTest, RenewStreamForAuth) {
   Initialize();
   EXPECT_EQ(NULL, stream_->RenewStreamForAuth());
@@ skipping 394 matching lines @@
 
   // Data should flush out now.
   connection_->OnCanWrite();
   EXPECT_FALSE(reliable_stream->HasBufferedData());
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 
 }  // namespace net