[CrOS Tether] Update NetworkConfigurationHandler::GetShillProperties() to work with Tether networks.

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 <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 20 matching lines @@
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_merger.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/onc/onc_validator.h"
 #include "chromeos/network/policy_util.h"
 #include "chromeos/network/prohibited_technologies_handler.h"
 #include "chromeos/network/shill_property_util.h"
+#include "chromeos/network/tether_constants.h"
 #include "components/onc/onc_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 using GuidToPolicyMap = ManagedNetworkConfigurationHandler::GuidToPolicyMap;
 
 // These are error strings used for error callbacks. None of these error
@@ skipping 85 matching lines @@
     const std::string& userhash,
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback,
     const std::string& service_path,
     std::unique_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)
+  if (!profile && !onc::IsTetherShillDictionary(*shill_properties)) {
+    // Tether networks are not expected to have an associated profile; only
+    // log an error if the provided properties do not correspond to a
+    // Tether network.
     NET_LOG_ERROR("No profile for service: " + profile_path, service_path);
+  }
 
   std::unique_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_DEBUG("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);
   const NetworkState* network_state =
       network_state_handler_->GetNetworkState(service_path);
   std::unique_ptr<base::DictionaryValue> active_settings(
       onc::TranslateShillServiceToONCPart(*shill_properties, onc_source,
                                           &onc::kNetworkWithStateSignature,
                                           network_state));
 
-  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;
     }
-    if (!guid.empty())
-      network_policy = GetByGUID(policies->per_network_config, guid);
-    global_policy = &policies->global_network_config;
+
+    const base::DictionaryValue* network_policy =
+        guid.empty() ? nullptr : GetByGUID(policies->per_network_config, guid);
+    const base::DictionaryValue* global_policy =
+        &policies->global_network_config;
+
+    std::unique_ptr<base::DictionaryValue> augmented_properties(
+        policy_util::CreateManagedONC(global_policy, network_policy,
+                                      user_settings, active_settings.get(),
+                                      profile));
+    callback.Run(service_path, *augmented_properties);
+  } else {
+    callback.Run(service_path, *active_settings);
   }
-
-  std::unique_ptr<base::DictionaryValue> augmented_properties(
-      policy_util::CreateManagedONC(global_policy, network_policy,
-                                    user_settings, active_settings.get(),
-                                    profile));

[stevenjb, 2017/04/24 17:15:52]

This always needs to be called, even if profile is null.

[Kyle Horimoto, 2017/04/24 19:49:38]

Done.

-  callback.Run(service_path, *augmented_properties);
 }
 
 // GetProperties
 
 void ManagedNetworkConfigurationHandlerImpl::GetProperties(
     const std::string& userhash,
     const std::string& service_path,
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) {
   NET_LOG_USER("GetProperties", service_path);
@@ skipping 702 matching lines @@
     std::unique_ptr<base::DictionaryValue> network_properties,
     GetDevicePropertiesCallback send_callback,
     const std::string& error_name,
     std::unique_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Error getting device properties", service_path);
   send_callback.Run(service_path, std::move(network_properties));
 }
 
 
 }  // namespace chromeos