Use GUID instead of servicePath in network settings

ui/chromeos/network/network_connect.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 "ui/chromeos/network/network_connect.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 58 matching lines @@
   void ShowMobileSetup(const std::string& service_path) override;
   void ConfigureNetworkAndConnect(const std::string& service_path,
                                   const base::DictionaryValue& shill_properties,
                                   bool shared) override;
   void CreateConfigurationAndConnect(base::DictionaryValue* shill_properties,
                                      bool shared) override;
   void CreateConfiguration(base::DictionaryValue* shill_properties,
                            bool shared) override;
   base::string16 GetShillErrorString(const std::string& error,
                                      const std::string& service_path) override;
-  void ShowNetworkSettings(const std::string& service_path) override;
+  void ShowNetworkSettingsForPath(const std::string& service_path) override;
 
  private:
   void HandleUnconfiguredNetwork(const std::string& service_path);
   void OnConnectFailed(const std::string& service_path,
                        const std::string& error_name,
                        scoped_ptr<base::DictionaryValue> error_data);
   bool GetNetworkProfilePath(bool shared, std::string* profile_path);
   void OnConnectSucceeded(const std::string& service_path);
   void CallConnectToNetwork(const std::string& service_path,
                             bool check_error_state);
@@ skipping 62 matching lines @@
     if (network->RequiresActivation()) {
       ActivateCellular(service_path);
       return;
     }
     if (network->cellular_out_of_credits()) {
       ShowMobileSetup(service_path);
       return;
     }
     // No special configure or setup for |network|, show the settings UI.
     if (chromeos::LoginState::Get()->IsUserLoggedIn()) {
-      delegate_->ShowNetworkSettings(service_path);
+      ShowNetworkSettingsForPath(service_path);
     }
     return;
   }
   NOTREACHED();
 }
 
 // If |shared| is true, sets |profile_path| to the shared profile path.
 // Otherwise sets |profile_path| to the user profile path if authenticated and
 // available. Returns 'false' if unable to set |profile_path|.
 bool NetworkConnectImpl::GetNetworkProfilePath(bool shared,
@@ skipping 31 matching lines @@
   // If a new connect attempt canceled this connect, or a connect attempt to
   // the same network is in progress, no need to notify the user here since they
   // will be notified when the new or existing attempt completes.
   if (error_name == NetworkConnectionHandler::kErrorConnectCanceled ||
       error_name == NetworkConnectionHandler::kErrorConnecting) {
     return;
   }
 
   // Already connected to the network, show the settings UI for the network.
   if (error_name == NetworkConnectionHandler::kErrorConnected) {
-    ShowNetworkSettings(service_path);
+    ShowNetworkSettingsForPath(service_path);
     return;
   }
 
   if (error_name == NetworkConnectionHandler::kErrorBadPassphrase ||
       error_name == NetworkConnectionHandler::kErrorPassphraseRequired ||
       error_name == NetworkConnectionHandler::kErrorConfigurationRequired ||
       error_name == NetworkConnectionHandler::kErrorAuthenticationRequired) {
     HandleUnconfiguredNetwork(service_path);
     return;
   }
@@ skipping 376 matching lines @@
   }
 
   if (base::StringToLowerASCII(error) ==
       base::StringToLowerASCII(std::string(shill::kUnknownString))) {
     return l10n_util::GetStringUTF16(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
   }
   return l10n_util::GetStringFUTF16(IDS_NETWORK_UNRECOGNIZED_ERROR,
                                     base::UTF8ToUTF16(error));
 }
 
-void NetworkConnectImpl::ShowNetworkSettings(const std::string& service_path) {
-  delegate_->ShowNetworkSettings(service_path);
+void NetworkConnectImpl::ShowNetworkSettingsForPath(
+    const std::string& service_path) {
+  const NetworkState* network = GetNetworkState(service_path);
+  delegate_->ShowNetworkSettingsForGuid(network ? network->guid() : "");
 }
 
 }  // namespace
 
 const char NetworkConnect::kErrorActivateFailed[] = "activate-failed";
 
 static NetworkConnect* g_network_connect = NULL;
 
 // static
 void NetworkConnect::Initialize(Delegate* delegate) {
@@ skipping 14 matching lines @@
   return g_network_connect;
 }
 
 NetworkConnect::NetworkConnect() {
 }
 
 NetworkConnect::~NetworkConnect() {
 }
 
 }  // namespace ui