diff --git a/resolv/resolver_test.cpp b/resolv/resolver_test.cpp
index 0f32fb9..89da17d 100644
--- a/resolv/resolver_test.cpp
+++ b/resolv/resolver_test.cpp
@@ -109,10 +109,10 @@
     return true;
 }
 
-class ResolverTest : public ::testing::Test, public DnsResponderClient {
+class ResolverTest : public ::testing::Test {
   protected:
-    void SetUp() { DnsResponderClient::SetUp(); }
-    void TearDown() { DnsResponderClient::TearDown(); }
+    void SetUp() { mDnsClient.SetUp(); }
+    void TearDown() { mDnsClient.TearDown(); }
 
     bool GetResolverInfo(std::vector<std::string>* servers, std::vector<std::string>* domains,
                          std::vector<std::string>* tlsServers, __res_params* params,
@@ -120,8 +120,8 @@
         using android::net::INetd;
         std::vector<int32_t> params32;
         std::vector<int32_t> stats32;
-        auto rv = mNetdSrv->getResolverInfo(TEST_NETID, servers, domains, tlsServers, &params32,
-                                            &stats32);
+        auto rv = mDnsClient.netdService()->getResolverInfo(TEST_NETID, servers, domains,
+                                                            tlsServers, &params32, &stats32);
         if (!rv.isOk() || params32.size() != static_cast<size_t>(INetd::RESOLVER_PARAMS_COUNT)) {
             return false;
         }
@@ -218,7 +218,7 @@
         const int limit = timeoutMs / intervalMs;
         for (int count = 0; count <= limit; ++count) {
             std::string prefix;
-            auto rv = mNetdSrv->getPrefix64(netId, &prefix);
+            auto rv = mDnsClient.netdService()->getPrefix64(netId, &prefix);
             if (rv.isOk()) {
                 return true;
             }
@@ -232,11 +232,11 @@
         std::vector<std::string> domains = { "example.com" };
         std::vector<std::unique_ptr<test::DNSResponder>> dns;
         std::vector<std::string> servers;
-        std::vector<DnsResponderClient::Mapping> mappings;
-        ASSERT_NO_FATAL_FAILURE(SetupMappings(num_hosts, domains, &mappings));
-        ASSERT_NO_FATAL_FAILURE(SetupDNSServers(MAXNS, mappings, &dns, &servers));
+        std::vector<DnsResponderClient::DnsResponderClient::Mapping> mappings;
+        ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupMappings(num_hosts, domains, &mappings));
+        ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupDNSServers(MAXNS, mappings, &dns, &servers));
 
-        ASSERT_TRUE(SetResolversForNetwork(servers, domains, mDefaultParams_Binder));
+        ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains, mDefaultParams));
 
         auto t0 = std::chrono::steady_clock::now();
         std::vector<std::thread> threads(num_threads);
@@ -268,17 +268,19 @@
         auto t1 = std::chrono::steady_clock::now();
         ALOGI("%u hosts, %u threads, %u queries, %Es", num_hosts, num_threads, num_queries,
                 std::chrono::duration<double>(t1 - t0).count());
-        ASSERT_NO_FATAL_FAILURE(ShutdownDNSServers(&dns));
+        ASSERT_NO_FATAL_FAILURE(mDnsClient.ShutdownDNSServers(&dns));
     }
 
     const std::vector<std::string> mDefaultSearchDomains = { "example.com" };
     // <sample validity in s> <success threshold in percent> <min samples> <max samples>
