Eliminate c/b/chromeos/options/network_connect.cc

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/shell.h"
 #include "ash/system/chromeos/network/network_observer.h"
 #include "ash/system/chromeos/network/network_state_notifier.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_handler_callbacks.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
+#include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/resource/resource_bundle.h"
 
 using chromeos::DeviceState;
 using chromeos::NetworkConfigurationHandler;
 using chromeos::NetworkConnectionHandler;
 using chromeos::NetworkHandler;
 using chromeos::NetworkProfile;
 using chromeos::NetworkProfileHandler;
 using chromeos::NetworkState;
+using chromeos::NetworkStateHandler;
 
 namespace ash {
 
 namespace {
 
 // TODO(stevenjb): This should be in service_constants.h
 const char kErrorInProgress[] = "org.chromium.flimflam.Error.InProgress";
 
 // Returns true for carriers that can be activated through Shill instead of
 // through a WebUI dialog.
 bool IsDirectActivatedCarrier(const std::string& carrier) {
   if (carrier == shill::kCarrierSprint)
     return true;
   return false;
 }
 
 void ShowErrorNotification(const std::string& error,
                            const std::string& service_path) {
   Shell::GetInstance()->system_tray_notifier()->network_state_notifier()->
       ShowNetworkConnectError(error, service_path);
 }
 
 void OnConnectFailed(const std::string& service_path,
                      gfx::NativeWindow owning_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 == NetworkConnectionHandler::kErrorPassphraseRequired ||
       error_name == NetworkConnectionHandler::kErrorConfigurationRequired ||
       error_name == NetworkConnectionHandler::kErrorAuthenticationRequired) {
     ash::Shell::GetInstance()->system_tray_delegate()->ConfigureNetwork(
         service_path);
     return;
   }
 
   if (error_name == NetworkConnectionHandler::kErrorCertificateRequired) {
     ash::Shell::GetInstance()->system_tray_delegate()->EnrollOrConfigureNetwork(
         service_path, owning_window);
     return;
   }
 
   if (error_name == NetworkConnectionHandler::kErrorActivationRequired) {
     network_connect::ActivateCellular(service_path);
     return;
   }
 
   if (error_name == NetworkConnectionHandler::kErrorConnected ||
       error_name == NetworkConnectionHandler::kErrorConnecting) {
-    ash::Shell::GetInstance()->system_tray_delegate()->ShowNetworkSettings(
-        service_path);
+    network_connect::ShowNetworkSettings(service_path);
     return;
   }
 
   // ConnectFailed or unknown error; show a notification.
   ShowErrorNotification(error_name, service_path);
 
   // Show a configure dialog for ConnectFailed errors.
   if (error_name != NetworkConnectionHandler::kErrorConnectFailed)
     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;
 
   ash::Shell::GetInstance()->system_tray_delegate()->ConfigureNetwork(
       service_path);
 }
 
 void OnConnectSucceeded(const std::string& service_path) {
   NET_LOG_USER("Connect Succeeded", service_path);
+  if (!ash::Shell::HasInstance())
+    return;
   ash::Shell::GetInstance()->system_tray_notifier()->NotifyClearNetworkMessage(
       NetworkObserver::ERROR_CONNECT_FAILED);
 }
 
 // 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). |owning_window| will be used to parent
 // any configuration UI on failure and may be NULL (in which case the default
 // window will be used).
 void CallConnectToNetwork(const std::string& service_path,
                           bool check_error_state,
                           gfx::NativeWindow owning_window) {
-  NET_LOG_USER("ConnectToNetwork", service_path);
-
+  if (!ash::Shell::HasInstance())
+    return;
   ash::Shell::GetInstance()->system_tray_notifier()->NotifyClearNetworkMessage(
       NetworkObserver::ERROR_CONNECT_FAILED);
 
   NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork(
       service_path,
       base::Bind(&OnConnectSucceeded, service_path),
       base::Bind(&OnConnectFailed, service_path, owning_window),
       check_error_state);
 }
 
@@ skipping 102 matching lines @@
                  properties_to_clear),
       base::Bind(&SetPropertiesFailed, "SetProperties", service_path));
 }
 
 }  // namespace
 
 namespace network_connect {
 
 void ConnectToNetwork(const std::string& service_path,
                       gfx::NativeWindow owning_window) {
+  NET_LOG_USER("ConnectToNetwork", service_path);
   const bool check_error_state = true;
   CallConnectToNetwork(service_path, check_error_state, owning_window);
 }
 
 void ActivateCellular(const std::string& service_path) {
   NET_LOG_USER("ActivateCellular", service_path);
   const NetworkState* cellular =
       NetworkHandler::Get()->network_state_handler()->
       GetNetworkState(service_path);
   if (!cellular || cellular->type() != flimflam::kTypeCellular) {
     NET_LOG_ERROR("ActivateCellular with no Service", service_path);
     return;
   }
   const DeviceState* cellular_device =
       NetworkHandler::Get()->network_state_handler()->
       GetDeviceState(cellular->device_path());
   if (!cellular_device) {
     NET_LOG_ERROR("ActivateCellular with no Device", service_path);
     return;
   }
   if (!IsDirectActivatedCarrier(cellular_device->carrier())) {
     // For non direct activation, show the mobile setup dialog which can be
     // used to activate the network. Only show the dialog, if an account
     // management URL is available.
     if (!cellular->payment_url().empty())
-      ash::Shell::GetInstance()->system_tray_delegate()->ShowMobileSetup(
-          service_path);
+      ShowMobileSetup(service_path);
     return;
   }
   if (cellular->activation_state() == flimflam::kActivationStateActivated) {
     NET_LOG_ERROR("ActivateCellular for activated service", service_path);
     return;
   }
 
   NetworkHandler::Get()->network_connection_handler()->ActivateNetwork(
       service_path,
       "",  // carrier
       base::Bind(&OnActivateSucceeded, service_path),
       base::Bind(&OnActivateFailed, service_path));
 }
 
+void ShowMobileSetup(const std::string& service_path) {
+  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
+  const NetworkState* cellular = handler->GetNetworkState(service_path);
+  if (!cellular || cellular->type() != flimflam::kTypeCellular) {
+    NET_LOG_ERROR("ShowMobileSetup without Cellular network", service_path);
+    return;
+  }
+  if (cellular->activation_state() != flimflam::kActivationStateActivated &&
+      cellular->activate_over_non_cellular_networks() &&
+      !handler->DefaultNetwork()) {
+    std::string technology = cellular->network_technology();
+    ash::NetworkObserver::NetworkType network_type =
+        (technology == flimflam::kNetworkTechnologyLte ||
+         technology == flimflam::kNetworkTechnologyLteAdvanced)
+        ? ash::NetworkObserver::NETWORK_CELLULAR_LTE
+        : ash::NetworkObserver::NETWORK_CELLULAR;
+    ash::Shell::GetInstance()->system_tray_notifier()->NotifySetNetworkMessage(
+        NULL,
+        ash::NetworkObserver::ERROR_CONNECT_FAILED,
+        network_type,
+        l10n_util::GetStringUTF16(IDS_NETWORK_ACTIVATION_ERROR_TITLE),
+        l10n_util::GetStringFUTF16(IDS_NETWORK_ACTIVATION_NEEDS_CONNECTION,
+                                   UTF8ToUTF16((cellular->name()))),
+        std::vector<string16>());
+    return;
+  }
+  ash::Shell::GetInstance()->system_tray_delegate()->ShowMobileSetupDialog(
+      service_path);
+}
+
 void ConfigureNetworkAndConnect(const std::string& service_path,
                                 const base::DictionaryValue& properties,
                                 bool shared) {
   NET_LOG_USER("ConfigureNetworkAndConnect", service_path);
 
   scoped_ptr<base::DictionaryValue> properties_to_set(properties.DeepCopy());
 
   std::string profile_path;
   if (!GetNetworkProfilePath(shared, &profile_path)) {
     ShowErrorNotification(
@@ skipping 86 matching lines @@
   }
 
   if (StringToLowerASCII(error) ==
       StringToLowerASCII(std::string(flimflam::kUnknownString))) {
     return l10n_util::GetStringUTF16(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
   }
   return l10n_util::GetStringFUTF16(IDS_NETWORK_UNRECOGNIZED_ERROR,
                                     UTF8ToUTF16(error));
 }
 
+void ShowNetworkSettings(const std::string& service_path) {
+  if (!ash::Shell::HasInstance())
+    return;
+  ash::Shell::GetInstance()->system_tray_delegate()->ShowNetworkSettings(
+      service_path);
+}
+
 }  // network_connect
 }  // ash