Fix HttpNetworkTransactionTest.UseIPConnectionPoolingWithHostCacheExpiration.

net/http/http_network_transaction_unittest.cc

Index: net/http/http_network_transaction_unittest.cc
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index 1e5f418e0b21ee0a665b63c28f9fd47f8fd7a413..24fafb279b244777d8149f5411b765db7170f757 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -13841,51 +13841,30 @@ TEST_F(HttpNetworkTransactionTest, ReturnHTTP421OnRetry) {
   EXPECT_EQ("hello!", response_data);
 }
 
-class OneTimeCachingHostResolver : public HostResolver {
+class OneTimeCachingHostResolver : public MockHostResolverBase {

[Bence, 2017/05/25 15:46:02]

Make this class inherit from MockHostResolverBase so that it can be shoved into
session_deps_.host_resolver.  The other option would be, as originally done, to
put it into params.host_resolver, for which a HostResolver suffices, however, in
that case, everything would need to be copied over from
SpdySessionDependencies::SpdyCreateSessionWithSocketFactory(), which would be
fragile due to code duplication.

  public:
   explicit OneTimeCachingHostResolver(const HostPortPair& host_port)
-      : host_port_(host_port) {}
+      : MockHostResolverBase(/* use_caching = */ true), host_port_(host_port) {}
   ~OneTimeCachingHostResolver() override {}
 
-  RuleBasedHostResolverProc* rules() { return host_resolver_.rules(); }

[Bence, 2017/05/25 15:46:02]

Remove unused method.

-
-  // HostResolver methods:
-  int Resolve(const RequestInfo& info,

[Bence, 2017/05/25 15:46:02]

Remove method that would trivially call into base class's method.

-              RequestPriority priority,
-              AddressList* addresses,
-              const CompletionCallback& callback,
-              std::unique_ptr<Request>* out_req,
-              const NetLogWithSource& net_log) override {
-    return host_resolver_.Resolve(
-        info, priority, addresses, callback, out_req, net_log);
-  }
-
   int ResolveFromCache(const RequestInfo& info,
                        AddressList* addresses,
                        const NetLogWithSource& net_log) override {
-    int rv = host_resolver_.ResolveFromCache(info, addresses, net_log);
+    int rv = MockHostResolverBase::ResolveFromCache(info, addresses, net_log);
     if (rv == OK && info.host_port_pair().Equals(host_port_))
-      host_resolver_.GetHostCache()->clear();
+      GetHostCache()->clear();
     return rv;
   }
 
-  MockCachingHostResolver* GetMockHostResolver() {

[Bence, 2017/05/25 15:46:02]

Remove unused method.  This is my favorite part!

-    return &host_resolver_;
-  }
-
  private:
-  MockCachingHostResolver host_resolver_;
   const HostPortPair host_port_;
 };
 
 TEST_F(HttpNetworkTransactionTest,
        UseIPConnectionPoolingWithHostCacheExpiration) {
   // Set up a special HttpNetworkSession with a OneTimeCachingHostResolver.
-  OneTimeCachingHostResolver host_resolver(
+  session_deps_.host_resolver = base::MakeUnique<OneTimeCachingHostResolver>(
       HostPortPair("mail.example.com", 443));
-  HttpNetworkSession::Params params =
-      SpdySessionDependencies::CreateSessionParams(&session_deps_);
-  params.host_resolver = &host_resolver;
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   AddSSLSocketData();
@@ -13940,8 +13919,9 @@ TEST_F(HttpNetworkTransactionTest,
   HostResolver::RequestInfo resolve_info(HostPortPair("mail.example.com", 443));
   AddressList ignored;
   std::unique_ptr<HostResolver::Request> request;
-  rv = host_resolver.Resolve(resolve_info, DEFAULT_PRIORITY, &ignored,
-                             callback.callback(), &request, NetLogWithSource());
+  rv = session_deps_.host_resolver->Resolve(resolve_info, DEFAULT_PRIORITY,
+                                            &ignored, callback.callback(),
+                                            &request, NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = callback.WaitForResult();
   EXPECT_THAT(rv, IsOk());