-    const std::vector<int> mDefaultParams_Binder = {
+    const std::vector<int> mDefaultParams = {
             300,     // SAMPLE_VALIDITY
             25,      // SUCCESS_THRESHOLD
             8,   8,  // {MIN,MAX}_SAMPLES
             100,     // BASE_TIMEOUT_MSEC
     };
+
+    DnsResponderClient mDnsClient;
 };
 
 TEST_F(ResolverTest, GetHostByName) {
@@ -290,7 +292,7 @@
     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.3");
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = { listen_addr };
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
 
     const hostent* result;
 
@@ -327,7 +329,7 @@
     test::DNSResponder dns(listen_addr, listen_srv, 250, ns_rcode::ns_r_servfail);
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Expect no DNS queries; localhost is resolved via /etc/hosts
@@ -381,8 +383,8 @@
     constexpr char listen_srv[] = "53";
     test::DNSResponder dns(listen_addr, listen_srv, 250, ns_rcode::ns_r_servfail);
     ASSERT_TRUE(dns.startServer());
-    ASSERT_TRUE(
-            SetResolversForNetwork({listen_addr}, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr}, mDefaultSearchDomains,
+                                                  mDefaultParams));
 
     // Numeric v4 address: expect no DNS queries
     constexpr char numeric_v4[] = "192.168.0.1";
@@ -449,13 +451,13 @@
     std::vector<std::string> domains = { "example.com" };
     std::vector<std::unique_ptr<test::DNSResponder>> dns;
     std::vector<std::string> servers;
-    std::vector<Mapping> mappings;
-    ASSERT_NO_FATAL_FAILURE(SetupMappings(1, domains, &mappings));
-    ASSERT_NO_FATAL_FAILURE(SetupDNSServers(4, mappings, &dns, &servers));
+    std::vector<DnsResponderClient::Mapping> mappings;
+    ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupMappings(1, domains, &mappings));
+    ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupDNSServers(4, mappings, &dns, &servers));
     ASSERT_EQ(1U, mappings.size());
-    const Mapping& mapping = mappings[0];
+    const DnsResponderClient::Mapping& mapping = mappings[0];
 
-    ASSERT_TRUE(SetResolversForNetwork(servers, domains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains, mDefaultParams));
 
     const hostent* result = gethostbyname(mapping.host.c_str());
     const size_t total_queries =
@@ -480,21 +482,20 @@
     EXPECT_EQ(servers.size(), res_servers.size());
     EXPECT_EQ(domains.size(), res_domains.size());
     EXPECT_EQ(0U, res_tls_servers.size());
-    ASSERT_EQ(static_cast<size_t>(INetd::RESOLVER_PARAMS_COUNT), mDefaultParams_Binder.size());
-    EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY],
-            res_params.sample_validity);
-    EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD],
-            res_params.success_threshold);
-    EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
-    EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
-    EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],
+    ASSERT_EQ(static_cast<size_t>(INetd::RESOLVER_PARAMS_COUNT), mDefaultParams.size());
+    EXPECT_EQ(mDefaultParams[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY], res_params.sample_validity);
+    EXPECT_EQ(mDefaultParams[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD],
+              res_params.success_threshold);
+    EXPECT_EQ(mDefaultParams[INetd::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
+    EXPECT_EQ(mDefaultParams[INetd::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
+    EXPECT_EQ(mDefaultParams[INetd::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],
               res_params.base_timeout_msec);
     EXPECT_EQ(servers.size(), res_stats.size());
 
     EXPECT_TRUE(UnorderedCompareArray(res_servers, servers));
     EXPECT_TRUE(UnorderedCompareArray(res_domains, domains));
 
-    ASSERT_NO_FATAL_FAILURE(ShutdownDNSServers(&dns));
+    ASSERT_NO_FATAL_FAILURE(mDnsClient.ShutdownDNSServers(&dns));
 }
 
 TEST_F(ResolverTest, GetAddrInfo) {
@@ -513,7 +514,7 @@
     ASSERT_TRUE(dns2.startServer());
 
     std::vector<std::string> servers = { listen_addr };
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
     dns2.clearQueries();
 
@@ -539,7 +540,7 @@
 
     // Change the DNS resolver, ensure that queries are still cached.
     servers = { listen_addr2 };
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
     dns2.clearQueries();
 
@@ -567,7 +568,7 @@
     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.5");
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = { listen_addr };
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
 
     addrinfo hints = {.ai_family = AF_INET};
     ScopedAddrinfo result = safe_getaddrinfo("hola", nullptr, &hints);
@@ -588,7 +589,7 @@
     test::DNSResponder dns(listen_addr, listen_srv, 250, ns_rcode::ns_r_servfail);
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
 
     ScopedAddrinfo result = safe_getaddrinfo(name, nullptr, nullptr);
     EXPECT_TRUE(result != nullptr);
@@ -612,7 +613,7 @@
     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.3");
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = { listen_addr };
-    ASSERT_TRUE(SetResolversForNetwork(servers, searchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, searchDomains, mDefaultParams));
 
     dns.clearQueries();
     const hostent* result = gethostbyname("nihao");
@@ -636,7 +637,7 @@
     dns.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::5");
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = {listen_addr0};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
 
     addrinfo hints = {.ai_family = AF_INET6};
     ScopedAddrinfo result = safe_getaddrinfo(numeric_addr, nullptr, &hints);
@@ -668,7 +669,7 @@
     // <sample validity in s> <success threshold in percent> <min samples> <max samples>
     int sample_count = 8;
     const std::vector<int> params = { 300, 25, sample_count, sample_count };
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, params));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, params));
 
     // Repeatedly perform resolutions for non-existing domains until MAXNSSAMPLES resolutions have
     // reached the dns0, which is set to fail. No more requests should then arrive at that server
