Merge FavoriteState into NetworkState

chrome/browser/ui/webui/options/chromeos/internet_options_handler.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/ui/webui/options/chromeos/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 18 matching lines @@
 #include "chrome/browser/chromeos/options/network_property_ui_data.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/chromeos/ui/choose_mobile_network_dialog.h"
 #include "chrome/browser/chromeos/ui/mobile_config_ui.h"
 #include "chrome/browser/chromeos/ui_proxy_config_service.h"
 #include "chrome/browser/ui/webui/options/chromeos/core_chromeos_options_handler.h"
 #include "chrome/browser/ui/webui/options/chromeos/internet_options_handler_strings.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/network/device_state.h"
-#include "chromeos/network/favorite_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_ip_config.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"
@@ skipping 236 matching lines @@
       return kTagLoggedInUserPublicAccount;
     case LoginState::LOGGED_IN_USER_LOCALLY_MANAGED:
       return kTagLoggedInUserLocallyManaged;
     case LoginState::LOGGED_IN_USER_KIOSK_APP:
       return kTagLoggedInUserKioskApp;
   }
   NOTREACHED();
   return std::string();
 }
 
-bool HasPolicyForFavorite(const FavoriteState* favorite,
-                          const PrefService* profile_prefs) {
-  return onc::HasPolicyForFavoriteNetwork(
-      profile_prefs, g_browser_process->local_state(), *favorite);
-}
-
-bool HasPolicyForNetwork(const NetworkState* network,
-                         const PrefService* profile_prefs) {
-  const FavoriteState* favorite =
-      NetworkHandler::Get()
-          ->network_state_handler()
-          ->GetFavoriteStateFromServicePath(network->path(),
-                                            true /* configured_only */);
-  if (!favorite)
-    return false;
-  return HasPolicyForFavorite(favorite, profile_prefs);
-}
-
-void SetCommonNetworkInfo(const ManagedState* state,
+void SetCommonNetworkInfo(const NetworkState* state,
                           const std::string& icon_url,
                           base::DictionaryValue* network_info) {
   network_info->SetString(kNetworkInfoKeyIconURL, icon_url);
 
   std::string name = state->name();
   if (state->Matches(NetworkTypePattern::Ethernet())) {
     name = internet_options_strings::NetworkDeviceTypeString(
         shill::kTypeEthernet);
   }
   network_info->SetString(kNetworkInfoKeyNetworkName, name);
   network_info->SetString(kNetworkInfoKeyNetworkType, state->type());
   network_info->SetString(kNetworkInfoKeyServicePath, state->path());
 }
 
 // Builds a dictionary with network information and an icon used for the
 // NetworkList on the settings page. Ownership of the returned pointer is
 // transferred to the caller.
 base::DictionaryValue* BuildNetworkDictionary(
     const NetworkState* network,
     float icon_scale_factor,
     const PrefService* profile_prefs) {
   scoped_ptr<base::DictionaryValue> network_info(new base::DictionaryValue());
-  network_info->SetBoolean(kNetworkInfoKeyConnectable, network->connectable());
-  network_info->SetBoolean(kNetworkInfoKeyConnected,
-                           network->IsConnectedState());
-  network_info->SetBoolean(kNetworkInfoKeyConnecting,
-                           network->IsConnectingState());
-  network_info->SetBoolean(kNetworkInfoKeyPolicyManaged,
-                           HasPolicyForNetwork(network, profile_prefs));
+  if (network->visible()) {
+    network_info->SetBoolean(kNetworkInfoKeyConnectable,
+                             network->connectable());
+    network_info->SetBoolean(kNetworkInfoKeyConnected,
+                             network->IsConnectedState());
+    network_info->SetBoolean(kNetworkInfoKeyConnecting,
+                             network->IsConnectingState());
+  } else {
+    network_info->SetBoolean(kNetworkInfoKeyConnectable, false);
+    network_info->SetBoolean(kNetworkInfoKeyConnected, false);
+    network_info->SetBoolean(kNetworkInfoKeyConnecting, false);
+  }
+  bool has_policy = onc::HasPolicyForNetwork(
+      profile_prefs, g_browser_process->local_state(), *network);
+  network_info->SetBoolean(kNetworkInfoKeyPolicyManaged, has_policy);
 
   std::string icon_url = ash::network_icon::GetImageUrlForNetwork(
       network, ash::network_icon::ICON_TYPE_LIST, icon_scale_factor);
   SetCommonNetworkInfo(network, icon_url, network_info.get());
   return network_info.release();
 }
 
-base::DictionaryValue* BuildFavoriteDictionary(
-    const FavoriteState* favorite,
-    float icon_scale_factor,
-    const PrefService* profile_prefs) {
-  scoped_ptr<base::DictionaryValue> network_info(new base::DictionaryValue());
-  network_info->SetBoolean(kNetworkInfoKeyConnectable, false);
-  network_info->SetBoolean(kNetworkInfoKeyConnected, false);
-  network_info->SetBoolean(kNetworkInfoKeyConnecting, false);
-  network_info->SetBoolean(kNetworkInfoKeyPolicyManaged,
-                           HasPolicyForFavorite(favorite, profile_prefs));
-
-  std::string icon_url = ash::network_icon::GetImageUrlForDisconnectedNetwork(
-      ash::network_icon::ICON_TYPE_LIST, favorite->type(), icon_scale_factor);
-  SetCommonNetworkInfo(favorite, icon_url, network_info.get());
-  return network_info.release();
-}
-
 // Pulls IP information out of a shill service properties dictionary. If
 // |static_ip| is true, then it fetches "StaticIP.*" properties. If not, then it
 // fetches "SavedIP.*" properties. Caller must take ownership of returned
 // dictionary.  If non-NULL, |ip_parameters_set| returns a count of the number
 // of IP routing parameters that get set.
 base::DictionaryValue* BuildIPInfoDictionary(
     const base::DictionaryValue& shill_properties,
     bool static_ip,
     int* routing_parameters_set) {
   std::string address_key;
@@ skipping 1353 matching lines @@
       BuildNetworkDictionary(network,
                              web_ui()->GetDeviceScaleFactor(),
                              Profile::FromWebUI(web_ui())->GetPrefs()));
   return list;
 }
 
 base::ListValue* InternetOptionsHandler::GetWirelessList() {
   base::ListValue* list = new base::ListValue();
 
   NetworkStateHandler::NetworkStateList networks;
-  NetworkHandler::Get()->network_state_handler()->GetNetworkListByType(
+  NetworkHandler::Get()->network_state_handler()->GetVisibleNetworkListByType(
       NetworkTypePattern::Wireless(), &networks);
   for (NetworkStateHandler::NetworkStateList::const_iterator iter =
            networks.begin(); iter != networks.end(); ++iter) {
     list->Append(
         BuildNetworkDictionary(*iter,
                                web_ui()->GetDeviceScaleFactor(),
                                Profile::FromWebUI(web_ui())->GetPrefs()));
   }
 
   return list;
 }
 
 base::ListValue* InternetOptionsHandler::GetVPNList() {
   base::ListValue* list = new base::ListValue();
 
   NetworkStateHandler::NetworkStateList networks;
-  NetworkHandler::Get()->network_state_handler()->GetNetworkListByType(
+  NetworkHandler::Get()->network_state_handler()->GetVisibleNetworkListByType(
       NetworkTypePattern::VPN(), &networks);
   for (NetworkStateHandler::NetworkStateList::const_iterator iter =
            networks.begin(); iter != networks.end(); ++iter) {
     list->Append(
         BuildNetworkDictionary(*iter,
                                web_ui()->GetDeviceScaleFactor(),
                                Profile::FromWebUI(web_ui())->GetPrefs()));
   }
 
   return list;
 }
 
 base::ListValue* InternetOptionsHandler::GetRememberedList() {
   base::ListValue* list = new base::ListValue();
 
-  NetworkStateHandler::FavoriteStateList favorites;
-  NetworkHandler::Get()->network_state_handler()->GetFavoriteList(&favorites);
-  for (NetworkStateHandler::FavoriteStateList::const_iterator iter =
-           favorites.begin(); iter != favorites.end(); ++iter) {
-    const FavoriteState* favorite = *iter;
-    if (favorite->type() != shill::kTypeWifi &&
-        favorite->type() != shill::kTypeVPN)
+  NetworkStateHandler::NetworkStateList networks;
+  NetworkHandler::Get()->network_state_handler()->GetNetworkListByType(
+      NetworkTypePattern::Default(),
+      true /* configured_only */,
+      false /* visible_only */,
+      0 /* no limit */,
+      &networks);
+  for (NetworkStateHandler::NetworkStateList::const_iterator iter =
+           networks.begin(); iter != networks.end(); ++iter) {
+    const NetworkState* network = *iter;
+    if (network->type() != shill::kTypeWifi &&
+        network->type() != shill::kTypeVPN)
       continue;
     list->Append(
-        BuildFavoriteDictionary(favorite,
-                                web_ui()->GetDeviceScaleFactor(),
-                                Profile::FromWebUI(web_ui())->GetPrefs()));
+        BuildNetworkDictionary(network,
+                               web_ui()->GetDeviceScaleFactor(),
+                               Profile::FromWebUI(web_ui())->GetPrefs()));
   }
 
   return list;
 }
 
 void InternetOptionsHandler::FillNetworkInfo(
     base::DictionaryValue* dictionary) {
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   dictionary->Set(kTagWiredList, GetWiredList());
   dictionary->Set(kTagWirelessList, GetWirelessList());
@@ skipping 22 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos