Fix HttpNetworkTransactionTest.UseIPConnectionPoolingWithHostCacheExpiration.

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 13823 matching lines @@
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 421", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_alpn_negotiated);
   EXPECT_TRUE(response->ssl_info.cert);
   ASSERT_THAT(ReadTransaction(&trans2, &response_data), IsOk());
   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();
 
   SpdySerializedFrame host1_req(
       spdy_util_.ConstructSpdyGet("https://www.example.org", 1, LOWEST));
   spdy_util_.UpdateWithStreamDestruction(1);
   SpdySerializedFrame host2_req(
       spdy_util_.ConstructSpdyGet("https://mail.example.com", 3, LOWEST));
   MockWrite spdy_writes[] = {
@@ skipping 34 matching lines @@
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_THAT(ReadTransaction(&trans1, &response_data), IsOk());
   EXPECT_EQ("hello!", response_data);
 
   // Preload cache entries into HostCache.
   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());
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("https://mail.example.com/");
   request2.load_flags = 0;
   HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
 
@@ skipping 2892 matching lines @@
   CheckContentEncodingMatching(&session_deps_, "identity;q=1, *;q=0", "gzip",
                                "", false);
 }
 
 TEST_F(HttpNetworkTransactionTest, MatchContentEncoding4) {
   CheckContentEncodingMatching(&session_deps_, "identity;q=1, *;q=0", "gzip",
                                "www.foo.com/other", true);
 }
 
 }  // namespace net