@@ -708,7 +709,7 @@
     ASSERT_TRUE(dns0.startServer());
     ASSERT_TRUE(dns1.startServer());
     std::vector<std::string> servers = {listen_addr0, listen_addr1};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
 
     const addrinfo hints = {.ai_family = AF_INET6};
 
@@ -757,8 +758,8 @@
                 }
             }
             if (serverSubset.empty()) serverSubset = servers;
-            ASSERT_TRUE(SetResolversForNetwork(serverSubset, mDefaultSearchDomains,
-                    mDefaultParams_Binder));
+            ASSERT_TRUE(mDnsClient.SetResolversForNetwork(serverSubset, mDefaultSearchDomains,
+                                                          mDefaultParams));
             addrinfo hints = {.ai_family = AF_INET6};
             addrinfo* result = nullptr;
             int rv = getaddrinfo("konbanha", nullptr, &hints, &result);
@@ -792,7 +793,7 @@
     using android::net::INetd;
     std::vector<std::string> servers;
     std::vector<std::string> domains;
-    ASSERT_TRUE(SetResolversForNetwork(servers, domains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains, mDefaultParams));
     std::vector<std::string> res_servers;
     std::vector<std::string> res_domains;
     std::vector<std::string> res_tls_servers;
@@ -803,14 +804,13 @@
     EXPECT_EQ(0U, res_servers.size());
     EXPECT_EQ(0U, res_domains.size());
     EXPECT_EQ(0U, res_tls_servers.size());
