net: Implement ChannelIDSourceChromium, which is based on Chromium's

net/quic/quic_stream_factory_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_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/quic/crypto/crypto_handshake.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/quic_http_stream.h"
 #include "net/quic/quic_server_id.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_test_packet_maker.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/socket/socket_test_util.h"
+#include "net/ssl/default_server_bound_cert_store.h"
 #include "net/test/cert_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::string;
 using std::vector;
 
 namespace net {
 namespace test {
 
@@ skipping 45 matching lines @@
   }
 };
 
 class QuicStreamFactoryTest : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicStreamFactoryTest()
       : random_generator_(0),
         maker_(GetParam(), 0),
         clock_(new MockClock()),
         cert_verifier_(CertVerifier::CreateDefault()),
+        server_bound_cert_service_(new ServerBoundCertService(
+            new DefaultServerBoundCertStore(NULL),
+            base::MessageLoopProxy::current())),
         factory_(&host_resolver_, &socket_factory_,
                  base::WeakPtr<HttpServerProperties>(), cert_verifier_.get(),
+                 server_bound_cert_service_.get(),
                  &crypto_client_stream_factory_, &random_generator_, clock_,
                  kDefaultMaxPacketSize, std::string(),
                  SupportedVersions(GetParam()), true, true, true,
                  QuicTagVector()),
         host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
         is_https_(false),
         privacy_mode_(PRIVACY_MODE_DISABLED) {
     factory_.set_require_confirmation(false);
   }
 
@@ skipping 71 matching lines @@
         AdjustErrorForVersion(QUIC_RST_FLOW_CONTROL_ACCOUNTING, GetParam()));
   }
 
   MockHostResolver host_resolver_;
   DeterministicMockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockRandom random_generator_;
   QuicTestPacketMaker maker_;
   MockClock* clock_;  // Owned by factory_.
   scoped_ptr<CertVerifier> cert_verifier_;
+  scoped_ptr<ServerBoundCertService> server_bound_cert_service_;
   QuicStreamFactory factory_;
   HostPortPair host_port_pair_;
   bool is_https_;
   PrivacyMode privacy_mode_;
   BoundNetLog net_log_;
   TestCompletionCallback callback_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version, QuicStreamFactoryTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
@@ skipping 945 matching lines @@
     QuicCryptoClientConfig::CachedState* cached2 =
         crypto_config->LookupOrCreate(server_id2);
     EXPECT_NE(cached1->source_address_token(), cached2->source_address_token());
     EXPECT_TRUE(cached2->source_address_token().empty());
     EXPECT_FALSE(cached2->proof_valid());
   }
 }
 
 }  // namespace test
 }  // namespace net