Implement networkingPrivate.getNetworks

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/guid.h"
 #include "base/location.h"
@@ skipping 280 matching lines @@
   for (ManagedStateList::const_iterator iter = device_list_.begin();
        iter != device_list_.end(); ++iter) {
     const DeviceState* device = (*iter)->AsDeviceState();
     DCHECK(device);
     if (device->update_received() && device->Matches(type))
       list->push_back(device);
   }
 }
 
 void NetworkStateHandler::GetFavoriteList(FavoriteStateList* list) const {
-  GetFavoriteListByType(NetworkTypePattern::Default(), list);
+  GetFavoriteListByType(NetworkTypePattern::Default(),
+                        true /* configured_only */,
+                        false /* visible_only */,
+                        0 /* no limit */,
+                        list);
 }
 
 void NetworkStateHandler::GetFavoriteListByType(const NetworkTypePattern& type,
+                                                bool configured_only,
+                                                bool visible_only,
+                                                int limit,
                                                 FavoriteStateList* list) const {
   DCHECK(list);
+  std::set<std::string> visible_networks;
+  if (visible_only) {
+    // Prepare a set of visible network service paths for fast lookup.
+    for (ManagedStateList::const_iterator iter = network_list_.begin();
+         iter != network_list_.end(); ++iter) {
+      visible_networks.insert((*iter)->path());
+    }
+  }
   FavoriteStateList result;
   list->clear();
+  int count = 0;
   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->IsInProfile() &&
-        favorite->Matches(type)) {
-      list->push_back(favorite);
-    }
+    if (!favorite->update_received() || !favorite->Matches(type))
+      continue;
+    if (configured_only && !favorite->IsInProfile())
+      continue;
+    if (visible_only && !ContainsKey(visible_networks, favorite->path()))
+      continue;
+    list->push_back(favorite);
+    if (limit > 0 && ++count >= limit)
+      break;
   }
 }
 
 const FavoriteState* NetworkStateHandler::GetFavoriteStateFromServicePath(
     const std::string& service_path,
     bool configured_only) const {
   ManagedState* managed =
       GetModifiableManagedState(&favorite_list_, service_path);
   if (!managed)
     return NULL;
@@ skipping 84 matching lines @@
         base::StringPrintf("Unknown device %s of connected ethernet service %s",
                            network->device_path().c_str(),
                            service_path.c_str()));
     return NULL;
   }
   if (!device->eap_authentication_completed())
     return NULL;
 
   FavoriteStateList list;
   GetFavoriteListByType(NetworkTypePattern::Primitive(shill::kTypeEthernetEap),
+                        true /* configured_only */,
+                        false /* visible_only */,
+                        1 /* limit */,
                         &list);
   if (list.empty()) {
     NET_LOG_ERROR("GetEAPForEthernet",
                   base::StringPrintf(
                       "Ethernet service %s connected using EAP, but no "
                       "EAP service found.",
                       service_path.c_str()));
     return NULL;
   }
-  DCHECK(list.size() == 1);
   return list.front();
 }
 
 //------------------------------------------------------------------------------
 // ShillPropertyHandler::Delegate overrides
 
 void NetworkStateHandler::UpdateManagedList(ManagedState::ManagedType type,
                                             const base::ListValue& entries) {
   ManagedStateList* managed_list = GetManagedList(type);
   NET_LOG_DEBUG(base::StringPrintf("UpdateManagedList:%d", type),
@@ skipping 490 matching lines @@
   if (type.MatchesType(shill::kTypeBluetooth))
     technologies.push_back(new std::string(shill::kTypeBluetooth));
   if (type.MatchesType(shill::kTypeVPN))
     technologies.push_back(new std::string(shill::kTypeVPN));
 
   CHECK_GT(technologies.size(), 0ul);
   return technologies.Pass();
 }
 
 }  // namespace chromeos