Fix minor bugs found in NetworkConnectionHandler code

chromeos/network/network_connection_handler.cc

 // Copyright (c) 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/network_connection_handler.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 54 matching lines @@
 bool VPNIsConfigured(const std::string& service_path,
                      const base::DictionaryValue& service_properties) {
   const DictionaryValue* properties;
   if (!service_properties.GetDictionary(flimflam::kProviderProperty,
                                         &properties)) {
     NET_LOG_ERROR("VPN Provider Dictionary not present", service_path);
     return false;
   }
   std::string provider_type;
   // Note: we use Value path expansion to extract Provider.Type.
-  if (!properties->GetString(flimflam::kTypeProperty, &provider_type)) {
+  if (!properties->GetStringWithoutPathExpansion(
+          flimflam::kTypeProperty, &provider_type)) {
     NET_LOG_ERROR("VPN Provider Type not present", service_path);
     return false;
   }
   if (provider_type == flimflam::kProviderOpenVpn) {
     std::string hostname;
-    properties->GetString(flimflam::kHostProperty, &hostname);
+    properties->GetStringWithoutPathExpansion(
+        flimflam::kHostProperty, &hostname);
     if (hostname.empty()) {
       NET_LOG_EVENT("OpenVPN: No hostname", service_path);
       return false;
     }
     std::string username;
     properties->GetStringWithoutPathExpansion(
         flimflam::kOpenVPNUserProperty, &username);
     if (username.empty()) {
       NET_LOG_EVENT("OpenVPN: No username", service_path);
       return false;
@@ skipping 121 matching lines @@
   NET_LOG_EVENT("Certificates Loaded", "");
   if (queued_connect_) {
     NET_LOG_EVENT("Connecting to Queued Network",
                   queued_connect_->service_path);
     ConnectToNetwork(queued_connect_->service_path,
                      queued_connect_->success_callback,
                      queued_connect_->error_callback,
                      true /* ignore_error_state */);
   } else if (initial_load) {
     // Once certificates have loaded, connect to the "best" available network.
-    NetworkHandler::Get()->network_state_handler()->ConnectToBestWifiNetwork();
+    network_state_handler_->ConnectToBestWifiNetwork();
   }
 }
 
 void NetworkConnectionHandler::ConnectToNetwork(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback,
     bool ignore_error_state) {
   NET_LOG_USER("ConnectToNetwork", service_path);
   // Clear any existing queued connect request.
@@ skipping 158 matching lines @@
     // TODO(stevenjb): Remove this code once NetworkConfigurationHandler
     // handles this.
     NET_LOG_EVENT("Configuring Network", service_path);
     const std::string& tpm_slot = cert_loader_->tpm_token_slot();
     const std::string& tpm_pin = cert_loader_->tpm_user_pin();
     base::DictionaryValue config_properties;
     network->GetConfigProperties(&config_properties);
 
     if (network->type() == flimflam::kTypeVPN) {
       std::string provider_type;
-      properties.GetString(flimflam::kTypeProperty, &provider_type);
+      // Get 'Type' property from 'Provider' dictionary (use expansion).
+      properties.GetString(flimflam::kProviderTypeProperty, &provider_type);
       if (provider_type == flimflam::kProviderOpenVpn) {
         config_properties.SetStringWithoutPathExpansion(
             flimflam::kOpenVPNClientCertSlotProperty, tpm_slot);
         config_properties.SetStringWithoutPathExpansion(
             flimflam::kOpenVPNPinProperty, tpm_pin);
         config_properties.SetStringWithoutPathExpansion(
             flimflam::kOpenVPNClientCertIdProperty, pkcs11_id);
       } else {
         config_properties.SetStringWithoutPathExpansion(
             flimflam::kL2tpIpsecClientCertSlotProperty, tpm_slot);
@@ skipping 182 matching lines @@
     const network_handler::ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   std::string error =
       "Disconnect Failure: " + error_name + ": " + error_message;
   network_handler::ShillErrorCallbackFunction(
       service_path, error_callback, error_name, error_message);
 }
 
 }  // namespace chromeos