Provide Shill IP Address to myIpAddress()

On Chrome OS we need to get the IP Address to use for myIpAddress() from Shill since gethostname() returns localhost.

BUG=175652
TBR=sky@chromium.org

Review URL: https://codereview.chromium.org/238433003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@277679 0039d316-1c4b-4281-b951-d872f2087c98

15 files changed, 593 insertions, 121 deletions

diff --git a/chrome/browser/io_thread.cc b/chrome/browser/io_thread.cc
index 277f4ff..3a9860c 100644
--- a/chrome/browser/io_thread.cc
+++ b/chrome/browser/io_thread.cc
@@ -101,6 +101,7 @@
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/net/cert_verify_proc_chromeos.h"
+#include "chromeos/network/host_resolver_impl_chromeos.h"
 #endif
 
 using content::BrowserThread;
@@ -185,8 +186,15 @@ scoped_ptr<net::HostResolver> CreateGlobalHostResolver(net::NetLog* net_log) {
     }
   }
 
-  scoped_ptr<net::HostResolver> global_host_resolver(
-      net::HostResolver::CreateSystemResolver(options, net_log));
+  scoped_ptr<net::HostResolver> global_host_resolver;
+#if defined OS_CHROMEOS
+  global_host_resolver =
+      chromeos::HostResolverImplChromeOS::CreateSystemResolver(options,
+                                                               net_log);
+#else
+  global_host_resolver =
+      net::HostResolver::CreateSystemResolver(options, net_log);
+#endif
 
   // Determine if we should disable IPv6 support.
   if (command_line.HasSwitch(switches::kEnableIPv6)) {
diff --git a/chromeos/chromeos.gyp b/chromeos/chromeos.gyp
index 686b7ae..58aea83 100644
--- a/chromeos/chromeos.gyp
+++ b/chromeos/chromeos.gyp
@@ -276,6 +276,8 @@
         'network/device_state.h',
         'network/geolocation_handler.cc',
         'network/geolocation_handler.h',
+        'network/host_resolver_impl_chromeos.cc',
+       	'network/host_resolver_impl_chromeos.h',
         'network/managed_network_configuration_handler.cc',
         'network/managed_network_configuration_handler.h',
         'network/managed_network_configuration_handler_impl.cc',
@@ -520,6 +522,7 @@
         'login/login_state_unittest.cc',
         'network/client_cert_resolver_unittest.cc',
         'network/geolocation_handler_unittest.cc',
+	'network/host_resolver_impl_chromeos_unittest.cc',
         'network/managed_network_configuration_handler_unittest.cc',
         'network/network_cert_migrator_unittest.cc',
         'network/network_change_notifier_chromeos_unittest.cc',
diff --git a/chromeos/network/device_state.h b/chromeos/network/device_state.h
index 5f4486d..3e8195b 100644
--- a/chromeos/network/device_state.h
+++ b/chromeos/network/device_state.h
@@ -49,10 +49,12 @@ class CHROMEOS_EXPORT DeviceState : public ManagedState {
   const std::string& mdn() const { return mdn_; }
   const CellularScanResults& scan_results() const { return scan_results_; }
 
+  // |ip_configs_| is kept up to date by NetworkStateHandler.
+  const base::DictionaryValue& ip_configs() const { return ip_configs_; }
+
   // Do not use this. It exists temporarily for internet_options_handler.cc
   // which is being deprecated.
   const base::DictionaryValue& properties() const { return properties_; }
-  const base::DictionaryValue& ip_configs() const { return ip_configs_; }
 
   // Ethernet specific accessors
   bool eap_authentication_completed() const {
diff --git a/chromeos/network/host_resolver_impl_chromeos.cc b/chromeos/network/host_resolver_impl_chromeos.cc
new file mode 100644
index 0000000..ad946e5
--- /dev/null
+++ b/chromeos/network/host_resolver_impl_chromeos.cc
@@ -0,0 +1,214 @@
+// Copyright 2014 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 "chromeos/network/host_resolver_impl_chromeos.h"
+
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/values.h"
+#include "chromeos/network/device_state.h"
+#include "chromeos/network/network_handler.h"
+#include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
+#include "chromeos/network/network_state_handler_observer.h"
+#include "net/base/address_list.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_util.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace chromeos {
+
+// HostResolverImplChromeOS::NetworkStateHandlerObserver
+//
+// An instance of this class is created on the NetworkHandler (UI) thread and
+// manages its own lifetime, destroying itself when NetworkStateHandlerObserver
+// ::IsShuttingDown() gets called.
+
+class HostResolverImplChromeOS::NetworkObserver
+    : public chromeos::NetworkStateHandlerObserver {
+ public:
+  static void Create(
+      const base::WeakPtr<HostResolverImplChromeOS>& resolver,
+      scoped_refptr<base::MessageLoopProxy> resolver_message_loop,
+      NetworkStateHandler* network_state_handler) {
+    new NetworkObserver(resolver, resolver_message_loop, network_state_handler);
+  }
+
+  NetworkObserver(const base::WeakPtr<HostResolverImplChromeOS>& resolver,
+                  scoped_refptr<base::MessageLoopProxy> resolver_message_loop,
+                  NetworkStateHandler* network_state_handler)
+      : resolver_(resolver),
+        resolver_message_loop_(resolver_message_loop),
+        network_state_handler_(network_state_handler),
+        weak_ptr_factory_resolver_thread_(this) {
+    network_state_handler_->AddObserver(this, FROM_HERE);
+    DefaultNetworkChanged(network_state_handler_->DefaultNetwork());
+  }
+
+ private:
+  virtual ~NetworkObserver() {
+    network_state_handler_->RemoveObserver(this, FROM_HERE);
+  }
+
+  // NetworkStateHandlerObserver
+  virtual void DefaultNetworkChanged(const NetworkState* network) OVERRIDE {
+    if (!network) {
+      DVLOG(2) << "DefaultNetworkChanged: No Network.";
+      CallResolverSetIpAddress("", "");
+      return;
+    }
+    std::string ipv4_address, ipv6_address;
+    const DeviceState* device_state =
+        network_state_handler_->GetDeviceState(network->device_path());
+    if (!device_state) {
+      LOG(ERROR) << "DefaultNetworkChanged: Network missing device: "
+                 << network->path();
+      CallResolverSetIpAddress("", "");
+      return;
+    }
+    for (base::DictionaryValue::Iterator iter(device_state->ip_configs());
+         !iter.IsAtEnd(); iter.Advance()) {
+      const base::DictionaryValue* ip_config;
+      if (!iter.value().GetAsDictionary(&ip_config)) {
+        LOG(ERROR) << "Badly formatted IPConfigs: " << network->path();
+        continue;
+      }
+      std::string method, address;
+      if (ip_config->GetString(shill::kMethodProperty, &method) &&
+          ip_config->GetString(shill::kAddressProperty, &address)) {
+        if (method == shill::kTypeIPv4 || method == shill::kTypeDHCP)
+          ipv4_address = address;
+        else if (method == shill::kTypeIPv6 || method == shill::kTypeDHCP6)
+          ipv6_address = address;
+      } else {
+        LOG(ERROR) << "DefaultNetworkChanged: IPConfigs missing properties: "
+                   << network->path();
+      }
+    }
+    DVLOG(2) << "DefaultNetworkChanged: " << network->name()
+             << " IPv4: " << ipv4_address << " IPv6: " << ipv6_address;
+    CallResolverSetIpAddress(ipv4_address, ipv6_address);
+  }
+
+  virtual void IsShuttingDown() OVERRIDE {
+    delete this;
+  }
+
+  void CallResolverSetIpAddress(const std::string& ipv4_address,
+                                const std::string& ipv6_address) {
+    resolver_message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&NetworkObserver::SetIpAddressOnResolverThread,
+                   weak_ptr_factory_resolver_thread_.GetWeakPtr(),
+                   ipv4_address, ipv6_address));
+  }
+
+  void SetIpAddressOnResolverThread(const std::string& ipv4_address,
+                                    const std::string& ipv6_address) {
+    if (resolver_)
+      resolver_->SetIPAddresses(ipv4_address, ipv6_address);
+  }
+
+  base::WeakPtr<HostResolverImplChromeOS> resolver_;
+  scoped_refptr<base::MessageLoopProxy> resolver_message_loop_;
+  NetworkStateHandler* network_state_handler_;
+  base::WeakPtrFactory<NetworkObserver> weak_ptr_factory_resolver_thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkObserver);
+};
+
+// HostResolverImplChromeOS
+
+HostResolverImplChromeOS::HostResolverImplChromeOS(
+    scoped_refptr<base::MessageLoopProxy> network_handler_message_loop,
+    NetworkStateHandler* network_state_handler,
+    const Options& options,
+    net::NetLog* net_log)
+    : HostResolverImpl(options, net_log),
+      network_handler_message_loop_(network_handler_message_loop),
+      weak_ptr_factory_(this) {
+  network_handler_message_loop->PostTask(
+      FROM_HERE,
+      base::Bind(&NetworkObserver::Create,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::MessageLoopProxy::current(),
+                 network_state_handler));
+}
+
+HostResolverImplChromeOS::~HostResolverImplChromeOS() {
+}
+
+int HostResolverImplChromeOS::Resolve(const RequestInfo& info,
+                                      net::RequestPriority priority,
+                                      net::AddressList* addresses,
+                                      const net::CompletionCallback& callback,
+                                      RequestHandle* out_req,
+                                      const net::BoundNetLog& source_net_log) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (ResolveLocalIPAddress(info, addresses))
+    return net::OK;
+  return net::HostResolverImpl::Resolve(
+      info, priority, addresses, callback, out_req, source_net_log);
+}
+
+void HostResolverImplChromeOS::SetIPAddresses(const std::string& ipv4_address,
+                                              const std::string& ipv6_address) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  ipv4_address_ = ipv4_address;
+  ipv6_address_ = ipv6_address;
+}
+
+bool HostResolverImplChromeOS::ResolveLocalIPAddress(
+    const RequestInfo& info,
+    net::AddressList* addresses) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (info.hostname() != net::GetHostName() || ipv4_address_.empty())
+    return false;
+
+  // Use IPConfig data for localhost address lookup.
+  addresses->clear();
+
+  if (info.address_family() != net::ADDRESS_FAMILY_IPV4 &&
+      !ipv6_address_.empty()) {
+    net::IPAddressNumber ipv6;
+    if (net::ParseIPLiteralToNumber(ipv6_address_, &ipv6))
+      addresses->push_back(net::IPEndPoint(ipv6, 0));
+  }
+
+  net::IPAddressNumber ipv4;
+  if (net::ParseIPLiteralToNumber(ipv4_address_, &ipv4))
+    addresses->push_back(net::IPEndPoint(ipv4, 0));
+
+  DVLOG(2) << "ResolveLocalIPAddress("
+           << static_cast<int>(info.address_family()) << "): "
+           << addresses->size()
+           << " IPv4: " << ipv4_address_ << " IPv6: " << ipv6_address_;
+  addresses->SetDefaultCanonicalName();
+  return true;
+}
+
+// static
+scoped_ptr<net::HostResolver> HostResolverImplChromeOS::CreateSystemResolver(
+    const Options& options,
+    net::NetLog* net_log) {
+  return scoped_ptr<net::HostResolver>(new HostResolverImplChromeOS(
+      NetworkHandler::Get()->message_loop(),
+      NetworkHandler::Get()->network_state_handler(),
+      options,
+      net_log));
+}
+
+// static
+scoped_ptr<net::HostResolver>
+HostResolverImplChromeOS::CreateHostResolverForTest(
+    scoped_refptr<base::MessageLoopProxy> network_handler_message_loop,
+    NetworkStateHandler* network_state_handler) {
+  Options options;
+  return scoped_ptr<net::HostResolver>(new HostResolverImplChromeOS(
+      network_handler_message_loop,
+      network_state_handler,
+      options,
+      NULL));
+}
+
+}  // namespace chromeos
diff --git a/chromeos/network/host_resolver_impl_chromeos.h b/chromeos/network/host_resolver_impl_chromeos.h
new file mode 100644
index 0000000..94f7712
--- /dev/null
+++ b/chromeos/network/host_resolver_impl_chromeos.h
@@ -0,0 +1,80 @@
+// Copyright 2014 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.
+
+#ifndef CHROMEOS_NETWORK_HOST_RESOLVER_IMPL_CHROMEOS_H_
+#define CHROMEOS_NETWORK_HOST_RESOLVER_IMPL_CHROMEOS_H_
+
+#include "base/memory/ref_counted.h"
+#include "base/threading/thread_checker.h"
+#include "chromeos/chromeos_export.h"
+#include "net/dns/host_resolver_impl.h"
+
+namespace base {
+class MessageLoopProxy;
+}
+
+namespace chromeos {
+class NetworkStateHandler;
+}
+
+namespace chromeos {
+
+// HostResolverImplChromeOS overrides HostResolverImpl::Resolve in order to
+// provide the correct IP addresses for localhost using the chromeos
+// NetworkHandler interface. ('hostname' only returns 'localhost' on cros).
+
+class CHROMEOS_EXPORT HostResolverImplChromeOS : public net::HostResolverImpl {
+ public:
+  // ChromeOS specific implementation of HostResolver::CreateSystemResolver.
+  // Assumes NetworkHandler has been initialized.
+  // This is expected to be constructed on the same thread that Resolve() is
+  // called from, i.e. the IO thread, which is presumed to differ from the
+  // thread that NetworkStateHandler is called on, i.e. the UI thread.
+  static scoped_ptr<net::HostResolver> CreateSystemResolver(
+      const Options& options,
+      net::NetLog* net_log);
+
+  // Creates a host resolver instance for testing.
+  static scoped_ptr<net::HostResolver> CreateHostResolverForTest(
+      scoped_refptr<base::MessageLoopProxy> network_handler_message_loop,
+      NetworkStateHandler* network_state_handler);
+
+  virtual ~HostResolverImplChromeOS();
+
+  // HostResolverImpl
+  virtual int Resolve(const RequestInfo& info,
+                      net::RequestPriority priority,
+                      net::AddressList* addresses,
+                      const net::CompletionCallback& callback,
+                      RequestHandle* out_req,
+                      const net::BoundNetLog& source_net_log) OVERRIDE;
+
+ private:
+  friend class net::HostResolver;
+  class NetworkObserver;
+
+  HostResolverImplChromeOS(
+      scoped_refptr<base::MessageLoopProxy> network_handler_message_loop,
+      NetworkStateHandler* network_state_handler,
+      const Options& options,
+      net::NetLog* net_log);
+
+  void SetIPAddresses(const std::string& ipv4_address,
+                      const std::string& ipv6_address);
+
+  bool ResolveLocalIPAddress(const RequestInfo& info,
+                             net::AddressList* addresses);
+
+  std::string ipv4_address_;
+  std::string ipv6_address_;
+  base::ThreadChecker thread_checker_;
+  scoped_refptr<base::MessageLoopProxy> network_handler_message_loop_;
+  base::WeakPtrFactory<HostResolverImplChromeOS> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(HostResolverImplChromeOS);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_NETWORK_HOST_RESOLVER_IMPL_CHROMEOS_H_
diff --git a/chromeos/network/host_resolver_impl_chromeos_unittest.cc b/chromeos/network/host_resolver_impl_chromeos_unittest.cc
new file mode 100644
index 0000000..535eec9
--- /dev/null
+++ b/chromeos/network/host_resolver_impl_chromeos_unittest.cc
@@ -0,0 +1,171 @@
+// Copyright 2014 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 "chromeos/network/host_resolver_impl_chromeos.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/strings/stringprintf.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/shill_device_client.h"
+#include "chromeos/dbus/shill_ipconfig_client.h"
+#include "chromeos/dbus/shill_service_client.h"
+#include "chromeos/network/device_state.h"
+#include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
+#include "dbus/object_path.h"
+#include "net/base/net_errors.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace {
+
+const char kTestIPv4Address[] = "1.2.3.4";
+const char kTestIPv6Address[] = "1:2:3:4:5:6:7:8";
+
+void DoNothingWithCallStatus(chromeos::DBusMethodCallStatus call_status) {}
+void ErrorCallbackFunction(const std::string& error_name,
+                           const std::string& error_message) {
+  LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
+}
+void ResolveCompletionCallback(int result) {}
+
+}  // namespace
+
+class HostResolverImplChromeOSTest : public testing::Test {
+ public:
+  HostResolverImplChromeOSTest() {}
+
+  virtual ~HostResolverImplChromeOSTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    chromeos::DBusThreadManager::InitializeWithStub();
+
+    network_state_handler_.reset(
+        chromeos::NetworkStateHandler::InitializeForTest());
+    base::RunLoop().RunUntilIdle();
+
+    const chromeos::NetworkState* default_network =
+        network_state_handler_->DefaultNetwork();
+    ASSERT_TRUE(default_network);
+    const chromeos::DeviceState* default_device =
+        network_state_handler_->GetDeviceState(default_network->device_path());
+    ASSERT_TRUE(default_device);
+    SetDefaultIPConfigs(default_device->path());
+
+    // Create the host resolver from the IO message loop.
+    io_message_loop_.PostTask(
+        FROM_HERE,
+        base::Bind(&HostResolverImplChromeOSTest::InitializeHostResolver,
+                   base::Unretained(this)));
+    io_message_loop_.RunUntilIdle();
+
+    // Run the main message loop to create the network observer and initialize
+    // the ip address values.
+    base::RunLoop().RunUntilIdle();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    network_state_handler_.reset();
+    chromeos::DBusThreadManager::Shutdown();
+  }
+
+ protected:
+  // Run from main (UI) message loop, calls Resolve on IO message loop.
+  int CallResolve(net::HostResolver::RequestInfo& info) {
+    io_message_loop_.PostTask(
+        FROM_HERE,
+        base::Bind(&HostResolverImplChromeOSTest::Resolve,
+                   base::Unretained(this),
+                   info));
+    io_message_loop_.RunUntilIdle();
+    return result_;
+  }
+
+  net::AddressList addresses_;
+  int result_;
+
+ private:
+  // Run from IO message loop.
+  void InitializeHostResolver() {
+    net::HostResolver::Options options;
+    host_resolver_ =
+        chromeos::HostResolverImplChromeOS::CreateHostResolverForTest(
+            base::MessageLoopProxy::current(),
+            network_state_handler_.get());
+  }
+
+  // Run from IO message loop.
+  void Resolve(net::HostResolver::RequestInfo info) {
+    result_ = host_resolver_->Resolve(
+        info,
+        net::DEFAULT_PRIORITY,
+        &addresses_,
+        base::Bind(&ResolveCompletionCallback),
+        NULL,
+        net_log_);
+  }
+
+  void SetDefaultIPConfigs(const std::string& default_device_path) {
+    const std::string kTestIPv4ConfigPath("test_ip_v4_config_path");
+    const std::string kTestIPv6ConfigPath("test_ip_v6_config_path");
+
+    SetIPConfig(kTestIPv4ConfigPath, shill::kTypeIPv4, kTestIPv4Address);
+    SetIPConfig(kTestIPv6ConfigPath, shill::kTypeIPv6, kTestIPv6Address);
+    base::RunLoop().RunUntilIdle();
+
+    base::ListValue ip_configs;
+    ip_configs.AppendString(kTestIPv4ConfigPath);
+    ip_configs.AppendString(kTestIPv6ConfigPath);
+
+    chromeos::DBusThreadManager::Get()->GetShillDeviceClient()->SetProperty(
+        dbus::ObjectPath(default_device_path),
+        shill::kIPConfigsProperty,
+        ip_configs,
+        base::Bind(&base::DoNothing),
+        base::Bind(&ErrorCallbackFunction));
+    base::RunLoop().RunUntilIdle();
+  }
+
+  void SetIPConfig(const std::string& path,
+                   const std::string& method,
+                   const std::string& address) {
+    chromeos::DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
+        dbus::ObjectPath(path),
+        shill::kAddressProperty,
+        base::StringValue(address),
+        base::Bind(&DoNothingWithCallStatus));
+    chromeos::DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
+        dbus::ObjectPath(path),
+        shill::kMethodProperty,
+        base::StringValue(method),
+        base::Bind(&DoNothingWithCallStatus));
+  }
+
+  scoped_ptr<chromeos::NetworkStateHandler> network_state_handler_;
+  scoped_ptr<net::HostResolver> host_resolver_;
+  base::MessageLoop io_message_loop_;
+  net::BoundNetLog net_log_;
+
+  DISALLOW_COPY_AND_ASSIGN(HostResolverImplChromeOSTest);
+};
+
+TEST_F(HostResolverImplChromeOSTest, Resolve) {
+  net::HostResolver::RequestInfo info(
+      net::HostPortPair(net::GetHostName(), 80));
+  info.set_address_family(net::ADDRESS_FAMILY_IPV4);
+  EXPECT_EQ(net::OK, CallResolve(info));
+  ASSERT_EQ(1u, addresses_.size());
+  std::string expected = base::StringPrintf("%s:%d", kTestIPv4Address, 0);
+  EXPECT_EQ(expected, addresses_[0].ToString());
+
+  info.set_address_family(net::ADDRESS_FAMILY_IPV6);
+  EXPECT_EQ(net::OK, CallResolve(info));
+  ASSERT_EQ(2u, addresses_.size());
+  expected = base::StringPrintf("[%s]:%d", kTestIPv6Address, 0);
+  EXPECT_EQ(expected, addresses_[0].ToString());
+  expected = base::StringPrintf("%s:%d", kTestIPv4Address, 0);
+  EXPECT_EQ(expected, addresses_[1].ToString());
+}
diff --git a/chromeos/network/network_state_handler.cc b/chromeos/network/network_state_handler.cc
index aa91883..e4e5f6e 100644
--- a/chromeos/network/network_state_handler.cc
+++ b/chromeos/network/network_state_handler.cc
@@ -60,6 +60,7 @@ NetworkStateHandler::NetworkStateHandler() {
 }
 
 NetworkStateHandler::~NetworkStateHandler() {
+  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_, IsShuttingDown());
   STLDeleteContainerPointers(network_list_.begin(), network_list_.end());
   STLDeleteContainerPointers(device_list_.begin(), device_list_.end());
 }