-    ASSERT_EQ(static_cast<size_t>(INetd::RESOLVER_PARAMS_COUNT), mDefaultParams_Binder.size());
-    EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY],
-            res_params.sample_validity);
-    EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD],
-            res_params.success_threshold);
-    EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
-    EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
-    EXPECT_EQ(mDefaultParams_Binder[INetd::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],
+    ASSERT_EQ(static_cast<size_t>(INetd::RESOLVER_PARAMS_COUNT), mDefaultParams.size());
+    EXPECT_EQ(mDefaultParams[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY], res_params.sample_validity);
+    EXPECT_EQ(mDefaultParams[INetd::RESOLVER_PARAMS_SUCCESS_THRESHOLD],
+              res_params.success_threshold);
+    EXPECT_EQ(mDefaultParams[INetd::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);
+    EXPECT_EQ(mDefaultParams[INetd::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);
+    EXPECT_EQ(mDefaultParams[INetd::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],
               res_params.base_timeout_msec);
 }
 
@@ -825,7 +825,7 @@
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = { listen_addr };
     std::vector<std::string> domains = { "domain1.org" };
-    ASSERT_TRUE(SetResolversForNetwork(servers, domains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains, mDefaultParams));
 
     const addrinfo hints = {.ai_family = AF_INET6};
     ScopedAddrinfo result = safe_getaddrinfo("test13", nullptr, &hints);
@@ -836,7 +836,7 @@
 
     // Test that changing the domain search path on its own works.
     domains = { "domain2.org" };
-    ASSERT_TRUE(SetResolversForNetwork(servers, domains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains, mDefaultParams));
     dns.clearQueries();
 
     result = safe_getaddrinfo("test13", nullptr, &hints);
@@ -887,16 +887,16 @@
     std::vector<std::unique_ptr<test::DnsTlsFrontend>> tls;
     std::vector<std::string> servers;
     std::vector<std::string> fingerprints;
-    std::vector<Mapping> mappings;
+    std::vector<DnsResponderClient::Mapping> mappings;
 
     for (unsigned i = 0; i < MAXDNSRCH + 1; i++) {
         domains.push_back(StringPrintf("example%u.com", i));
     }
-    ASSERT_NO_FATAL_FAILURE(SetupMappings(1, domains, &mappings));
-    ASSERT_NO_FATAL_FAILURE(SetupDNSServers(MAXNS + 1, mappings, &dns, &servers));
+    ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupMappings(1, domains, &mappings));
+    ASSERT_NO_FATAL_FAILURE(mDnsClient.SetupDNSServers(MAXNS + 1, mappings, &dns, &servers));
     ASSERT_NO_FATAL_FAILURE(setupTlsServers(servers, &tls, &fingerprints));
 
-    ASSERT_TRUE(SetResolversWithTls(servers, domains, mDefaultParams_Binder, "", fingerprints));
+    ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, domains, mDefaultParams, "", fingerprints));
 
     std::vector<std::string> res_servers;
     std::vector<std::string> res_domains;
@@ -914,7 +914,7 @@
     EXPECT_TRUE(std::equal(servers.begin(), servers.begin() + MAXNS, res_tls_servers.begin()));
     EXPECT_TRUE(std::equal(domains.begin(), domains.begin() + MAXDNSRCH, res_domains.begin()));
 
-    ASSERT_NO_FATAL_FAILURE(ShutdownDNSServers(&dns));
+    ASSERT_NO_FATAL_FAILURE(mDnsClient.ShutdownDNSServers(&dns));
     ASSERT_NO_FATAL_FAILURE(shutdownTlsServers(&tls));
 }
 
@@ -941,7 +941,7 @@
     ASSERT_TRUE(dns3.startServer());
 
     std::vector<std::string> servers = {listen_addr1, listen_addr2, listen_addr3};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
 
     dns3.clearQueries();
     addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_DGRAM};
@@ -980,7 +980,8 @@
 
     // There's nothing listening on this address, so validation will either fail or
     /// hang.  Either way, queries will continue to flow to the DNSResponder.
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "", {}));
+    ASSERT_TRUE(
+            mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams, "", {}));
 
     const hostent* result;
 
@@ -989,7 +990,7 @@
     EXPECT_EQ("1.2.3.3", ToString(result));
 
     // Clear TLS bit.
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains,  mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.stopServer();
 }
 
@@ -1019,7 +1020,8 @@
     ASSERT_FALSE(listen(s, 1));
 
     // Trigger TLS validation.
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "", {}));
+    ASSERT_TRUE(
+            mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams, "", {}));
 
     struct sockaddr_storage cliaddr;
     socklen_t sin_size = sizeof(cliaddr);
@@ -1046,7 +1048,7 @@
     EXPECT_EQ("1.2.3.2", ToString(result));
 
     // Clear TLS bit.
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains,  mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.stopServer();
     close(s);
 }
@@ -1067,7 +1069,8 @@
 
     test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
     ASSERT_TRUE(tls.startServer());
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "", {}));
+    ASSERT_TRUE(
+            mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams, "", {}));
 
     const hostent* result;
 
