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->activation_state() != ACTIVATION_STATE_ACTIVATED &&
+           cell->activation_state() != ACTIVATION_STATE_UNKNOWN) ||
+          cell->needs_new_plan()) {

[stevenjb, 2012/03/12 18:21:29]

As long as we're cleaning this up, can you wrap these checks into
CellularNetwork as NeedsActivation() ? This will help us with the refactoring
we're about to start. Thanks!

[sadrul, 2012/03/12 18:32:25]

Done.

+        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()) {
+        // Show the config settings for the connected network.
+        if (cros->connected_network())
+          ShowTabbedNetworkSettings(cros->connected_network());

[stevenjb, 2012/03/12 18:21:29]

Can you put the cros->connected_network() bit into ShowTabbedNetworkSettings(),
i.e. have this just call ShowTabbedNetworkSettings(vpn), and have the logic to
show the conencted network in ShowTabbedNetworkSettings()? At some point we will
want to move that logic into the settings page since eventually we may want to
show properties for the VPN, not for the connected network.

[sadrul, 2012/03/12 18:32:25]

Done.

+      } 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 579 matching lines @@
       window->Show();
     } else {
       cros->ConnectToWifiNetwork(wifi);
       // Connection failures are responsible for updating the UI, including
       // reopening dialogs.
     }
   }
 }
 
 }  // namespace chromeos