@@ -658,11 +659,19 @@ void NetworkStateHandler::UpdateIPConfigProperties(
     if (!network)
       return;
     network->IPConfigPropertiesChanged(properties);
+    if (network->path() == default_network_path_)
+      NotifyDefaultNetworkChanged(network);
   } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
     DeviceState* device = GetModifiableDeviceState(path);
     if (!device)
       return;
     device->IPConfigPropertiesChanged(ip_config_path, properties);
+    if (!default_network_path_.empty()) {
+      const NetworkState* default_network =
+          GetNetworkState(default_network_path_);
+      if (default_network && default_network->device_path() == path)
+        NotifyDefaultNetworkChanged(default_network);
+    }
   }
 }
 
diff --git a/chromeos/network/network_state_handler_observer.cc b/chromeos/network/network_state_handler_observer.cc
index b0cab57..0914e6b 100644
--- a/chromeos/network/network_state_handler_observer.cc
+++ b/chromeos/network/network_state_handler_observer.cc
@@ -30,4 +30,7 @@ void NetworkStateHandlerObserver::NetworkPropertiesUpdated(
     const NetworkState* network) {
 }
 
+void NetworkStateHandlerObserver::IsShuttingDown() {
+}
+
 }  // namespace chromeos
diff --git a/chromeos/network/network_state_handler_observer.h b/chromeos/network/network_state_handler_observer.h
index ef33c6f..63910c4 100644
--- a/chromeos/network/network_state_handler_observer.h
+++ b/chromeos/network/network_state_handler_observer.h
@@ -44,6 +44,10 @@ class CHROMEOS_EXPORT NetworkStateHandlerObserver {
   // wifi strength.
   virtual void NetworkPropertiesUpdated(const NetworkState* network);
 
+  // Called just before NetworkStateHandler is destroyed so that observers
+  // can safely stop observing.
+  virtual void IsShuttingDown();
+
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkStateHandlerObserver);
 };