@@ -1096,7 +1099,7 @@
 
     // Reset the resolvers without enabling TLS.  Queries should still be routed
     // to the UDP endpoint.
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
 
     result = gethostbyname("tls3");
     ASSERT_FALSE(result == nullptr);
@@ -1119,8 +1122,8 @@
         test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
         tls.set_chain_length(chain_length);
         ASSERT_TRUE(tls.startServer());
-        ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "",
-                { base64Encode(tls.fingerprint()) }));
+        ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams,
+                                                   "", {base64Encode(tls.fingerprint())}));
 
         const hostent* result;
 
@@ -1137,7 +1140,8 @@
         }
 
         // Clear TLS bit to ensure revalidation.
-        ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains,  mDefaultParams_Binder));
+        ASSERT_TRUE(
+                mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
         tls.stopServer();
     }
     dns.stopServer();
@@ -1157,8 +1161,8 @@
     ASSERT_TRUE(tls.startServer());
     std::vector<uint8_t> bad_fingerprint = tls.fingerprint();
     bad_fingerprint[5] += 1;  // Corrupt the fingerprint.
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "",
-            { base64Encode(bad_fingerprint) }));
+    ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams, "",
+                                               {base64Encode(bad_fingerprint)}));
 
     // The initial validation should fail at the fingerprint check before
     // issuing a query.
@@ -1168,7 +1172,7 @@
     EXPECT_EQ(nullptr, gethostbyname("badtlsfingerprint"));
 
     // Clear TLS bit.
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains,  mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     tls.stopServer();
     dns.stopServer();
 }
@@ -1189,8 +1193,9 @@
     ASSERT_TRUE(tls.startServer());
     std::vector<uint8_t> bad_fingerprint = tls.fingerprint();
     bad_fingerprint[5] += 1;  // Corrupt the fingerprint.
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "",
-            { base64Encode(bad_fingerprint), base64Encode(tls.fingerprint()) }));
+    ASSERT_TRUE(mDnsClient.SetResolversWithTls(
+            servers, mDefaultSearchDomains, mDefaultParams, "",
+            {base64Encode(bad_fingerprint), base64Encode(tls.fingerprint())}));
 
     const hostent* result;
 
@@ -1205,7 +1210,7 @@
     EXPECT_TRUE(tls.waitForQueries(2, 5000));
 
     // Clear TLS bit.
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains,  mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     tls.stopServer();
     dns.stopServer();
 }
@@ -1224,8 +1229,8 @@
 
     test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
     ASSERT_TRUE(tls.startServer());
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "",
-            { base64Encode(tls.fingerprint()) }));
+    ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams, "",
+                                               {base64Encode(tls.fingerprint())}));
 
     const hostent* result;
 
@@ -1249,7 +1254,7 @@
     EXPECT_EQ(HOST_NOT_FOUND, h_errno);
 
     // Clear TLS bit.
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains,  mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     tls.stopServer();
     dns.stopServer();
 }
@@ -1275,8 +1280,9 @@
     test::DnsTlsFrontend tls2(listen_addr2, listen_tls, listen_addr2, listen_udp);
     ASSERT_TRUE(tls1.startServer());
     ASSERT_TRUE(tls2.startServer());
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "",
-            { base64Encode(tls1.fingerprint()), base64Encode(tls2.fingerprint()) }));
+    ASSERT_TRUE(mDnsClient.SetResolversWithTls(
+            servers, mDefaultSearchDomains, mDefaultParams, "",
+            {base64Encode(tls1.fingerprint()), base64Encode(tls2.fingerprint())}));
 
     const hostent* result;
 
@@ -1307,7 +1313,7 @@
     EXPECT_EQ(2U, dns2.queries().size());
 
     // Clear TLS bit.
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains,  mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     tls2.stopServer();
     dns1.stopServer();
     dns2.stopServer();
@@ -1325,8 +1331,8 @@
 
     test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
     ASSERT_TRUE(tls.startServer());
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder,
-            "www.example.com", {}));
+    ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams,
+                                               "www.example.com", {}));
 
     // The TLS server's certificate doesn't chain to a known CA, and a nonempty name was specified,
     // so the client should fail the TLS handshake before ever issuing a query.
