Apply global auto connect ONC policy in GetManagedProperties.

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 131 matching lines @@
                                                   &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;
-  const base::DictionaryValue* shared_settings = NULL;
 
   if (ui_data && profile) {
-    if (profile->type() == NetworkProfile::TYPE_SHARED)
-      shared_settings = ui_data->user_settings();
-    else if (profile->type() == NetworkProfile::TYPE_USER)
-      user_settings = ui_data->user_settings();
-    else
-      NOTREACHED();
+    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.
   }
 
   scoped_ptr<base::DictionaryValue> active_settings(
       onc::TranslateShillServiceToONCPart(
           *shill_properties,
           &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 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;
     }
-    const base::DictionaryValue* policy =
-        GetByGUID(policies->per_network_config, guid);
-    if (profile->type() == NetworkProfile::TYPE_SHARED)
-      device_policy = policy;
-    else if (profile->type() == NetworkProfile::TYPE_USER)
-      user_policy = policy;
-    else
-      NOTREACHED();
+    if (!guid.empty())
+      network_policy = GetByGUID(policies->per_network_config, guid);
+    global_policy = &policies->global_network_config;
   }
 
-  // This call also removes credentials from policies.
-  scoped_ptr<base::DictionaryValue> augmented_properties =
-      onc::MergeSettingsAndPoliciesToAugmented(
-          onc::kNetworkConfigurationSignature,
-          user_policy,
-          device_policy,
-          user_settings,
-          shared_settings,
-          active_settings.get());
+  scoped_ptr<base::DictionaryValue> augmented_properties(
+      policy_util::CreateManagedONC(global_policy,
+                                    network_policy,
+                                    user_settings,
+                                    active_settings.get(),
+                                    profile));
   callback.Run(service_path, *augmented_properties);
 }
 
 // GetProperties
 
 void ManagedNetworkConfigurationHandlerImpl::GetProperties(
     const std::string& service_path,
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) {
   network_configuration_handler_->GetProperties(
@@ skipping 75 matching lines @@
           user_settings,
           &validation_result);
 
   if (validation_result == onc::Validator::INVALID) {
     InvokeErrorCallback(service_path, error_callback, kInvalidUserSettings);
     return;
   }
   if (validation_result == onc::Validator::VALID_WITH_WARNINGS)
     LOG(WARNING) << "Validation of ONC user settings produced warnings.";
 
-  const base::DictionaryValue* policy =
+  const base::DictionaryValue* network_policy =
       GetByGUID(policies->per_network_config, guid);
-  VLOG(2) << "This configuration is " << (policy ? "" : "not ") << "managed.";
+  VLOG(2) << "This configuration is " << (network_policy ? "" : "not ")
+          << "managed.";
 
   scoped_ptr<base::DictionaryValue> shill_dictionary(
-      policy_util::CreateShillConfiguration(
-          *profile, guid, policy, validated_user_settings.get()));
+      policy_util::CreateShillConfiguration(*profile,
+                                            guid,
+                                            &policies->global_network_config,
+                                            network_policy,
+                                            validated_user_settings.get()));
 
   network_configuration_handler_->SetProperties(
       service_path, *shill_dictionary, callback, error_callback);
 }
 
 void ManagedNetworkConfigurationHandlerImpl::CreateConfiguration(
     const std::string& userhash,
     const base::DictionaryValue& properties,
     const network_handler::StringResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) const {
@@ skipping 17 matching lines @@
   }
 
   // TODO(pneubeck): In case of WiFi, check that no other configuration for the
   // same {SSID, mode, security} exists. We don't support such multiple
   // configurations, yet.
 
   // Generate a new GUID for this configuration. Ignore the maybe provided GUID
   // in |properties| as it is not our own and from an untrusted source.
   std::string guid = base::GenerateGUID();
   scoped_ptr<base::DictionaryValue> shill_dictionary(
-      policy_util::CreateShillConfiguration(
-          *profile, guid, NULL /*no policy*/, &properties));
+      policy_util::CreateShillConfiguration(*profile,
+                                            guid,
+                                            NULL,  // no global policy
+                                            NULL,  // no network policy
+                                            &properties));
 
   network_configuration_handler_->CreateConfiguration(
       *shill_dictionary, callback, error_callback);
 }
 
 void ManagedNetworkConfigurationHandlerImpl::RemoveConfiguration(
     const std::string& service_path,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) const {
   network_configuration_handler_->RemoveConfiguration(
@@ skipping 361 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