diff --git a/net/dns/host_resolver.cc b/net/dns/host_resolver.cc
index 0435091..147a5a6e 100644
--- a/net/dns/host_resolver.cc
+++ b/net/dns/host_resolver.cc
@@ -24,10 +24,11 @@ namespace {
 // that limit this to 6, so we're temporarily holding it at that level.
 const size_t kDefaultMaxProcTasks = 6u;
 
-PrioritizedDispatcher::Limits GetDispatcherLimits(
-    const HostResolver::Options& options) {
-  PrioritizedDispatcher::Limits limits(NUM_PRIORITIES,
-                                       options.max_concurrent_resolves);
+}  // namespace
+
+PrioritizedDispatcher::Limits HostResolver::Options::GetDispatcherLimits()
+    const {
+  PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, max_concurrent_resolves);
 
   // If not using default, do not use the field trial.
   if (limits.total_jobs != HostResolver::kDefaultParallelism)
@@ -82,8 +83,6 @@ PrioritizedDispatcher::Limits GetDispatcherLimits(
   return limits;
 }
 
-}  // namespace
-
 HostResolver::Options::Options()
     : max_concurrent_resolves(kDefaultParallelism),
       max_retry_attempts(kDefaultRetryAttempts),
@@ -116,22 +115,15 @@ base::Value* HostResolver::GetDnsConfigAsValue() const {
 }
 
 // static
-scoped_ptr<HostResolver>
-HostResolver::CreateSystemResolver(const Options& options, NetLog* net_log) {
-  scoped_ptr<HostCache> cache;
-  if (options.enable_caching)
-    cache = HostCache::CreateDefaultCache();
-  return scoped_ptr<HostResolver>(new HostResolverImpl(
-      cache.Pass(),
-      GetDispatcherLimits(options),
-      HostResolverImpl::ProcTaskParams(NULL, options.max_retry_attempts),
-      net_log));
+scoped_ptr<HostResolver> HostResolver::CreateSystemResolver(
+    const Options& options,
+    NetLog* net_log) {
+  return scoped_ptr<HostResolver>(new HostResolverImpl(options, net_log));
 }
 
 // static
-scoped_ptr<HostResolver>
-HostResolver::CreateDefaultResolver(NetLog* net_log) {
-  return CreateSystemResolver(Options(), net_log);
+scoped_ptr<HostResolver> HostResolver::CreateDefaultResolver(NetLog* net_log) {
+  return scoped_ptr<HostResolver>(new HostResolverImpl(Options(), net_log));
 }
 
 HostResolver::HostResolver() {
diff --git a/net/dns/host_resolver.h b/net/dns/host_resolver.h
index 2964fe6..5216329 100644
--- a/net/dns/host_resolver.h
+++ b/net/dns/host_resolver.h
@@ -13,6 +13,7 @@
 #include "net/base/host_port_pair.h"
 #include "net/base/net_export.h"
 #include "net/base/net_util.h"
+#include "net/base/prioritized_dispatcher.h"
 #include "net/base/request_priority.h"
 
 namespace base {
@@ -48,6 +49,8 @@ class NET_EXPORT HostResolver {
   struct NET_EXPORT Options {
     Options();
 
+    PrioritizedDispatcher::Limits GetDispatcherLimits() const;
+
     size_t max_concurrent_resolves;
     size_t max_retry_attempts;
     bool enable_caching;
@@ -105,13 +108,11 @@ class NET_EXPORT HostResolver {
   // Opaque type used to cancel a request.
   typedef void* RequestHandle;
 
-  // This value can be passed into CreateSystemResolver as the
-  // |max_concurrent_resolves| parameter. It will select a default level of
-  // concurrency.
+  // Set Options.max_concurrent_resolves to this to select a default level
+  // of concurrency.
   static const size_t kDefaultParallelism = 0;
 
-  // This value can be passed into CreateSystemResolver as the
-  // |max_retry_attempts| parameter.
+  // Set Options.max_retry_attempts to this to select a default retry value.
   static const size_t kDefaultRetryAttempts = -1;
 
   // If any completion callbacks are pending when the resolver is destroyed,
diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc
index dd11336..d5602a4 100644
--- a/net/dns/host_resolver_impl.cc
+++ b/net/dns/host_resolver_impl.cc
@@ -1258,9 +1258,9 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
     DCHECK(!is_queued());
     PrioritizedDispatcher::Handle handle;
     if (!at_head) {
-      handle = resolver_->dispatcher_.Add(this, priority());
+      handle = resolver_->dispatcher_->Add(this, priority());
     } else {
-      handle = resolver_->dispatcher_.AddAtHead(this, priority());
+      handle = resolver_->dispatcher_->AddAtHead(this, priority());
     }
     // The dispatcher could have started |this| in the above call to Add, which
     // could have called Schedule again. In that case |handle| will be null,
@@ -1399,10 +1399,10 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
   void ReduceToOneJobSlot() {
     DCHECK_GE(num_occupied_job_slots_, 1u);
     if (is_queued()) {
-      resolver_->dispatcher_.Cancel(handle_);
+      resolver_->dispatcher_->Cancel(handle_);
       handle_.Reset();
     } else if (num_occupied_job_slots_ > 1) {
-      resolver_->dispatcher_.OnJobFinished();
+      resolver_->dispatcher_->OnJobFinished();
       --num_occupied_job_slots_;
     }
     DCHECK_EQ(1u, num_occupied_job_slots_);
@@ -1412,7 +1412,7 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
     if (is_queued()) {
       if (priority() != static_cast<RequestPriority>(handle_.priority()))
         priority_change_time_ = base::TimeTicks::Now();
-      handle_ = resolver_->dispatcher_.ChangePriority(handle_, priority());
+      handle_ = resolver_->dispatcher_->ChangePriority(handle_, priority());
     }
   }
 
@@ -1659,9 +1659,9 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
       KillDnsTask();
 
       // Signal dispatcher that a slot has opened.
-      resolver_->dispatcher_.OnJobFinished();
+      resolver_->dispatcher_->OnJobFinished();
     } else if (is_queued()) {
-      resolver_->dispatcher_.Cancel(handle_);
+      resolver_->dispatcher_->Cancel(handle_);
       handle_.Reset();
     }
 
@@ -1783,19 +1783,17 @@ HostResolverImpl::ProcTaskParams::ProcTaskParams(
       max_retry_attempts(max_retry_attempts),
       unresponsive_delay(base::TimeDelta::FromMilliseconds(6000)),
       retry_factor(2) {
+  // Maximum of 4 retry attempts for host resolution.
+  static const size_t kDefaultMaxRetryAttempts = 4u;
+  if (max_retry_attempts == HostResolver::kDefaultRetryAttempts)
+    max_retry_attempts = kDefaultMaxRetryAttempts;
 }
 
 HostResolverImpl::ProcTaskParams::~ProcTaskParams() {}
 
-HostResolverImpl::HostResolverImpl(
-    scoped_ptr<HostCache> cache,
-    const PrioritizedDispatcher::Limits& job_limits,
-    const ProcTaskParams& proc_params,
-    NetLog* net_log)
-    : cache_(cache.Pass()),
-      dispatcher_(job_limits),
-      max_queued_jobs_(job_limits.total_jobs * 100u),
-      proc_params_(proc_params),
+HostResolverImpl::HostResolverImpl(const Options& options, NetLog* net_log)
+    : max_queued_jobs_(0),
+      proc_params_(NULL, options.max_retry_attempts),
       net_log_(net_log),
       default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       received_dns_config_(false),
@@ -1807,14 +1805,14 @@ HostResolverImpl::HostResolverImpl(
       fallback_to_proctask_(true),
       weak_ptr_factory_(this),
       probe_weak_ptr_factory_(this) {
+  if (options.enable_caching)
+    cache_ = HostCache::CreateDefaultCache();
 
-  DCHECK_GE(dispatcher_.num_priorities(), static_cast<size_t>(NUM_PRIORITIES));
-
-  // Maximum of 4 retry attempts for host resolution.
-  static const size_t kDefaultMaxRetryAttempts = 4u;
+  PrioritizedDispatcher::Limits job_limits = options.GetDispatcherLimits();
+  dispatcher_.reset(new PrioritizedDispatcher(job_limits));
+  max_queued_jobs_ = job_limits.total_jobs * 100u;
 
-  if (proc_params_.max_retry_attempts == HostResolver::kDefaultRetryAttempts)
-    proc_params_.max_retry_attempts = kDefaultMaxRetryAttempts;
+  DCHECK_GE(dispatcher_->num_priorities(), static_cast<size_t>(NUM_PRIORITIES));
 
 #if defined(OS_WIN)
   EnsureWinsockInit();
@@ -1842,7 +1840,7 @@ HostResolverImpl::HostResolverImpl(
 
 HostResolverImpl::~HostResolverImpl() {
   // Prevent the dispatcher from starting new jobs.
-  dispatcher_.SetLimitsToZero();
+  dispatcher_->SetLimitsToZero();
   // It's now safe for Jobs to call KillDsnTask on destruction, because
   // OnJobComplete will not start any new jobs.
   STLDeleteValues(&jobs_);
@@ -1852,7 +1850,7 @@ HostResolverImpl::~HostResolverImpl() {
 }
 
 void HostResolverImpl::SetMaxQueuedJobs(size_t value) {
-  DCHECK_EQ(0u, dispatcher_.num_queued_jobs());
+  DCHECK_EQ(0u, dispatcher_->num_queued_jobs());
   DCHECK_GT(value, 0u);
   max_queued_jobs_ = value;
 }
@@ -1900,8 +1898,8 @@ int HostResolverImpl::Resolve(const RequestInfo& info,
     job->Schedule(false);
 
     // Check for queue overflow.
-    if (dispatcher_.num_queued_jobs() > max_queued_jobs_) {
-      Job* evicted = static_cast<Job*>(dispatcher_.EvictOldestLowest());
+    if (dispatcher_->num_queued_jobs() > max_queued_jobs_) {
+      Job* evicted = static_cast<Job*>(dispatcher_->EvictOldestLowest());
       DCHECK(evicted);
       evicted->OnEvicted();  // Deletes |evicted|.
       if (evicted == job) {
@@ -2203,8 +2201,8 @@ void HostResolverImpl::AbortAllInProgressJobs() {
   // aborting the old ones.  This is needed so that it won't start the second
   // DnsTransaction for a job in |jobs_to_abort| if the DnsConfig just became
   // invalid.
-  PrioritizedDispatcher::Limits limits = dispatcher_.GetLimits();
-  dispatcher_.SetLimits(
+  PrioritizedDispatcher::Limits limits = dispatcher_->GetLimits();
+  dispatcher_->SetLimits(
       PrioritizedDispatcher::Limits(limits.reserved_slots.size(), 0));
 
   // Life check to bail once |this| is deleted.
@@ -2217,20 +2215,20 @@ void HostResolverImpl::AbortAllInProgressJobs() {
   }
 
   if (self)
-    dispatcher_.SetLimits(limits);
+    dispatcher_->SetLimits(limits);
 }
 
 void HostResolverImpl::AbortDnsTasks() {
   // Pause the dispatcher so it won't start any new dispatcher jobs while
   // aborting the old ones.  This is needed so that it won't start the second
   // DnsTransaction for a job if the DnsConfig just changed.
-  PrioritizedDispatcher::Limits limits = dispatcher_.GetLimits();
-  dispatcher_.SetLimits(
+  PrioritizedDispatcher::Limits limits = dispatcher_->GetLimits();
+  dispatcher_->SetLimits(
       PrioritizedDispatcher::Limits(limits.reserved_slots.size(), 0));
 
   for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
     it->second->AbortDnsTask();
-  dispatcher_.SetLimits(limits);
+  dispatcher_->SetLimits(limits);
 }
 
 void HostResolverImpl::TryServingAllJobsFromHosts() {
diff --git a/net/dns/host_resolver_impl.h b/net/dns/host_resolver_impl.h
index 7bcc800..7a0fb57 100644
--- a/net/dns/host_resolver_impl.h
+++ b/net/dns/host_resolver_impl.h
@@ -16,7 +16,6 @@
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "net/base/network_change_notifier.h"
-#include "net/base/prioritized_dispatcher.h"
 #include "net/dns/host_cache.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/host_resolver_proc.h"
@@ -97,21 +96,17 @@ class NET_EXPORT HostResolverImpl
     uint32 retry_factor;
   };
 
-  // Creates a HostResolver that first uses the local cache |cache|, and then
-  // falls back to |proc_params.resolver_proc|.
+  // Creates a HostResolver as specified by |options|.
   //
-  // If |cache| is NULL, then no caching is used. Otherwise we take
-  // ownership of the |cache| pointer, and will free it during destruction.
+  // If Options.enable_caching is true, a cache is created using
+  // HostCache::CreateDefaultCache(). Otherwise no cache is used.
   //
-  // |job_limits| specifies the maximum number of jobs that the resolver will
-  // run at once. This upper-bounds the total number of outstanding
-  // DNS transactions (not counting retransmissions and retries).
+  // Options.GetDispatcherLimits() determines the maximum number of jobs that
+  // the resolver will run at once. This upper-bounds the total number of
+  // outstanding DNS transactions (not counting retransmissions and retries).
   //
   // |net_log| must remain valid for the life of the HostResolverImpl.
-  HostResolverImpl(scoped_ptr<HostCache> cache,
-                   const PrioritizedDispatcher::Limits& job_limits,
-                   const ProcTaskParams& proc_params,
-                   NetLog* net_log);
+  HostResolverImpl(const Options& options, NetLog* net_log);
 
   // If any completion callbacks are pending when the resolver is destroyed,
   // the host resolutions are cancelled, and the completion callbacks will not
@@ -145,6 +140,10 @@ class NET_EXPORT HostResolverImpl
   virtual HostCache* GetHostCache() OVERRIDE;
   virtual base::Value* GetDnsConfigAsValue() const OVERRIDE;
 
+  void set_proc_params_for_test(const ProcTaskParams& proc_params) {
+    proc_params_ = proc_params;
+  }
+
  private:
   friend class HostResolverImplTest;
   class Job;
@@ -237,7 +236,7 @@ class NET_EXPORT HostResolverImpl
   // HostResolverImpl::Job could occupy multiple PrioritizedDispatcher job
   // slots.
   size_t num_running_dispatcher_jobs_for_tests() const {
-    return dispatcher_.num_running_jobs();
+    return dispatcher_->num_running_jobs();
   }
 
   // Cache of host resolution results.
@@ -247,7 +246,7 @@ class NET_EXPORT HostResolverImpl
   JobMap jobs_;
 
   // Starts Jobs according to their priority and the configured limits.
-  PrioritizedDispatcher dispatcher_;
+  scoped_ptr<PrioritizedDispatcher> dispatcher_;
 
   // Limit on the maximum number of jobs queued in |dispatcher_|.
   size_t max_queued_jobs_;
diff --git a/net/dns/host_resolver_impl_unittest.cc b/net/dns/host_resolver_impl_unittest.cc
index efb63e8..4ab8fdf 100644
--- a/net/dns/host_resolver_impl_unittest.cc
+++ b/net/dns/host_resolver_impl_unittest.cc
@@ -24,7 +24,6 @@
 #include "net/base/net_util.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_test_util.h"
-#include "net/dns/host_cache.h"
 #include "net/dns/mock_host_resolver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -35,9 +34,12 @@ namespace {
 const size_t kMaxJobs = 10u;
 const size_t kMaxRetryAttempts = 4u;
 
-PrioritizedDispatcher::Limits DefaultLimits() {
-  PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, kMaxJobs);
-  return limits;
+HostResolver::Options DefaultOptions() {
+  HostResolver::Options options;
+  options.max_concurrent_resolves = kMaxJobs;
+  options.max_retry_attempts = kMaxRetryAttempts;
+  options.enable_caching = true;
+  return options;
 }
 
 HostResolverImpl::ProcTaskParams DefaultParams(
@@ -422,7 +424,7 @@ class HostResolverImplTest : public testing::Test {
   HostResolverImplTest() : proc_(new MockHostResolverProc()) {}
 
   void CreateResolver() {
-    CreateResolverWithLimitsAndParams(DefaultLimits(),
+    CreateResolverWithLimitsAndParams(kMaxJobs,
                                       DefaultParams(proc_.get()));
   }
 
@@ -431,8 +433,7 @@ class HostResolverImplTest : public testing::Test {
   void CreateSerialResolver() {
     HostResolverImpl::ProcTaskParams params = DefaultParams(proc_.get());
     params.max_retry_attempts = 0u;
-    PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
-    CreateResolverWithLimitsAndParams(limits, params);
+    CreateResolverWithLimitsAndParams(1u, params);
   }
 
  protected:
@@ -470,10 +471,12 @@ class HostResolverImplTest : public testing::Test {
   }
 
   virtual void CreateResolverWithLimitsAndParams(
-      const PrioritizedDispatcher::Limits& limits,
+      size_t max_concurrent_resolves,
       const HostResolverImpl::ProcTaskParams& params) {
-    resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
-                                         limits, params, NULL));
+    HostResolverImpl::Options options = DefaultOptions();
+    options.max_concurrent_resolves = max_concurrent_resolves;
+    resolver_.reset(new HostResolverImpl(options, NULL));
+    resolver_->set_proc_params_for_test(params);
   }
 
   // The Request will not be made until a call to |Resolve()|, and the Job will
@@ -835,10 +838,10 @@ TEST_F(HostResolverImplTest, StartWithinCallback) {
   set_handler(new MyHandler());
 
   // Turn off caching for this host resolver.
-  resolver_.reset(new HostResolverImpl(scoped_ptr<HostCache>(),
-                                       DefaultLimits(),
-                                       DefaultParams(proc_.get()),
-                                       NULL));
+  HostResolver::Options options = DefaultOptions();
+  options.enable_caching = false;
+  resolver_.reset(new HostResolverImpl(options, NULL));
+  resolver_->set_proc_params_for_test(DefaultParams(proc_.get()));
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
@@ -1272,11 +1275,8 @@ TEST_F(HostResolverImplTest, MultipleAttempts) {
   // (500ms * 3).
   params.unresponsive_delay = base::TimeDelta::FromMilliseconds(500);
 
-  resolver_.reset(
-      new HostResolverImpl(HostCache::CreateDefaultCache(),
-                           DefaultLimits(),
-                           params,
-                           NULL));
+  resolver_.reset(new HostResolverImpl(DefaultOptions(), NULL));
+  resolver_->set_proc_params_for_test(params);
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
@@ -1353,12 +1353,12 @@ class HostResolverImplDnsTest : public HostResolverImplTest {
 
   // HostResolverImplTest implementation:
   virtual void CreateResolverWithLimitsAndParams(
-      const PrioritizedDispatcher::Limits& limits,
+      size_t max_concurrent_resolves,
       const HostResolverImpl::ProcTaskParams& params) OVERRIDE {
-    resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
-                                         limits,
-                                         params,
-                                         NULL));
+    HostResolverImpl::Options options = DefaultOptions();
+    options.max_concurrent_resolves = max_concurrent_resolves;
+    resolver_.reset(new HostResolverImpl(options, NULL));
+    resolver_->set_proc_params_for_test(params);
     // Disable IPv6 support probing.
     resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
     dns_client_ = new MockDnsClient(DnsConfig(), dns_rules_);
@@ -1688,10 +1688,9 @@ TEST_F(HostResolverImplDnsTest, DontDisableDnsClientOnSporadicFailure) {
 TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) {
   // Use regular SystemHostResolverCall!
   scoped_refptr<HostResolverProc> proc(new SystemHostResolverProc());
-  resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(),
-                                       DefaultLimits(),
-                                       DefaultParams(proc.get()),
-                                       NULL));
+  resolver_.reset(new HostResolverImpl(DefaultOptions(), NULL));
+  resolver_->set_proc_params_for_test(DefaultParams(proc.get()));
+
   resolver_->SetDnsClient(
       scoped_ptr<DnsClient>(new MockDnsClient(DnsConfig(), dns_rules_)));
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
@@ -1786,9 +1785,7 @@ TEST_F(HostResolverImplDnsTest, CancelWithTwoTransactionsActive) {
 // Delete a resolver with some active requests and some queued requests.
 TEST_F(HostResolverImplDnsTest, DeleteWithActiveTransactions) {
   // At most 10 Jobs active at once.
-  CreateResolverWithLimitsAndParams(
-      PrioritizedDispatcher::Limits(NUM_PRIORITIES, 10u),
-      DefaultParams(proc_.get()));
+  CreateResolverWithLimitsAndParams(10u, DefaultParams(proc_.get()));
 
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
@@ -1899,9 +1896,7 @@ TEST_F(HostResolverImplDnsTest, SerialResolver) {
 // Test the case where the AAAA query is started when another transaction
 // completes.
 TEST_F(HostResolverImplDnsTest, AAAAStartsAfterOtherJobFinishes) {
-  CreateResolverWithLimitsAndParams(
-      PrioritizedDispatcher::Limits(NUM_PRIORITIES, 2),
-      DefaultParams(proc_.get()));
+  CreateResolverWithLimitsAndParams(2u, DefaultParams(proc_.get()));
   set_fallback_to_proctask(false);
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
@@ -1960,9 +1955,7 @@ TEST_F(HostResolverImplDnsTest, InvalidDnsConfigWithPendingRequests) {
   // make sure that aborting the first HostResolverImpl::Job does not trigger
   // another DnsTransaction on the second Job when it releases its second
   // prioritized dispatcher slot.
-  CreateResolverWithLimitsAndParams(
-      PrioritizedDispatcher::Limits(NUM_PRIORITIES, 3u),
-      DefaultParams(proc_.get()));
+  CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()));
 
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
@@ -2003,9 +1996,7 @@ TEST_F(HostResolverImplDnsTest,
   // occupying two slots has its DnsTask aborted is the case most likely to run
   // into problems.
   for (size_t limit = 1u; limit < 6u; ++limit) {
-    CreateResolverWithLimitsAndParams(
-        PrioritizedDispatcher::Limits(NUM_PRIORITIES, limit),
-        DefaultParams(proc_.get()));
+    CreateResolverWithLimitsAndParams(limit, DefaultParams(proc_.get()));
 
     resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
     ChangeDnsConfig(CreateValidDnsConfig());
@@ -2052,9 +2043,7 @@ TEST_F(HostResolverImplDnsTest, ManuallyDisableDnsClientWithPendingRequests) {
   // make sure that aborting the first HostResolverImpl::Job does not trigger
   // another DnsTransaction on the second Job when it releases its second
   // prioritized dispatcher slot.
-  CreateResolverWithLimitsAndParams(
-      PrioritizedDispatcher::Limits(NUM_PRIORITIES, 3u),
-      DefaultParams(proc_.get()));
+  CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()));
 
   resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
diff --git a/net/tools/gdig/gdig.cc b/net/tools/gdig/gdig.cc
index a55dbde..fbee886 100644
--- a/net/tools/gdig/gdig.cc
+++ b/net/tools/gdig/gdig.cc
@@ -421,12 +421,11 @@ void GDig::OnDnsConfig(const DnsConfig& dns_config_const) {
 
   scoped_ptr<DnsClient> dns_client(DnsClient::CreateClient(NULL));
   dns_client->SetConfig(dns_config);
+  HostResolver::Options options;
+  options.max_concurrent_resolves = parallellism_;
+  options.max_retry_attempts = 1u;
   scoped_ptr<HostResolverImpl> resolver(
-      new HostResolverImpl(
-          HostCache::CreateDefaultCache(),
-          PrioritizedDispatcher::Limits(NUM_PRIORITIES, parallellism_),
-          HostResolverImpl::ProcTaskParams(NULL, 1),
-          log_.get()));
+      new HostResolverImpl(options, log_.get()));
   resolver->SetDnsClient(dns_client.Pass());
   resolver_ = resolver.Pass();