@@ -1336,7 +1342,7 @@
     EXPECT_EQ(nullptr, gethostbyname("badtlsname"));
 
     // Clear TLS bit.
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains,  mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     tls.stopServer();
     dns.stopServer();
 }
@@ -1354,8 +1360,8 @@
 
     test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
     ASSERT_TRUE(tls.startServer());
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "",
-            { base64Encode(tls.fingerprint()) }));
+    ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams, "",
+                                               {base64Encode(tls.fingerprint())}));
 
     // Wait for validation to complete.
     EXPECT_TRUE(tls.waitForQueries(1, 5000));
@@ -1373,7 +1379,7 @@
     EXPECT_TRUE(tls.waitForQueries(3, 5000));
 
     // Clear TLS bit.
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains,  mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     tls.stopServer();
     dns.stopServer();
 }
@@ -1448,11 +1454,11 @@
         if (config.withWorkingTLS) ASSERT_TRUE(tls.startServer());
 
         if (config.mode == OFF) {
-            ASSERT_TRUE(SetResolversForNetwork(
-                    servers, mDefaultSearchDomains,  mDefaultParams_Binder));
+            ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains,
+                                                          mDefaultParams));
         } else if (config.mode == OPPORTUNISTIC) {
-            ASSERT_TRUE(SetResolversWithTls(
-                    servers, mDefaultSearchDomains, mDefaultParams_Binder, "", {}));
+            ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains,
+                                                       mDefaultParams, "", {}));
             // Wait for validation to complete.
             if (config.withWorkingTLS) EXPECT_TRUE(tls.waitForQueries(1, 5000));
         } else if (config.mode == STRICT) {
@@ -1460,9 +1466,9 @@
             // rather than hostname validation.
             const auto& fingerprint =
                     (config.withWorkingTLS) ? tls.fingerprint() : NOOP_FINGERPRINT;
-            ASSERT_TRUE(SetResolversWithTls(
-                    servers, mDefaultSearchDomains, mDefaultParams_Binder, "",
-                    { base64Encode(fingerprint) }));
+            ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains,
+                                                       mDefaultParams, "",
+                                                       {base64Encode(fingerprint)}));
             // Wait for validation to complete.
             if (config.withWorkingTLS) EXPECT_TRUE(tls.waitForQueries(1, 5000));
         } else {
@@ -1534,9 +1540,8 @@
     dns.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
     ASSERT_TRUE(dns.startServer());
 
-    ASSERT_TRUE(SetResolversWithTls(
-            servers, mDefaultSearchDomains, mDefaultParams_Binder,
-            {}, "", { base64Encode(NOOP_FINGERPRINT) }));
+    ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams, {},
+                                               "", {base64Encode(NOOP_FINGERPRINT)}));
 
     addrinfo* ai_result = nullptr;
     EXPECT_NE(0, getaddrinfo(host_name, nullptr, nullptr, &ai_result));
@@ -1633,7 +1638,7 @@
     dns.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     int fd1 = resNetworkQuery(TEST_NETID, "howdy.example.com", ns_c_in, ns_t_a, 0);
