Always list EthernetEAP as a Favorite for debugging

chromeos/network/network_state_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 "chromeos/network/network_state_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 286 matching lines @@
 
 void NetworkStateHandler::GetFavoriteListByType(const NetworkTypePattern& type,
                                                 FavoriteStateList* list) const {
   DCHECK(list);
   FavoriteStateList result;
   list->clear();
   for (ManagedStateList::const_iterator iter = favorite_list_.begin();
        iter != favorite_list_.end(); ++iter) {
     const FavoriteState* favorite = (*iter)->AsFavoriteState();
     DCHECK(favorite);
-    if (favorite->update_received() && favorite->is_favorite() &&
+    if (favorite->update_received() && favorite->IsFavorite() &&
         favorite->Matches(type)) {
       list->push_back(favorite);
     }
   }
 }
 
 const FavoriteState* NetworkStateHandler::GetFavoriteState(
     const std::string& service_path) const {
   ManagedState* managed =
       GetModifiableManagedState(&favorite_list_, service_path);
   if (!managed)
     return NULL;
   const FavoriteState* favorite = managed->AsFavoriteState();
   DCHECK(favorite);
-  if (!favorite->update_received() || !favorite->is_favorite())
+  if (!favorite->update_received() || !favorite->IsFavorite())
     return NULL;
   return favorite;
 }
 
 void NetworkStateHandler::RequestScan() const {
   NET_LOG_USER("RequestScan", "");
   shill_property_handler_->RequestScan();
 }
 
 void NetworkStateHandler::WaitForScan(const std::string& type,
@@ skipping 13 matching lines @@
 void NetworkStateHandler::RequestUpdateForNetwork(
     const std::string& service_path) {
   NetworkState* network = GetModifiableNetworkState(service_path);
   if (network)
     network->set_update_requested(true);
   NET_LOG_EVENT("RequestUpdate", service_path);
   shill_property_handler_->RequestProperties(
       ManagedState::MANAGED_TYPE_NETWORK, service_path);
 }
 
-void NetworkStateHandler::RequestUpdateForAllNetworks() {
-  NET_LOG_EVENT("RequestUpdateForAllNetworks", "");
-  for (ManagedStateList::iterator iter = network_list_.begin();
-       iter != network_list_.end(); ++iter) {
-    ManagedState* network = *iter;
-    network->set_update_requested(true);
-    shill_property_handler_->RequestProperties(
-        ManagedState::MANAGED_TYPE_NETWORK, network->path());
-  }
-}
-
 void NetworkStateHandler::ClearLastErrorForNetwork(
     const std::string& service_path) {
   NetworkState* network = GetModifiableNetworkState(service_path);
   if (network)
     network->clear_last_error();
 }
 
 void NetworkStateHandler::SetCheckPortalList(
     const std::string& check_portal_list) {
   NET_LOG_EVENT("SetCheckPortalList", check_portal_list);
@@ skipping 99 matching lines @@
       managed_map.erase(found);
     }
     list_entries.insert(path);
   }
   // Delete any remaining entries in managed_map.
   STLDeleteContainerPairSecondPointers(managed_map.begin(), managed_map.end());
 }
 
 void NetworkStateHandler::ProfileListChanged() {
   NET_LOG_EVENT("ProfileListChanged", "Re-Requesting Network Properties");
-  for (ManagedStateList::iterator iter = network_list_.begin();
-       iter != network_list_.end(); ++iter) {
+  for (ManagedStateList::iterator iter = favorite_list_.begin();
+       iter != favorite_list_.end(); ++iter) {
     shill_property_handler_->RequestProperties(
         ManagedState::MANAGED_TYPE_NETWORK, (*iter)->path());
   }
 }
 
 void NetworkStateHandler::UpdateManagedStateProperties(
     ManagedState::ManagedType type,
     const std::string& path,
     const base::DictionaryValue& properties) {
   ManagedStateList* managed_list = GetManagedList(type);
   ManagedState* managed = GetModifiableManagedState(managed_list, path);
   if (!managed) {
     if (type != ManagedState::MANAGED_TYPE_FAVORITE) {
       // The network has been removed from the list of visible networks.
       NET_LOG_DEBUG("UpdateManagedStateProperties: Not found", path);
       return;
     }
     // A Favorite may not have been created yet if it was added later (e.g.
     // through ConfigureService) since ServiceCompleteList updates are not
     // emitted. Add and update the state here.
     managed = new FavoriteState(path);
     managed_list->push_back(managed);
   }
   managed->set_update_received();
 
-  std::string desc = GetManagedStateLogType(managed) + " PropertiesReceived";
+  std::string desc = GetManagedStateLogType(managed) + " Properties Received";
   NET_LOG_DEBUG(desc, GetManagedStateLogName(managed));
 
   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
     UpdateNetworkStateProperties(managed->AsNetworkState(), properties);
   } else {
     // Device, Favorite
     for (base::DictionaryValue::Iterator iter(properties);
          !iter.IsAtEnd(); iter.Advance()) {
       managed->PropertyChanged(iter.key(), iter.value());
     }
@@ skipping 148 matching lines @@
     NET_LOG_DEBUG("FavoriteListChanged",
                   base::StringPrintf("Size:%" PRIuS, favorite_list_.size()));
     // The FavoriteState list only changes when the NetworkState list changes,
     // so no need to signal observers here again.
 
     // Update UMA stats.
     size_t shared = 0, unshared = 0;
     for (ManagedStateList::iterator iter = favorite_list_.begin();
          iter != favorite_list_.end(); ++iter) {
       FavoriteState* favorite = (*iter)->AsFavoriteState();
-      if (!favorite->is_favorite())
+      if (!favorite->IsFavorite())
         continue;
       if (favorite->IsPrivate())
         ++unshared;
       else
         ++shared;
     }
     UMA_HISTOGRAM_COUNTS_100("Networks.RememberedShared", shared);
     UMA_HISTOGRAM_COUNTS_100("Networks.RememberedUnshared", unshared);
   } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
     NotifyDeviceListChanged();
@@ skipping 147 matching lines @@
   }
 
   if (type.MatchesType(shill::kTypeCellular))
     return shill::kTypeCellular;
 
   NOTREACHED();
   return std::string();
 }
 
 }  // namespace chromeos