Add ONC 'Source' configuration property

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"
@@ skipping 109 matching lines @@
     return;
   }
   network_configuration_handler_->GetProperties(
       service_path,
       base::Bind(
           &ManagedNetworkConfigurationHandlerImpl::GetPropertiesCallback,
           weak_ptr_factory_.GetWeakPtr(),
           base::Bind(
               &ManagedNetworkConfigurationHandlerImpl::SendManagedProperties,
               weak_ptr_factory_.GetWeakPtr(),
+              userhash,
               callback,
               error_callback)),
       error_callback);
 }
 
 void ManagedNetworkConfigurationHandlerImpl::SendManagedProperties(
+    const std::string& userhash,
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback,
     const std::string& service_path,
     scoped_ptr<base::DictionaryValue> shill_properties) {
   std::string profile_path;
   shill_properties->GetStringWithoutPathExpansion(shill::kProfileProperty,
                                                   &profile_path);
   const NetworkProfile* profile =
       network_profile_handler_->GetProfileForPath(profile_path);
   if (!profile)
     NET_LOG_ERROR("No profile for service: " + profile_path, service_path);
 
   scoped_ptr<NetworkUIData> ui_data =
       shill_property_util::GetUIDataFromProperties(*shill_properties);
 
   const base::DictionaryValue* user_settings = NULL;
 
   if (ui_data && profile) {
     user_settings = ui_data->user_settings();
   } 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.
   }
 
+  std::string guid;
+  shill_properties->GetStringWithoutPathExpansion(shill::kGuidProperty, &guid);
+
+  ::onc::ONCSource onc_source;
+  FindPolicyByGUID(userhash, guid, &onc_source);
   scoped_ptr<base::DictionaryValue> active_settings(
       onc::TranslateShillServiceToONCPart(
-          *shill_properties,
-          &onc::kNetworkWithStateSignature));
-
-  std::string guid;
-  active_settings->GetStringWithoutPathExpansion(::onc::network_config::kGUID,
-                                                 &guid);
+          *shill_properties, onc_source, &onc::kNetworkWithStateSignature));
 
   const base::DictionaryValue* network_policy = NULL;
   const base::DictionaryValue* global_policy = NULL;
   if (profile) {
     const Policies* policies = GetPoliciesForProfile(*profile);
     if (!policies) {
       InvokeErrorCallback(
           service_path, error_callback, kPoliciesNotInitialized);
       return;
     }
@@ skipping 28 matching lines @@
                      error_callback)),
       error_callback);
 }
 
 void ManagedNetworkConfigurationHandlerImpl::SendProperties(
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback,
     const std::string& service_path,
     scoped_ptr<base::DictionaryValue> shill_properties) {
   scoped_ptr<base::DictionaryValue> onc_network(
-      onc::TranslateShillServiceToONCPart(*shill_properties,
-                                          &onc::kNetworkWithStateSignature));
+      onc::TranslateShillServiceToONCPart(
+          *shill_properties, ::onc::ONC_SOURCE_UNKNOWN,
+          &onc::kNetworkWithStateSignature));
   callback.Run(service_path, *onc_network);
 }
 
 // SetProperties
 
 void ManagedNetworkConfigurationHandlerImpl::SetProperties(
     const std::string& service_path,
     const base::DictionaryValue& user_settings,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) const {
@@ skipping 480 matching lines @@
     scoped_ptr<base::DictionaryValue> network_properties,
     GetDevicePropertiesCallback send_callback,
     const std::string& error_name,
     scoped_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Error getting device properties", service_path);
   send_callback.Run(service_path, network_properties.Pass());
 }
 
 
 }  // namespace chromeos