@@ -1680,7 +1685,7 @@
     dns.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     static struct {
@@ -1722,7 +1727,7 @@
     dns.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // TODO: Disable retry to make this test explicit.
@@ -1782,7 +1787,7 @@
     dns.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     int fd = dns_open_proxy();
@@ -1843,7 +1848,7 @@
     dns.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // ANDROID_RESOLV_NO_CACHE_STORE
@@ -1908,7 +1913,7 @@
     dns.addMapping(host_name, ns_type::ns_t_aaaa, "::1.2.3.4");
     ASSERT_TRUE(dns.startServer());
     std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     dns.setResponseProbability(0.0);
@@ -2035,21 +2040,22 @@
         dns.setEdns(config.edns);
 
         if (config.mode == OFF) {
-            ASSERT_TRUE(
-                    SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+            ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains,
+                                                          mDefaultParams));
         } else if (config.mode == OPPORTUNISTIC_UDP) {
-            ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder,
-                                            "", {}));
+            ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains,
+                                                       mDefaultParams, "", {}));
         } else if (config.mode == OPPORTUNISTIC_TLS) {
             ASSERT_TRUE(tls.startServer());
-            ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder,
-                                            "", {}));
+            ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains,
+                                                       mDefaultParams, "", {}));
             // Wait for validation to complete.
             EXPECT_TRUE(tls.waitForQueries(1, 5000));
         } else if (config.mode == STRICT) {
             ASSERT_TRUE(tls.startServer());
-            ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder,
-                                            "", {base64Encode(tls.fingerprint())}));
+            ASSERT_TRUE(mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains,
+                                                       mDefaultParams, "",
+                                                       {base64Encode(tls.fingerprint())}));
             // Wait for validation to complete.
             EXPECT_TRUE(tls.waitForQueries(1, 5000));
         }
@@ -2109,7 +2115,8 @@
     dns.setEdns(test::DNSResponder::Edns::FORMERR_ON_EDNS);
     test::DnsTlsFrontend tls(CLEARTEXT_ADDR, TLS_PORT, CLEARTEXT_ADDR, CLEARTEXT_PORT);
     ASSERT_TRUE(tls.startServer());
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "", {}));
+    ASSERT_TRUE(
+            mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams, "", {}));
     // Wait for validation complete.
     EXPECT_TRUE(tls.waitForQueries(1, 5000));
     // Shutdown TLS server to get an error. It's similar to no response case but without waiting.
@@ -2140,7 +2147,8 @@
     ASSERT_TRUE(dns.startServer());
     test::DnsTlsFrontend tls(CLEARTEXT_ADDR, TLS_PORT, CLEARTEXT_ADDR, CLEARTEXT_PORT);
     ASSERT_TRUE(tls.startServer());
-    ASSERT_TRUE(SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams_Binder, "", {}));
+    ASSERT_TRUE(
+            mDnsClient.SetResolversWithTls(servers, mDefaultSearchDomains, mDefaultParams, "", {}));
     // Wait for validation complete.
     EXPECT_TRUE(tls.waitForQueries(1, 5000));
     // Shutdown TLS server to get an error. It's similar to no response case but without waiting.
@@ -2175,7 +2183,7 @@
     ASSERT_TRUE(dns2.startServer());
 
     std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2195,7 +2203,7 @@
 
     // Let's test the case when there's an IPv4 resolver.
     servers = {listen_addr, listen_addr2};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
     dns2.clearQueries();
 
@@ -2222,7 +2230,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2259,7 +2267,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2292,7 +2300,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2332,7 +2340,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2395,7 +2403,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2439,7 +2447,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2519,7 +2527,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2563,7 +2571,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2611,7 +2619,7 @@
     dns.addMapping(dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170");
     ASSERT_TRUE(dns.startServer());
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2653,7 +2661,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2732,7 +2740,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2804,7 +2812,7 @@
     dns.addMapping(dns64_name, ns_type::ns_t_aaaa, "64:ff9b::192.0.0.170");
     ASSERT_TRUE(dns.startServer());
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2839,7 +2847,7 @@
     dns.addMapping(host_name, ns_type::ns_t_a, "1.2.3.4");
     ASSERT_TRUE(dns.startServer());
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2865,7 +2873,7 @@
     dns.addMapping(host_name, ns_type::ns_t_aaaa, "2001:db8::1.2.3.4");
     ASSERT_TRUE(dns.startServer());
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.
@@ -2909,7 +2917,7 @@
     ASSERT_TRUE(dns.startServer());
 
     const std::vector<std::string> servers = {listen_addr};
-    ASSERT_TRUE(SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams_Binder));
+    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, mDefaultSearchDomains, mDefaultParams));
     dns.clearQueries();
 
     // Wait for detecting prefix to complete.