[net] Move DnsConfigService to NetworkChangeNotifier.

net/base/host_resolver_impl_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 "net/base/host_resolver_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 417 matching lines @@
     void DeleteResolver() { test->resolver_.reset(); }
 
     HostResolverImplTest* test;
   };
 
   void CreateResolver() {
     resolver_.reset(new HostResolverImpl(
         HostCache::CreateDefaultCache(),
         DefaultLimits(),
         DefaultParams(proc_),
-        scoped_ptr<DnsConfigService>(NULL),
         scoped_ptr<DnsClient>(NULL),
         NULL));
   }
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time and
   // perform no retries.
   void CreateSerialResolver() {
     HostResolverImpl::ProcTaskParams params = DefaultParams(proc_);
     params.max_retry_attempts = 0u;
     PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
     resolver_.reset(new HostResolverImpl(
         HostCache::CreateDefaultCache(),
         limits,
         params,
-        scoped_ptr<DnsConfigService>(NULL),
         scoped_ptr<DnsClient>(NULL),
         NULL));
   }
 
   // The Request will not be made until a call to |Resolve()|, and the Job will
   // not start until released by |proc_->SignalXXX|.
   Request* CreateRequest(const HostResolver::RequestInfo& info) {
     Request* req = new Request(info, requests_.size(), resolver_.get(),
                                handler_.get());
     requests_.push_back(req);
@@ skipping 292 matching lines @@
       }
     }
   };
   set_handler(new MyHandler());
 
   // Turn off caching for this host resolver.
   resolver_.reset(new HostResolverImpl(
       NULL,
       DefaultLimits(),
       DefaultParams(proc_),
-      scoped_ptr<DnsConfigService>(NULL),
       scoped_ptr<DnsClient>(NULL),
       NULL));
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
   }
 
   proc_->SignalMultiple(2u);  // One for "a". One for the second "a".
 
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
@@ skipping 417 matching lines @@
 
   // Specify smaller interval for unresponsive_delay_ for HostResolverImpl so
   // that unit test runs faster. For example, this test finishes in 1.5 secs
   // (500ms * 3).
   params.unresponsive_delay = base::TimeDelta::FromMilliseconds(500);
 
   resolver_.reset(
       new HostResolverImpl(HostCache::CreateDefaultCache(),
                            DefaultLimits(),
                            params,
-                           scoped_ptr<DnsConfigService>(NULL),
                            scoped_ptr<DnsClient>(NULL),
                            NULL));
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   Request* req = CreateRequest(info);
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
 
   // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
   EXPECT_EQ(-4, req->WaitForResult());
@@ skipping 30 matching lines @@
     AddDnsRule("4ok", dns_protocol::kTypeA, MockDnsClientRule::OK);
     AddDnsRule("4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY);
     AddDnsRule("6ok", dns_protocol::kTypeA, MockDnsClientRule::EMPTY);
     AddDnsRule("6ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK);
     AddDnsRule("4nx", dns_protocol::kTypeA, MockDnsClientRule::OK);
     AddDnsRule("4nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL_ASYNC);
     CreateResolver();
   }
 
   void CreateResolver() {
-    config_service_ = new MockDnsConfigService();
     resolver_.reset(new HostResolverImpl(
         HostCache::CreateDefaultCache(),
         DefaultLimits(),
         DefaultParams(proc_),
-        scoped_ptr<DnsConfigService>(config_service_),
         CreateMockDnsClient(DnsConfig(), dns_rules_),
         NULL));
   }
 
   // Adds a rule to |dns_rules_|. Must be followed by |CreateResolver| to apply.
   void AddDnsRule(const std::string& prefix,
                   uint16 qtype,
                   MockDnsClientRule::Result result) {
     MockDnsClientRule rule = { prefix, qtype, result };
     dns_rules_.push_back(rule);
   }
 
   void ChangeDnsConfig(const DnsConfig& config) {
-    config_service_->ChangeConfig(config);
-    config_service_->ChangeHosts(config.hosts);
+    NetworkChangeNotifier::SetDnsConfig(config);
+    // Notification is delivered asynchronously.
+    MessageLoop::current()->RunAllPending();
   }
 
   MockDnsClientRuleList dns_rules_;
-  // Owned by |resolver_|.
-  MockDnsConfigService* config_service_;
 };
 
 // TODO(szym): Test AbortAllInProgressJobs due to DnsConfig change.
 
 // TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
 
 // Test successful and fallback resolutions in HostResolverImpl::DnsTask.
 TEST_F(HostResolverImplDnsTest, DnsTask) {
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
@@ skipping 54 matching lines @@
   EXPECT_EQ(1u, requests_[1]->NumberOfAddresses());
   EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
   EXPECT_EQ(1u, requests_[2]->NumberOfAddresses());
   EXPECT_TRUE(requests_[2]->HasAddress("::1", 80));
   EXPECT_EQ(1u, requests_[3]->NumberOfAddresses());
   EXPECT_TRUE(requests_[3]->HasAddress("192.168.1.101", 80));
 }
 
 TEST_F(HostResolverImplDnsTest, ServeFromHosts) {
   // Initially, use empty HOSTS file.
-  ChangeDnsConfig(CreateValidDnsConfig());
+  DnsConfig config = CreateValidDnsConfig();
+  ChangeDnsConfig(config);
 
   proc_->AddRuleForAllFamilies("", "");  // Default to failures.
   proc_->SignalMultiple(1u);  // For the first request which misses.
 
   Request* req0 = CreateRequest("er_ipv4", 80);
   EXPECT_EQ(ERR_IO_PENDING, req0->Resolve());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req0->WaitForResult());
 
   IPAddressNumber local_ipv4, local_ipv6;
   ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4));
   ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6));
 
   DnsHosts hosts;
   hosts[DnsHostsKey("er_ipv4", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   hosts[DnsHostsKey("er_ipv6", ADDRESS_FAMILY_IPV6)] = local_ipv6;
   hosts[DnsHostsKey("er_both", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   hosts[DnsHostsKey("er_both", ADDRESS_FAMILY_IPV6)] = local_ipv6;
 
   // Update HOSTS file.
-  config_service_->ChangeHosts(hosts);
+  config.hosts = hosts;
+  ChangeDnsConfig(config);
 
   Request* req1 = CreateRequest("er_ipv4", 80);
   EXPECT_EQ(OK, req1->Resolve());
   EXPECT_TRUE(req1->HasOneAddress("127.0.0.1", 80));
 
   Request* req2 = CreateRequest("er_ipv6", 80);
   EXPECT_EQ(OK, req2->Resolve());
   EXPECT_TRUE(req2->HasOneAddress("::1", 80));
 
   Request* req3 = CreateRequest("er_both", 80);
@@ skipping 30 matching lines @@
   proc_->SignalMultiple(requests_.size());
 
   for (size_t i = 0; i < 2; ++i)
     EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[i]->WaitForResult()) << i;
 
   for (size_t i = 2; i < requests_.size(); ++i)
     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
 }
 
 }  // namespace net