chromeos: Refactor some network related code in preparation for the uber tray.

chrome/browser/chromeos/status/network_menu.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/status/network_menu.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 69 matching lines @@
       views::View* item = submenu->child_at(i);
       if (item->id() == views::MenuItemView::kMenuItemViewID) {
         views::MenuItemView* menu_item =
             static_cast<views::MenuItemView*>(item);
         SetMenuMargins(menu_item, top, bottom);
       }
     }
   }
 }
 
+// Activate a cellular network.
+void ActivateCellular(const chromeos::CellularNetwork* cellular) {
+  DCHECK(cellular);
+  Browser* browser = BrowserList::GetLastActive();
+  if (!browser)
+    return;
+  browser->OpenMobilePlanTabAndActivate();
+}
+
 }  // namespace
 
 namespace chromeos {
 
 class NetworkMenuModel : public ui::MenuModel {
  public:
   struct MenuItem {
     MenuItem()
         : type(ui::MenuModel::TYPE_SEPARATOR),
           sub_menu_model(NULL),
@@ skipping 95 matching lines @@
   // Top up URL of the current carrier on empty string if there's none.
   std::string top_up_url_;
 
   // Carrier ID which top up URL is initialized for.
   // Used to update top up URL only when cellular carrier has changed.
   std::string carrier_id_;
 
  private:
   // Show a NetworkConfigView modal dialog instance.
   void ShowNetworkConfigView(NetworkConfigView* view) const;
-  // Activate a cellular network.
-  void ActivateCellular(const CellularNetwork* cellular) const;
   // Open a dialog to set up and connect to a network.
   void ShowOther(ConnectionType type) const;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkMenuModel);
 };
 
-
 class MoreMenuModel : public NetworkMenuModel {
  public:
   explicit MoreMenuModel(const base::WeakPtr<NetworkMenu> owner)
     : NetworkMenuModel(owner) {}
   virtual ~MoreMenuModel() {}
 
   // NetworkMenuModel implementation.
   virtual void InitMenuItems(bool should_open_button_options) OVERRIDE;
 
   // ui::MenuModel implementation
@@ skipping 50 matching lines @@
                                           int auto_connect) const {
   int flags = menu_items_[index].flags;
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   const std::string& service_path = menu_items_[index].service_path;
   if (flags & FLAG_WIFI) {
     WifiNetwork* wifi = cros->FindWifiNetworkByPath(service_path);
     if (wifi) {
       // Connect or reconnect.
       if (auto_connect >= 0)
         wifi->SetAutoConnect(auto_connect ? true : false);
-      if (wifi->connecting_or_connected()) {
-        // Show the config settings for the active network.
-        owner_->ShowTabbedNetworkSettings(wifi);
-      } else {
-        wifi->AttemptConnection(base::Bind(&NetworkMenu::DoConnect,
-                                           owner_,
-                                           wifi));
-      }
+      owner_->ConnectToNetwork(wifi);
     } else {
       // If we are attempting to connect to a network that no longer exists,
       // display a notification.
       LOG(WARNING) << "Wi-fi network does not exist to connect to: "
                    << service_path;
       // TODO(stevenjb): Show notification.
     }
   } else if (flags & FLAG_CELLULAR) {
     CellularNetwork* cellular = cros->FindCellularNetworkByPath(
         service_path);
     if (cellular) {
-      if ((cellular->activation_state() != ACTIVATION_STATE_ACTIVATED &&
-           cellular->activation_state() != ACTIVATION_STATE_UNKNOWN) ||
-          cellular->needs_new_plan()) {
-        ActivateCellular(cellular);
-      } else if (cellular->connecting_or_connected()) {
-        // Cellular network is connecting or connected,
-        // so we show the config settings for the cellular network.
-        owner_->ShowTabbedNetworkSettings(cellular);
-      } else {
-        // Clicked on a disconnected cellular network, so connect to it.
-        cros->ConnectToCellularNetwork(cellular);
-      }
+      owner_->ConnectToNetwork(cellular);
     } else {
       // If we are attempting to connect to a network that no longer exists,
       // display a notification.
       LOG(WARNING) << "Cellular network does not exist to connect to: "
                    << service_path;
       // TODO(stevenjb): Show notification.
     }
   } else if (flags & FLAG_ADD_WIFI) {
     ShowOther(TYPE_WIFI);
   } else if (flags & FLAG_ADD_CELLULAR) {
     ShowOther(TYPE_CELLULAR);
   } else if (flags & FLAG_ADD_VPN) {
     ShowOther(TYPE_VPN);
   } else if (flags & FLAG_VPN) {
     VirtualNetwork* vpn = cros->FindVirtualNetworkByPath(service_path);
     if (vpn) {
-      // Connect or reconnect.
-      if (vpn->connecting_or_connected()) {
-        // Show the config settings for the connected network.
-        if (cros->connected_network())
-          owner_->ShowTabbedNetworkSettings(cros->connected_network());
-      } else {
-        vpn->AttemptConnection(base::Bind(&NetworkMenu::DoConnect,
-                                          owner_,
-                                          vpn));
-      }
+      owner_->ConnectToNetwork(vpn);
     } else {
       // If we are attempting to connect to a network that no longer exists,
       // display a notification.
       LOG(WARNING) << "VPN does not exist to connect to: " << service_path;
       // TODO(stevenjb): Show notification.
     }
   }
 }
 
+void NetworkMenu::ConnectToNetwork(Network* network) {
+  NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
+  switch (network->type()) {
+    case TYPE_ETHERNET: {
+      ShowTabbedNetworkSettings(network);
+      break;
+    }
+    case TYPE_WIFI: {
+      WifiNetwork* wifi = static_cast<WifiNetwork*>(network);
+      if (wifi->connecting_or_connected()) {
+        ShowTabbedNetworkSettings(wifi);
+      } else {
+        wifi->AttemptConnection(base::Bind(&NetworkMenu::DoConnect,
+                                           weak_pointer_factory_.GetWeakPtr(),
+                                           wifi));
+      }
+      break;
+    }
+
+    case TYPE_CELLULAR: {
+      CellularNetwork* cell = static_cast<CellularNetwork*>(network);
+      if (cell->NeedsActivation()) {
+        ActivateCellular(cell);
+      } else if (cell->connecting_or_connected()) {
+        // Cellular network is connecting or connected,
+        // so we show the config settings for the cellular network.
+        ShowTabbedNetworkSettings(cell);
+      } else {
+        // Clicked on a disconnected cellular network, so connect to it.
+        cros->ConnectToCellularNetwork(cell);
+      }
+      break;
+    }
+
+    case TYPE_VPN: {
+      VirtualNetwork* vpn = static_cast<VirtualNetwork*>(network);
+      // Connect or reconnect.
+      if (vpn->connecting_or_connected()) {
+        ShowTabbedNetworkSettings(vpn);
+      } else {
+        vpn->AttemptConnection(base::Bind(&NetworkMenu::DoConnect,
+                                          weak_pointer_factory_.GetWeakPtr(),
+                                          vpn));
+      }
+      break;
+    }
+
+    default:
+      break;
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuModel, ui::MenuModel implementation:
 
 bool NetworkMenuModel::HasIcons() const {
   return true;
 }
 
 int NetworkMenuModel::GetItemCount() const {
   return static_cast<int>(menu_items_.size());
 }
@@ skipping 84 matching lines @@
     } else if (cellular->sim_lock_state() == SIM_UNLOCKED ||
                cellular->sim_lock_state() == SIM_UNKNOWN) {
       cros->EnableCellularNetworkDevice(!cros->cellular_enabled());
     } else {
       SimDialogDelegate::ShowDialog(owner_->delegate()->GetNativeWindow(),
                                     SimDialogDelegate::SIM_DIALOG_UNLOCK);
     }
   } else if (flags & FLAG_TOGGLE_OFFLINE) {
     cros->EnableOfflineMode(!cros->offline_mode());
   } else if (flags & FLAG_ETHERNET) {
-    if (cros->ethernet_connected()) {
+    if (cros->ethernet_connected())
       owner_->ShowTabbedNetworkSettings(cros->ethernet_network());
-    }
   } else if (flags & (FLAG_WIFI | FLAG_ADD_WIFI |
                       FLAG_CELLULAR | FLAG_ADD_CELLULAR |
                       FLAG_VPN | FLAG_ADD_VPN)) {
     ConnectToNetworkAt(index, std::string(), std::string(), -1);
   } else if (flags & FLAG_DISCONNECT_VPN) {
     const VirtualNetwork* active_vpn = cros->virtual_network();
     if (active_vpn)
       cros->DisconnectFromNetwork(active_vpn);
   } else if (flags & FLAG_VIEW_ACCOUNT) {
     Browser* browser = BrowserList::GetLastActive();
     if (browser)
       browser->ShowSingletonTab(GURL(top_up_url_));
   }
 }
 
 void NetworkMenuModel::SetMenuModelDelegate(ui::MenuModelDelegate* delegate) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuModel, private methods:
 
 void NetworkMenuModel::ShowNetworkConfigView(NetworkConfigView* view) const {
   views::Widget* window = browser::CreateViewsWindow(
       owner_->delegate()->GetNativeWindow(), view, STYLE_GENERIC);
   window->SetAlwaysOnTop(true);
   window->Show();
 }
 
