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

net/quic/quic_network_transaction_unittest.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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "net/base/capturing_net_log.h"
 #include "net/base/net_log_unittest.h"
@@ skipping 46 matching lines @@
 
 class QuicNetworkTransactionTest : public PlatformTest {
  protected:
   QuicNetworkTransactionTest()
       : clock_(new MockClock),
         ssl_config_service_(new SSLConfigServiceDefaults),
         proxy_service_(ProxyService::CreateDirect()),
         compressor_(new QuicSpdyCompressor()),
         auth_handler_factory_(
             HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
+        random_generator_(0),
         hanging_data_(NULL, 0, NULL, 0) {
     request_.method = "GET";
     request_.url = GURL("http://www.google.com/");
     request_.load_flags = 0;
   }
 
   virtual void SetUp() {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   virtual void TearDown() {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     // Empty the current queue.
     base::MessageLoop::current()->RunUntilIdle();
     PlatformTest::TearDown();
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::MessageLoop::current()->RunUntilIdle();
     HttpStreamFactory::set_use_alternate_protocols(false);
     HttpStreamFactory::SetNextProtos(std::vector<NextProto>());
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket(
       QuicPacketSequenceNumber num,
       QuicStreamId stream_id) {
     QuicPacketHeader header;
-    header.public_header.guid = 0xDEADBEEF;
+    header.public_header.guid = random_generator_.RandUint64();
     header.public_header.reset_flag = false;
     header.public_header.version_flag = false;
     header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
     header.packet_sequence_number = num;
     header.entropy_flag = false;
     header.fec_flag = false;
     header.fec_group = 0;
 
     QuicRstStreamFrame rst(stream_id, QUIC_STREAM_NO_ERROR);
     return scoped_ptr<QuicEncryptedPacket>(
         ConstructPacket(header, QuicFrame(&rst)));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructConnectionClosePacket(
       QuicPacketSequenceNumber num) {
     QuicPacketHeader header;
-    header.public_header.guid = 0xDEADBEEF;
+    header.public_header.guid = random_generator_.RandUint64();
     header.public_header.reset_flag = false;
     header.public_header.version_flag = false;
     header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
     header.packet_sequence_number = num;
     header.entropy_flag = false;
     header.fec_flag = false;
     header.fec_group = 0;
 
     QuicConnectionCloseFrame close;
     close.error_code = QUIC_CRYPTO_VERSION_NOT_SUPPORTED;
     close.error_details = "Time to panic!";
     return scoped_ptr<QuicEncryptedPacket>(
         ConstructPacket(header, QuicFrame(&close)));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
       QuicPacketSequenceNumber largest_received,
       QuicPacketSequenceNumber least_unacked) {
     QuicPacketHeader header;
-    header.public_header.guid = 0xDEADBEEF;
+    header.public_header.guid = random_generator_.RandUint64();
     header.public_header.reset_flag = false;
     header.public_header.version_flag = false;
     header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
     header.packet_sequence_number = 2;
     header.entropy_flag = false;
     header.fec_flag = false;
     header.fec_group = 0;
 
     QuicAckFrame ack(largest_received, QuicTime::Zero(), least_unacked);
 
@@ skipping 707 matching lines @@
   SendRequestAndExpectHttpResponse("hello from http");
 
   ExpectBrokenAlternateProtocolMapping();
 
   EXPECT_TRUE(quic_data.at_read_eof());
   EXPECT_TRUE(quic_data.at_write_eof());
 }
 
 }  // namespace test
 }  // namespace net