[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 29 matching lines @@
 }
 
 const base::DictionaryValue* GetByGUID(const GuidToPolicyMap& policies,
                                        const std::string& guid) {
   auto it = policies.find(guid);
   if (it == policies.end())
     return NULL;
   return it->second.get();
 }
 
+bool IsTetherShillDictionary(const base::DictionaryValue& dict) {
+  std::string network_type;
+  return dict.GetStringWithoutPathExpansion(shill::kTypeProperty,
+                                            &network_type) &&
+         network_type == kTypeTether;
+}
+
 }  // namespace
 
 struct ManagedNetworkConfigurationHandlerImpl::Policies {
   ~Policies();
 
   GuidToPolicyMap per_network_config;
   base::DictionaryValue global_network_config;
 };
 
 ManagedNetworkConfigurationHandlerImpl::Policies::~Policies() {}
@@ skipping 36 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 && !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;
+  const base::DictionaryValue* user_settings = nullptr;
 
   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;
+  const base::DictionaryValue* network_policy = nullptr;
+  const base::DictionaryValue* global_policy = nullptr;
   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;
@@ skipping 719 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