NetworkChangeNotifierChromeos: Handle IPConfig property changes on the default network

chromeos/network/shill_property_handler.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 "chromeos/network/shill_property_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.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_manager_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/network_event_log.h"
+#include "chromeos/network/network_state.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 const char kLogModule[] = "ShillPropertyHandler";
 
 // Limit the number of services or devices we observe. Since they are listed in
 // priority order, it should be reasonable to ignore services past this.
 const size_t kMaxObserved = 100;
@@ skipping 379 matching lines @@
     NetworkDevicePropertyChangedCallback(path, key, value);
   else
     NOTREACHED();
 }
 
 void ShillPropertyHandler::NetworkServicePropertyChangedCallback(
     const std::string& path,
     const std::string& key,
     const base::Value& value) {
   if (key == shill::kIPConfigProperty) {
-    // Handle IPConfig here and call listener_->UpdateNetworkServiceIPAddress
+    // Request the IPConfig for the network and update network properties
     // when the request completes.
     std::string ip_config_path;
     value.GetAsString(&ip_config_path);
     DCHECK(!ip_config_path.empty());
     DBusThreadManager::Get()->GetShillIPConfigClient()->GetProperties(
         dbus::ObjectPath(ip_config_path),
         base::Bind(&ShillPropertyHandler::GetIPConfigCallback,
                    AsWeakPtr(), path));
   } else {
     listener_->UpdateNetworkServiceProperty(path, key, value);
   }
 }
 
 void ShillPropertyHandler::GetIPConfigCallback(
     const std::string& service_path,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& properties)  {
   if (call_status != DBUS_METHOD_CALL_SUCCESS) {
-    LOG(ERROR) << "Failed to get IP properties for: " << service_path;
+    LOG(ERROR) << "Failed to get IP Config properties for: " << service_path;
     return;
   }
-  std::string ip_address;
-  if (!properties.GetStringWithoutPathExpansion(flimflam::kAddressProperty,
-                                                &ip_address)) {
+  const base::Value* ip_address;
+  if (!properties.GetWithoutPathExpansion(flimflam::kAddressProperty,
+                                          &ip_address)) {
     LOG(ERROR) << "Failed to get IP Address property for: " << service_path;
     return;
   }
-  listener_->UpdateNetworkServiceIPAddress(service_path, ip_address);
+  listener_->UpdateNetworkServiceProperty(
+      service_path,
+      NetworkState::IPConfigProperty(flimflam::kAddressProperty),
+      *ip_address);
+
+  const base::Value* dns_servers = NULL;
+  if (!properties.GetWithoutPathExpansion(
+          flimflam::kNameServersProperty, &dns_servers)) {
+    LOG(ERROR) << "Failed to get Name servers property for: " << service_path;
+    return;
+  }
+  listener_->UpdateNetworkServiceProperty(
+      service_path,
+      NetworkState::IPConfigProperty(flimflam::kNameServersProperty),
+      *dns_servers);
 }
 
 void ShillPropertyHandler::NetworkDevicePropertyChangedCallback(
     const std::string& path,
     const std::string& key,
     const base::Value& value) {
   listener_->UpdateDeviceProperty(path, key, value);
 }
 
 }  // namespace internal
 }  // namespace chromeos