Provide IPConfigs in networkingPrivate.GetProperties

chromeos/network/managed_network_configuration_handler_impl.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/network/managed_network_configuration_handler_impl.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
+#include "chromeos/network/device_state.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_policy_observer.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/onc/onc_merger.h"
 #include "chromeos/network/onc/onc_signature.h"
@@ skipping 45 matching lines @@
 }
 
 const base::DictionaryValue* GetByGUID(const GuidToPolicyMap& policies,
                                        const std::string& guid) {
   GuidToPolicyMap::const_iterator it = policies.find(guid);
   if (it == policies.end())
     return NULL;
   return it->second;
 }
 
-void TranslatePropertiesToOncAndRunCallback(
-    const network_handler::DictionaryResultCallback& callback,
-    const std::string& service_path,
-    const base::DictionaryValue& shill_properties) {
-  scoped_ptr<base::DictionaryValue> onc_network(
-      onc::TranslateShillServiceToONCPart(
-          shill_properties,
-          &onc::kNetworkWithStateSignature));
-  callback.Run(service_path, *onc_network);
-}
-
 }  // namespace
 
 struct ManagedNetworkConfigurationHandlerImpl::Policies {
   ~Policies();
 
   GuidToPolicyMap per_network_config;
   base::DictionaryValue global_network_config;
 };
 
 ManagedNetworkConfigurationHandlerImpl::Policies::~Policies() {
@@ skipping 55 matching lines @@
       user_settings = ui_data->user_settings();
     else
       NOTREACHED();
   } else if (profile) {
     NET_LOG_ERROR("Service contains empty or invalid UIData", service_path);
     // TODO(pneubeck): add a conversion of user configured entries of old
     // ChromeOS versions. We will have to use a heuristic to determine which
     // properties _might_ be user configured.
   }
 
+  scoped_ptr<base::DictionaryValue> properties_copy(
+      shill_properties.DeepCopy());
+  // Add the IPConfigs to the dictionary before the ONC translation.
+  GetIPConfigs(service_path, properties_copy.get());
+
   scoped_ptr<base::DictionaryValue> active_settings(
       onc::TranslateShillServiceToONCPart(
-          shill_properties,
+          *properties_copy,
           &onc::kNetworkWithStateSignature));
 
   std::string guid;
   active_settings->GetStringWithoutPathExpansion(::onc::network_config::kGUID,
                                                  &guid);
 
   const base::DictionaryValue* user_policy = NULL;
   const base::DictionaryValue* device_policy = NULL;
   if (!guid.empty() && profile) {
     const Policies* policies = GetPoliciesForProfile(*profile);
@@ skipping 20 matching lines @@
           device_policy,
           user_settings,
           shared_settings,
           active_settings.get());
   callback.Run(service_path, *augmented_properties);
 }
 
 void ManagedNetworkConfigurationHandlerImpl::GetProperties(
     const std::string& service_path,
     const network_handler::DictionaryResultCallback& callback,
-    const network_handler::ErrorCallback& error_callback) const {
+    const network_handler::ErrorCallback& error_callback) {
   network_configuration_handler_->GetProperties(
       service_path,
-      base::Bind(&TranslatePropertiesToOncAndRunCallback, callback),
+      base::Bind(&ManagedNetworkConfigurationHandlerImpl::GetPropertiesCallback,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 callback),
       error_callback);
 }
 
+void ManagedNetworkConfigurationHandlerImpl::GetPropertiesCallback(
+    const network_handler::DictionaryResultCallback& callback,
+    const std::string& service_path,
+    const base::DictionaryValue& shill_properties) {
+  scoped_ptr<base::DictionaryValue> properties_copy(
+      shill_properties.DeepCopy());
+  // Add the IPConfigs to the dictionary before the ONC translation.
+  GetIPConfigs(service_path, properties_copy.get());
+
+  scoped_ptr<base::DictionaryValue> onc_network(
+      onc::TranslateShillServiceToONCPart(
+          *properties_copy,
+          &onc::kNetworkWithStateSignature));
+  callback.Run(service_path, *onc_network);
+}
+
 void ManagedNetworkConfigurationHandlerImpl::SetProperties(
     const std::string& service_path,
     const base::DictionaryValue& user_settings,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) const {
   const NetworkState* state =
       network_state_handler_->GetNetworkState(service_path);
 
   if (!state) {
     InvokeErrorCallback(service_path, error_callback, kUnknownServicePath);
@@ skipping 357 matching lines @@
 }
 
 void ManagedNetworkConfigurationHandlerImpl::OnPolicyAppliedToNetwork(
     const std::string& service_path) {
   if (service_path.empty())
     return;
   FOR_EACH_OBSERVER(
       NetworkPolicyObserver, observers_, PolicyApplied(service_path));
 }
 
+void ManagedNetworkConfigurationHandlerImpl::GetIPConfigs(
+    const std::string& service_path,
+    base::DictionaryValue* properties) {
+  std::string connection_state;
+  properties->GetStringWithoutPathExpansion(
+      shill::kStateProperty, &connection_state);
+  if (!NetworkState::StateIsConnected(connection_state))
+    return;
+
+  // Get the IPConfig properties from the device and store them in "IPConfigs"
+  // (plural) in the properties dictionary. (Note: Shill only provides a single
+  // "IPConfig" property for a network service, but a consumer of this API may
+  // want information about all ipv4 and ipv6 IPConfig properties.
+  std::string device;
+  properties->GetStringWithoutPathExpansion(shill::kDeviceProperty, &device);
+  const DeviceState* device_state =
+      network_state_handler_->GetDeviceState(device);
+  if (!device_state) {
+    NET_LOG_ERROR("GetIPConfigs: no device: " + device, service_path);
+    return;
+  }
+  // Convert IPConfig dictionary to a ListValue.
+  base::ListValue* ip_configs = new base::ListValue;
+  for (base::DictionaryValue::Iterator iter(device_state->ip_configs());
+       !iter.IsAtEnd(); iter.Advance()) {
+    ip_configs->Append(iter.value().DeepCopy());
+  }
+  properties->SetWithoutPathExpansion(shill::kIPConfigsProperty, ip_configs);
+}
+
 }  // namespace chromeos