-void NetworkMenuModel::ActivateCellular(const CellularNetwork* cellular) const {
-  DCHECK(cellular);
-  Browser* browser = BrowserList::GetLastActive();
-  if (!browser)
-    return;
-  browser->OpenMobilePlanTabAndActivate();
-}
-
 void NetworkMenuModel::ShowOther(ConnectionType type) const {
   if (type == TYPE_CELLULAR) {
     ChooseMobileNetworkDialog::ShowDialog(
         owner_->delegate()->GetNativeWindow());
   } else {
     ShowNetworkConfigView(new NetworkConfigView(type));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 530 matching lines @@
           delegate_->GetMenuButton(), bounds, views::MenuItemView::TOPRIGHT,
           views::MenuRunner::HAS_MNEMONICS) == views::MenuRunner::MENU_DELETED)
     return;
 }
 
 void NetworkMenu::ShowTabbedNetworkSettings(const Network* network) const {
   DCHECK(network);
   Browser* browser = BrowserList::GetLastActive();
   if (!browser)
     return;
+
+  // In case of a VPN, show the config settings for the connected network.
+  if (network->type() == chromeos::TYPE_VPN) {
+    network = CrosLibrary::Get()->GetNetworkLibrary()->connected_network();
+    if (!network)
+      return;
+  }
+
   std::string network_name(network->name());
   if (network_name.empty() && network->type() == chromeos::TYPE_ETHERNET) {
     network_name = l10n_util::GetStringUTF8(
         IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET);
   }
   std::string page = StringPrintf(
       "%s?servicePath=%s&networkType=%d&networkName=%s",
       chrome::kInternetOptionsSubPage,
       net::EscapeUrlEncodedData(network->service_path(), true).c_str(),
       network->type(),
@@ skipping 29 matching lines @@
       window->Show();
     } else {
       cros->ConnectToWifiNetwork(wifi);
       // Connection failures are responsible for updating the UI, including
       // reopening dialogs.
     }
   }
 }
 
 }  // namespace chromeos