Elim parent_window parameter from network_connect

ash/system/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 "ash/system/chromeos/network/network_connect.h"
 
 #include "ash/session/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/system/chromeos/network/network_state_notifier.h"
 #include "ash/system/system_notifier.h"
@@ skipping 47 matching lines @@
     return true;
   return false;
 }
 
 void ShowErrorNotification(const std::string& error_name,
                            const std::string& service_path) {
   Shell::GetInstance()->system_tray_notifier()->network_state_notifier()->
       ShowNetworkConnectError(error_name, service_path);
 }
 
-void HandleUnconfiguredNetwork(const std::string& service_path,
-                               gfx::NativeWindow parent_window) {
+void HandleUnconfiguredNetwork(const std::string& service_path) {
   const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
       GetNetworkState(service_path);
   if (!network) {
     NET_LOG_ERROR("Configuring unknown network", service_path);
     return;
   }
 
   if (network->type() == shill::kTypeWifi) {
     // Only show the config view for secure networks, otherwise do nothing.
     if (network->security() != shill::kSecurityNone) {
       ash::Shell::GetInstance()->system_tray_delegate()->
-          ShowNetworkConfigure(service_path, parent_window);
+          ShowNetworkConfigure(service_path);
     }
     return;
   }
 
   if (network->type() == shill::kTypeWimax ||
       network->type() == shill::kTypeVPN) {
     ash::Shell::GetInstance()->system_tray_delegate()->
-        ShowNetworkConfigure(service_path, parent_window);
+        ShowNetworkConfigure(service_path);
     return;
   }
 
   if (network->type() == shill::kTypeCellular) {
     if (network->RequiresActivation()) {
       ash::network_connect::ActivateCellular(service_path);
       return;
     }
     if (network->cellular_out_of_credits()) {
       ash::network_connect::ShowMobileSetup(service_path);
@@ skipping 29 matching lines @@
   if (!profile) {
     NET_LOG_ERROR("No user profile for unshared network configuration", "");
     return false;
   }
 
   *profile_path = profile->path;
   return true;
 }
 
 void OnConnectFailed(const std::string& service_path,
-                     gfx::NativeWindow parent_window,
                      const std::string& error_name,
                      scoped_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Connect Failed: " + error_name, service_path);
 
   if (!ash::Shell::HasInstance())
     return;
 
   // If a new connect attempt canceled this connect, no need to notify the user.
   if (error_name == NetworkConnectionHandler::kErrorConnectCanceled)
     return;
 
   if (error_name == shill::kErrorBadPassphrase ||
       error_name == NetworkConnectionHandler::kErrorPassphraseRequired ||
       error_name == NetworkConnectionHandler::kErrorConfigurationRequired ||
       error_name == NetworkConnectionHandler::kErrorAuthenticationRequired) {
-    HandleUnconfiguredNetwork(service_path, parent_window);
+    HandleUnconfiguredNetwork(service_path);
     return;
   }
 
   if (error_name == NetworkConnectionHandler::kErrorCertificateRequired) {
     if (!ash::Shell::GetInstance()->system_tray_delegate()->EnrollNetwork(
-            service_path, parent_window)) {
-      HandleUnconfiguredNetwork(service_path, parent_window);
+            service_path)) {
+      HandleUnconfiguredNetwork(service_path);
     }
     return;
   }
 
   if (error_name == NetworkConnectionHandler::kErrorActivationRequired) {
     network_connect::ActivateCellular(service_path);
     return;
   }
 
   if (error_name == NetworkConnectionHandler::kErrorConnected ||
@@ skipping 11 matching lines @@
       Shell::GetInstance()->session_state_delegate()->IsScreenLocked())
     return;
 
   // If Shill reports an InProgress error, don't try to configure the network.
   std::string dbus_error_name;
   error_data.get()->GetString(
       chromeos::network_handler::kDbusErrorName, &dbus_error_name);
   if (dbus_error_name == kErrorInProgress)
     return;
 
-  HandleUnconfiguredNetwork(service_path, parent_window);
+  HandleUnconfiguredNetwork(service_path);
 }
 
 void OnConnectSucceeded(const std::string& service_path) {
   NET_LOG_USER("Connect Succeeded", service_path);
   if (!ash::Shell::HasInstance())
     return;
   message_center::MessageCenter::Get()->RemoveNotification(
       network_connect::kNetworkConnectNotificationId, false /* not by user */);
 }
 
 // If |check_error_state| is true, error state for the network is checked,
 // otherwise any current error state is ignored (e.g. for recently configured
-// networks or repeat connect attempts). |parent_window| will be used to parent
-// any configuration UI on failure and may be NULL (in which case the default
-// window will be used).
+// networks or repeat connect attempts).
 void CallConnectToNetwork(const std::string& service_path,
-                          bool check_error_state,
-                          gfx::NativeWindow parent_window) {
+                          bool check_error_state) {
   if (!ash::Shell::HasInstance())
     return;
   message_center::MessageCenter::Get()->RemoveNotification(
       network_connect::kNetworkConnectNotificationId, false /* not by user */);
 
   NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork(
       service_path,
       base::Bind(&OnConnectSucceeded, service_path),
-      base::Bind(&OnConnectFailed, service_path, parent_window),
+      base::Bind(&OnConnectFailed, service_path),
       check_error_state);
 }
 
 void OnActivateFailed(const std::string& service_path,
                       const std::string& error_name,
                       scoped_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Unable to activate network", service_path);
   ShowErrorNotification(network_connect::kErrorActivateFailed, service_path);
 }
 
 void OnActivateSucceeded(const std::string& service_path) {
   NET_LOG_USER("Activation Succeeded", service_path);
 }
 
 void OnConfigureFailed(const std::string& error_name,
                        scoped_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Unable to configure network", "");
   ShowErrorNotification(NetworkConnectionHandler::kErrorConfigureFailed, "");
 }
 
 void OnConfigureSucceeded(bool connect_on_configure,
                           const std::string& service_path) {
   NET_LOG_USER("Configure Succeeded", service_path);
   if (!connect_on_configure)
     return;
   // After configuring a network, ignore any (possibly stale) error state.
   const bool check_error_state = false;
-  const gfx::NativeWindow parent_window = NULL;
-  CallConnectToNetwork(service_path, check_error_state, parent_window);
+  CallConnectToNetwork(service_path, check_error_state);
 }
 
 void CallCreateConfiguration(base::DictionaryValue* properties,
                              bool shared,
                              bool connect_on_configure) {
   std::string profile_path;
   if (!GetNetworkProfilePath(shared, &profile_path)) {
     ShowErrorNotification(NetworkConnectionHandler::kErrorConfigureFailed, "");
     return;
   }
@@ skipping 29 matching lines @@
     properties_to_set->RemoveWithoutPathExpansion(*iter, NULL);
   }
 }
 
 void ClearPropertiesAndConnect(
     const std::string& service_path,
     const std::vector<std::string>& properties_to_clear) {
   NET_LOG_USER("ClearPropertiesAndConnect", service_path);
   // After configuring a network, ignore any (possibly stale) error state.
   const bool check_error_state = false;
-  const gfx::NativeWindow parent_window = NULL;
   NetworkHandler::Get()->network_configuration_handler()->ClearProperties(
       service_path,
       properties_to_clear,
       base::Bind(&CallConnectToNetwork,
-                 service_path, check_error_state,
-                 parent_window),
+                 service_path, check_error_state),
       base::Bind(&SetPropertiesFailed, "ClearProperties", service_path));
 }
 
 void ConfigureSetProfileSucceeded(
     const std::string& service_path,
     scoped_ptr<base::DictionaryValue> properties_to_set) {
   std::vector<std::string> properties_to_clear;
   SetPropertiesToClear(properties_to_set.get(), &properties_to_clear);
   NetworkHandler::Get()->network_configuration_handler()->SetProperties(
       service_path,
@@ skipping 13 matching lines @@
 
 namespace network_connect {
 
 const char kNetworkConnectNotificationId[] =
     "chrome://settings/internet/connect";
 const char kNetworkActivateNotificationId[] =
     "chrome://settings/internet/activate";
 
 const char kErrorActivateFailed[] = "activate-failed";
 
-void ConnectToNetwork(const std::string& service_path,
-                      gfx::NativeWindow parent_window) {
+void ConnectToNetwork(const std::string& service_path) {
   NET_LOG_USER("ConnectToNetwork", service_path);
   const NetworkState* network = GetNetworkState(service_path);
   if (network) {
     if (!network->error().empty() && !network->security().empty()) {
       NET_LOG_USER("Configure: " + network->error(), service_path);
       // If the network is in an error state, show the configuration UI directly
       // to avoid a spurious notification.
-      HandleUnconfiguredNetwork(service_path, parent_window);
+      HandleUnconfiguredNetwork(service_path);
       return;
     } else if (network->RequiresActivation()) {
       ActivateCellular(service_path);
       return;
     }
   }
   const bool check_error_state = true;
-  CallConnectToNetwork(service_path, check_error_state, parent_window);
+  CallConnectToNetwork(service_path, check_error_state);
 }
 
 void SetTechnologyEnabled(const NetworkTypePattern& technology,
                           bool enabled_state) {
   std::string log_string =
       base::StringPrintf("technology %s, target state: %s",
                          technology.ToDebugString().c_str(),
                          (enabled_state ? "ENABLED" : "DISABLED"));
   NET_LOG_USER("SetTechnologyEnabled", log_string);
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
@@ skipping 215 matching lines @@
 
 void ShowNetworkSettings(const std::string& service_path) {
   if (!ash::Shell::HasInstance())
     return;
   ash::Shell::GetInstance()->system_tray_delegate()->ShowNetworkSettings(
       service_path);
 }
 
 }  // network_connect
 }  // ash