chromeos/network/network_state_handler.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/network/network_state_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/format_macros.h"
   9 #include "base/guid.h"
  10 #include "base/location.h"
  11 #include "base/logging.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/stl_util.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "base/values.h"
  17 #include "chromeos/network/device_state.h"
  18 #include "chromeos/network/managed_state.h"
  19 #include "chromeos/network/network_event_log.h"
  20 #include "chromeos/network/network_state.h"
  21 #include "chromeos/network/network_state_handler_observer.h"
  22 #include "chromeos/network/shill_property_handler.h"
  23 #include "third_party/cros_system_api/dbus/service_constants.h"
  24
  25 namespace chromeos {
  26
  27 namespace {
  28
  29 bool ConnectionStateChanged(NetworkState* network,
  30                             const std::string& prev_connection_state) {
  31   return (network->connection_state() != prev_connection_state) &&
  32          (network->connection_state() != shill::kStateIdle ||
  33           !prev_connection_state.empty());
  34 }
  35
  36 std::string GetManagedStateLogType(const ManagedState* state) {
  37   switch (state->managed_type()) {
  38     case ManagedState::MANAGED_TYPE_NETWORK:
  39       return "Network";
  40     case ManagedState::MANAGED_TYPE_DEVICE:
  41       return "Device";
  42   }
  43   NOTREACHED();
  44   return "";
  45 }
  46
  47 std::string GetLogName(const ManagedState* state) {
  48   if (!state)
  49     return "None";
  50   return base::StringPrintf("%s (%s)", state->name().c_str(),
  51                             state->path().c_str());
  52 }
  53
  54 }  // namespace
  55
  56 const char NetworkStateHandler::kDefaultCheckPortalList[] =
  57     "ethernet,wifi,cellular";
  58
  59 NetworkStateHandler::NetworkStateHandler()
  60     : network_list_sorted_(false) {
  61 }
  62
  63 NetworkStateHandler::~NetworkStateHandler() {
  64   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_, IsShuttingDown());
  65   STLDeleteContainerPointers(network_list_.begin(), network_list_.end());
  66   STLDeleteContainerPointers(device_list_.begin(), device_list_.end());
  67 }
  68
  69 void NetworkStateHandler::InitShillPropertyHandler() {
  70   shill_property_handler_.reset(new internal::ShillPropertyHandler(this));
  71   shill_property_handler_->Init();
  72 }
  73
  74 // static
  75 NetworkStateHandler* NetworkStateHandler::InitializeForTest() {
  76   NetworkStateHandler* handler = new NetworkStateHandler();
  77   handler->InitShillPropertyHandler();
  78   return handler;
  79 }
  80
  81 void NetworkStateHandler::AddObserver(
  82     NetworkStateHandlerObserver* observer,
  83     const tracked_objects::Location& from_here) {
  84   observers_.AddObserver(observer);
  85   network_event_log::internal::AddEntry(
  86       from_here.file_name(), from_here.line_number(),
  87       network_event_log::LOG_LEVEL_DEBUG,
  88       "NetworkStateHandler::AddObserver", "");
  89 }
  90
  91 void NetworkStateHandler::RemoveObserver(
  92     NetworkStateHandlerObserver* observer,
  93     const tracked_objects::Location& from_here) {
  94   observers_.RemoveObserver(observer);
  95   network_event_log::internal::AddEntry(
  96       from_here.file_name(), from_here.line_number(),
  97       network_event_log::LOG_LEVEL_DEBUG,
  98       "NetworkStateHandler::RemoveObserver", "");
  99 }
 100
 101 NetworkStateHandler::TechnologyState NetworkStateHandler::GetTechnologyState(
 102     const NetworkTypePattern& type) const {
 103   std::string technology = GetTechnologyForType(type);
 104   TechnologyState state;
 105   if (shill_property_handler_->IsTechnologyEnabled(technology))
 106     state = TECHNOLOGY_ENABLED;
 107   else if (shill_property_handler_->IsTechnologyEnabling(technology))
 108     state = TECHNOLOGY_ENABLING;
 109   else if (shill_property_handler_->IsTechnologyUninitialized(technology))
 110     state = TECHNOLOGY_UNINITIALIZED;
 111   else if (shill_property_handler_->IsTechnologyAvailable(technology))
 112     state = TECHNOLOGY_AVAILABLE;
 113   else
 114     state = TECHNOLOGY_UNAVAILABLE;
 115   VLOG(2) << "GetTechnologyState: " << type.ToDebugString() << " = " << state;
 116   return state;
 117 }
 118
 119 void NetworkStateHandler::SetTechnologyEnabled(
 120     const NetworkTypePattern& type,
 121     bool enabled,
 122     const network_handler::ErrorCallback& error_callback) {
 123   ScopedVector<std::string> technologies = GetTechnologiesForType(type);
 124   for (ScopedVector<std::string>::iterator it = technologies.begin();
 125       it != technologies.end(); ++it) {
 126     std::string* technology = *it;
 127     DCHECK(technology);
 128     if (!shill_property_handler_->IsTechnologyAvailable(*technology))
 129       continue;
 130     NET_LOG_USER("SetTechnologyEnabled",
 131                  base::StringPrintf("%s:%d", technology->c_str(), enabled));
 132     shill_property_handler_->SetTechnologyEnabled(
 133         *technology, enabled, error_callback);
 134   }
 135   // Signal Device/Technology state changed.
 136   NotifyDeviceListChanged();
 137 }
 138
 139 const DeviceState* NetworkStateHandler::GetDeviceState(
 140     const std::string& device_path) const {
 141   const DeviceState* device = GetModifiableDeviceState(device_path);
 142   if (device && !device->update_received())
 143     return NULL;
 144   return device;
 145 }
 146
 147 const DeviceState* NetworkStateHandler::GetDeviceStateByType(
 148     const NetworkTypePattern& type) const {
 149   for (ManagedStateList::const_iterator iter = device_list_.begin();
 150        iter != device_list_.end(); ++iter) {
 151     ManagedState* device = *iter;
 152     if (!device->update_received())
 153       continue;
 154     if (device->Matches(type))
 155       return device->AsDeviceState();
 156   }
 157   return NULL;
 158 }
 159
 160 bool NetworkStateHandler::GetScanningByType(
 161     const NetworkTypePattern& type) const {
 162   for (ManagedStateList::const_iterator iter = device_list_.begin();
 163        iter != device_list_.end(); ++iter) {
 164     const DeviceState* device = (*iter)->AsDeviceState();
 165     DCHECK(device);
 166     if (!device->update_received())
 167       continue;
 168     if (device->Matches(type) && device->scanning())
 169       return true;
 170   }
 171   return false;
 172 }
 173
 174 const NetworkState* NetworkStateHandler::GetNetworkState(
 175     const std::string& service_path) const {
 176   const NetworkState* network = GetModifiableNetworkState(service_path);
 177   if (network && !network->update_received())
 178     return NULL;
 179   return network;
 180 }
 181
 182 const NetworkState* NetworkStateHandler::DefaultNetwork() const {
 183   if (default_network_path_.empty())
 184     return NULL;
 185   return GetNetworkState(default_network_path_);
 186 }
 187
 188 const NetworkState* NetworkStateHandler::ConnectedNetworkByType(
 189     const NetworkTypePattern& type) const {
 190   // Active networks are always listed first by Shill so no need to sort.
 191   for (ManagedStateList::const_iterator iter = network_list_.begin();
 192        iter != network_list_.end(); ++iter) {
 193     const NetworkState* network = (*iter)->AsNetworkState();
 194     DCHECK(network);
 195     if (!network->update_received())
 196       continue;
 197     if (!network->IsConnectedState())
 198       break;  // Connected networks are listed first.
 199     if (network->Matches(type))
 200       return network;
 201   }
 202   return NULL;
 203 }
 204
 205 const NetworkState* NetworkStateHandler::ConnectingNetworkByType(
 206     const NetworkTypePattern& type) const {
 207   // Active networks are always listed first by Shill so no need to sort.
 208   for (ManagedStateList::const_iterator iter = network_list_.begin();
 209        iter != network_list_.end(); ++iter) {
 210     const NetworkState* network = (*iter)->AsNetworkState();
 211     DCHECK(network);
 212     if (!network->update_received() || network->IsConnectedState())
 213       continue;
 214     if (!network->IsConnectingState())
 215       break;  // Connected and connecting networks are listed first.
 216     if (network->Matches(type))
 217       return network;
 218   }
 219   return NULL;
 220 }
 221
 222 const NetworkState* NetworkStateHandler::FirstNetworkByType(
 223     const NetworkTypePattern& type) {
 224   if (!network_list_sorted_)
 225     SortNetworkList();  // Sort to ensure visible networks are listed first.
 226   for (ManagedStateList::const_iterator iter = network_list_.begin();
 227        iter != network_list_.end(); ++iter) {
 228     const NetworkState* network = (*iter)->AsNetworkState();
 229     DCHECK(network);
 230     if (!network->update_received())
 231       continue;
 232     if (!network->visible())
 233       break;
 234     if (network->Matches(type))
 235       return network;
 236   }
 237   return NULL;
 238 }
 239
 240 std::string NetworkStateHandler::FormattedHardwareAddressForType(
 241     const NetworkTypePattern& type) const {
 242   const DeviceState* device = NULL;
 243   const NetworkState* network = ConnectedNetworkByType(type);
 244   if (network)
 245     device = GetDeviceState(network->device_path());
 246   else
 247     device = GetDeviceStateByType(type);
 248   if (!device)
 249     return std::string();
 250   return network_util::FormattedMacAddress(device->mac_address());
 251 }
 252
 253 void NetworkStateHandler::GetVisibleNetworkListByType(
 254     const NetworkTypePattern& type,
 255     NetworkStateList* list) {
 256   GetNetworkListByType(type,
 257                        false /* configured_only */,
 258                        true /* visible_only */,
 259                        0 /* no limit */,
 260                        list);
 261 }
 262
 263 void NetworkStateHandler::GetVisibleNetworkList(NetworkStateList* list) {
 264   GetVisibleNetworkListByType(NetworkTypePattern::Default(), list);
 265 }
 266
 267 void NetworkStateHandler::GetNetworkListByType(const NetworkTypePattern& type,
 268                                                bool configured_only,
 269                                                bool visible_only,
 270                                                int limit,
 271                                                NetworkStateList* list) {
 272   DCHECK(list);
 273   list->clear();
 274   int count = 0;
 275   // Sort the network list if necessary.
 276   if (!network_list_sorted_)
 277     SortNetworkList();
 278   for (ManagedStateList::const_iterator iter = network_list_.begin();
 279        iter != network_list_.end(); ++iter) {
 280     const NetworkState* network = (*iter)->AsNetworkState();
 281     DCHECK(network);
 282     if (!network->update_received() || !network->Matches(type))
 283       continue;
 284     if (configured_only && !network->IsInProfile())
 285       continue;
 286     if (visible_only && !network->visible())
 287       continue;
 288     list->push_back(network);
 289     if (limit > 0 && ++count >= limit)
 290       break;
 291   }
 292 }
 293
 294 const NetworkState* NetworkStateHandler::GetNetworkStateFromServicePath(
 295     const std::string& service_path,
 296     bool configured_only) const {
 297   ManagedState* managed =
 298       GetModifiableManagedState(&network_list_, service_path);
 299   if (!managed)
 300     return NULL;
 301   const NetworkState* network = managed->AsNetworkState();
 302   DCHECK(network);
 303   if (!network->update_received() ||
 304       (configured_only && !network->IsInProfile())) {
 305     return NULL;
 306   }
 307   return network;
 308 }
 309
 310 const NetworkState* NetworkStateHandler::GetNetworkStateFromGuid(
 311     const std::string& guid) const {
 312   DCHECK(!guid.empty());
 313   for (ManagedStateList::const_iterator iter = network_list_.begin();
 314        iter != network_list_.end(); ++iter) {
 315     const NetworkState* network = (*iter)->AsNetworkState();
 316     if (network->guid() == guid)
 317       return network;
 318   }
 319   return NULL;
 320 }
 321
 322 void NetworkStateHandler::GetDeviceList(DeviceStateList* list) const {
 323   GetDeviceListByType(NetworkTypePattern::Default(), list);
 324 }
 325
 326 void NetworkStateHandler::GetDeviceListByType(const NetworkTypePattern& type,
 327                                               DeviceStateList* list) const {
 328   DCHECK(list);
 329   list->clear();
 330   for (ManagedStateList::const_iterator iter = device_list_.begin();
 331        iter != device_list_.end(); ++iter) {
 332     const DeviceState* device = (*iter)->AsDeviceState();
 333     DCHECK(device);
 334     if (device->update_received() && device->Matches(type))
 335       list->push_back(device);
 336   }
 337 }
 338
 339 void NetworkStateHandler::RequestScan() const {
 340   NET_LOG_USER("RequestScan", "");
 341   shill_property_handler_->RequestScan();
 342 }
 343
 344 void NetworkStateHandler::WaitForScan(const std::string& type,
 345                                       const base::Closure& callback) {
 346   scan_complete_callbacks_[type].push_back(callback);
 347   if (!GetScanningByType(NetworkTypePattern::Primitive(type)))
 348     RequestScan();
 349 }
 350
 351 void NetworkStateHandler::ConnectToBestWifiNetwork() {
 352   NET_LOG_USER("ConnectToBestWifiNetwork", "");
 353   WaitForScan(shill::kTypeWifi,
 354               base::Bind(&internal::ShillPropertyHandler::ConnectToBestServices,
 355                          shill_property_handler_->AsWeakPtr()));
 356 }
 357
 358 void NetworkStateHandler::RequestUpdateForNetwork(
 359     const std::string& service_path) {
 360   NetworkState* network = GetModifiableNetworkState(service_path);
 361   if (network)
 362     network->set_update_requested(true);
 363   NET_LOG_EVENT("RequestUpdate", service_path);
 364   shill_property_handler_->RequestProperties(
 365       ManagedState::MANAGED_TYPE_NETWORK, service_path);
 366 }
 367
 368 void NetworkStateHandler::ClearLastErrorForNetwork(
 369     const std::string& service_path) {
 370   NetworkState* network = GetModifiableNetworkState(service_path);
 371   if (network)
 372     network->clear_last_error();
 373 }
 374
 375 void NetworkStateHandler::SetCheckPortalList(
 376     const std::string& check_portal_list) {
 377   NET_LOG_EVENT("SetCheckPortalList", check_portal_list);
 378   shill_property_handler_->SetCheckPortalList(check_portal_list);
 379 }
 380
 381 const NetworkState* NetworkStateHandler::GetEAPForEthernet(
 382     const std::string& service_path) {
 383   const NetworkState* network = GetNetworkState(service_path);
 384   if (!network) {
 385     NET_LOG_ERROR("GetEAPForEthernet", "Unknown service path " + service_path);
 386     return NULL;
 387   }
 388   if (network->type() != shill::kTypeEthernet) {
 389     NET_LOG_ERROR("GetEAPForEthernet", "Not of type Ethernet: " + service_path);
 390     return NULL;
 391   }
 392   if (!network->IsConnectedState())
 393     return NULL;
 394
 395   // The same EAP service is shared for all ethernet services/devices.
 396   // However EAP is used/enabled per device and only if the connection was
 397   // successfully established.
 398   const DeviceState* device = GetDeviceState(network->device_path());
 399   if (!device) {
 400     NET_LOG_ERROR(
 401         "GetEAPForEthernet",
 402         base::StringPrintf("Unknown device %s of connected ethernet service %s",
 403                            network->device_path().c_str(),
 404                            service_path.c_str()));
 405     return NULL;
 406   }
 407   if (!device->eap_authentication_completed())
 408     return NULL;
 409
 410   NetworkStateList list;
 411   GetNetworkListByType(NetworkTypePattern::Primitive(shill::kTypeEthernetEap),
 412                        true /* configured_only */,
 413                        false /* visible_only */,
 414                        1 /* limit */,
 415                        &list);
 416   if (list.empty()) {
 417     NET_LOG_ERROR("GetEAPForEthernet",
 418                   base::StringPrintf(
 419                       "Ethernet service %s connected using EAP, but no "
 420                       "EAP service found.",
 421                       service_path.c_str()));
 422     return NULL;
 423   }
 424   return list.front();
 425 }
 426
 427 //------------------------------------------------------------------------------
 428 // ShillPropertyHandler::Delegate overrides
 429
 430 void NetworkStateHandler::UpdateManagedList(ManagedState::ManagedType type,
 431                                             const base::ListValue& entries) {
 432   ManagedStateList* managed_list = GetManagedList(type);
 433   NET_LOG_DEBUG("UpdateManagedList: " + ManagedState::TypeToString(type),
 434                 base::StringPrintf("%" PRIuS, entries.GetSize()));
 435   // Create a map of existing entries. Assumes all entries in |managed_list|
 436   // are unique.
 437   typedef std::map<std::string, ManagedState*> ManagedMap;
 438   ManagedMap managed_map;
 439   for (ManagedStateList::iterator iter = managed_list->begin();
 440        iter != managed_list->end(); ++iter) {
 441     ManagedState* managed = *iter;
 442     DCHECK(!ContainsKey(managed_map, managed->path()));
 443     managed_map[managed->path()] = managed;
 444   }
 445   // Clear the list (pointers are temporarily owned by managed_map).
 446   managed_list->clear();
 447   // Updates managed_list and request updates for new entries.
 448   std::set<std::string> list_entries;
 449   for (base::ListValue::const_iterator iter = entries.begin();
 450        iter != entries.end(); ++iter) {
 451     std::string path;
 452     (*iter)->GetAsString(&path);
 453     if (path.empty() || path == shill::kFlimflamServicePath) {
 454       NET_LOG_ERROR(base::StringPrintf("Bad path in list:%d", type), path);
 455       continue;
 456     }
 457     ManagedMap::iterator found = managed_map.find(path);
 458     if (found == managed_map.end()) {
 459       if (list_entries.count(path) != 0) {
 460         NET_LOG_ERROR("Duplicate entry in list", path);
 461         continue;
 462       }
 463       ManagedState* managed = ManagedState::Create(type, path);
 464       managed_list->push_back(managed);
 465     } else {
 466       managed_list->push_back(found->second);
 467       managed_map.erase(found);
 468     }
 469     list_entries.insert(path);
 470   }
 471   // Delete any remaining entries in managed_map.
 472   STLDeleteContainerPairSecondPointers(managed_map.begin(), managed_map.end());
 473 }
 474
 475 void NetworkStateHandler::ProfileListChanged() {
 476   NET_LOG_EVENT("ProfileListChanged", "Re-Requesting Network Properties");
 477   for (ManagedStateList::iterator iter = network_list_.begin();
 478        iter != network_list_.end(); ++iter) {
 479     NetworkState* network = (*iter)->AsNetworkState();
 480     DCHECK(network);
 481     shill_property_handler_->RequestProperties(
 482         ManagedState::MANAGED_TYPE_NETWORK, network->path());
 483   }
 484 }
 485
 486 void NetworkStateHandler::UpdateManagedStateProperties(
 487     ManagedState::ManagedType type,
 488     const std::string& path,
 489     const base::DictionaryValue& properties) {
 490   ManagedStateList* managed_list = GetManagedList(type);
 491   ManagedState* managed = GetModifiableManagedState(managed_list, path);
 492   if (!managed) {
 493     // The network has been removed from the list of networks.
 494     NET_LOG_DEBUG("UpdateManagedStateProperties: Not found", path);
 495     return;
 496   }
 497   managed->set_update_received();
 498
 499   std::string desc = GetManagedStateLogType(managed) + " Properties Received";
 500   NET_LOG_DEBUG(desc, GetLogName(managed));
 501
 502   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
 503     UpdateNetworkStateProperties(managed->AsNetworkState(), properties);
 504   } else {
 505     // Device
 506     for (base::DictionaryValue::Iterator iter(properties);
 507          !iter.IsAtEnd(); iter.Advance()) {
 508       managed->PropertyChanged(iter.key(), iter.value());
 509     }
 510     managed->InitialPropertiesReceived(properties);
 511   }
 512   managed->set_update_requested(false);
 513 }
 514
 515 void NetworkStateHandler::UpdateNetworkStateProperties(
 516     NetworkState* network,
 517     const base::DictionaryValue& properties) {
 518   DCHECK(network);
 519   bool network_property_updated = false;
 520   std::string prev_connection_state = network->connection_state();
 521   for (base::DictionaryValue::Iterator iter(properties);
 522        !iter.IsAtEnd(); iter.Advance()) {
 523     if (network->PropertyChanged(iter.key(), iter.value()))
 524       network_property_updated = true;
 525   }
 526   network_property_updated |= network->InitialPropertiesReceived(properties);
 527   UpdateGuid(network);
 528   network_list_sorted_ = false;
 529
 530   // Notify observers of NetworkState changes.
 531   if (network_property_updated || network->update_requested()) {
 532     // Signal connection state changed after all properties have been updated.
 533     if (ConnectionStateChanged(network, prev_connection_state))
 534       OnNetworkConnectionStateChanged(network);
 535     NET_LOG_EVENT("NetworkPropertiesUpdated", GetLogName(network));
 536     NotifyNetworkPropertiesUpdated(network);
 537   }
 538 }
 539
 540 void NetworkStateHandler::UpdateNetworkServiceProperty(
 541     const std::string& service_path,
 542     const std::string& key,
 543     const base::Value& value) {
 544   bool changed = false;
 545   NetworkState* network = GetModifiableNetworkState(service_path);
 546   if (!network)
 547     return;
 548   std::string prev_connection_state = network->connection_state();
 549   std::string prev_profile_path = network->profile_path();
 550   changed |= network->PropertyChanged(key, value);
 551   if (!changed)
 552     return;
 553
 554   if (key == shill::kStateProperty || key == shill::kVisibleProperty) {
 555     network_list_sorted_ = false;
 556     if (ConnectionStateChanged(network, prev_connection_state)) {
 557       OnNetworkConnectionStateChanged(network);
 558       // If the connection state changes, other properties such as IPConfig
 559       // may have changed, so request a full update.
 560       RequestUpdateForNetwork(service_path);
 561     }
 562   } else {
 563     std::string value_str;
 564     value.GetAsString(&value_str);
 565     // Some property changes are noisy and not interesting:
 566     // * Wifi SignalStrength
 567     // * WifiFrequencyList updates
 568     // * Device property changes to "/" (occurs before a service is removed)
 569     if (key != shill::kSignalStrengthProperty &&
 570         key != shill::kWifiFrequencyListProperty &&
 571         (key != shill::kDeviceProperty || value_str != "/")) {
 572       std::string log_event = "NetworkPropertyUpdated";
 573       // Trigger a default network update for interesting changes only.
 574       if (network->path() == default_network_path_) {
 575         NotifyDefaultNetworkChanged(network);
 576         log_event = "Default" + log_event;
 577       }
 578       // Log event.
 579       std::string detail = network->name() + "." + key;
 580       detail += " = " + network_event_log::ValueAsString(value);
 581       network_event_log::LogLevel log_level;
 582       if (key == shill::kErrorProperty || key == shill::kErrorDetailsProperty) {
 583         log_level = network_event_log::LOG_LEVEL_ERROR;
 584       } else {
 585         log_level = network_event_log::LOG_LEVEL_EVENT;
 586       }
 587       NET_LOG_LEVEL(log_level, log_event, detail);
 588     }
 589   }
 590
 591   // All property updates signal 'NetworkPropertiesUpdated'.
 592   NotifyNetworkPropertiesUpdated(network);
 593
 594   // If added to a Profile, request a full update so that a NetworkState
 595   // gets created.
 596   if (prev_profile_path.empty() && !network->profile_path().empty())
 597     RequestUpdateForNetwork(service_path);
 598 }
 599
 600 void NetworkStateHandler::UpdateDeviceProperty(const std::string& device_path,
 601                                                const std::string& key,
 602                                                const base::Value& value) {
 603   DeviceState* device = GetModifiableDeviceState(device_path);
 604   if (!device)
 605     return;
 606   if (!device->PropertyChanged(key, value))
 607     return;
 608
 609   std::string detail = device->name() + "." + key;
 610   detail += " = " + network_event_log::ValueAsString(value);
 611   NET_LOG_EVENT("DevicePropertyUpdated", detail);
 612
 613   NotifyDeviceListChanged();
 614   NotifyDevicePropertiesUpdated(device);
 615
 616   if (key == shill::kScanningProperty && device->scanning() == false)
 617     ScanCompleted(device->type());
 618   if (key == shill::kEapAuthenticationCompletedProperty) {
 619     // Notify a change for each Ethernet service using this device.
 620     NetworkStateList ethernet_services;
 621     GetNetworkListByType(NetworkTypePattern::Ethernet(),
 622                          false /* configured_only */,
 623                          false /* visible_only */,
 624                          0 /* no limit */,
 625                          &ethernet_services);
 626     for (NetworkStateList::const_iterator it = ethernet_services.begin();
 627          it != ethernet_services.end(); ++it) {
 628       const NetworkState* ethernet_service = *it;
 629       if (ethernet_service->update_received() ||
 630           ethernet_service->device_path() != device->path()) {
 631         continue;
 632       }
 633       RequestUpdateForNetwork(ethernet_service->path());
 634     }
 635   }
 636 }
 637
 638 void NetworkStateHandler::UpdateIPConfigProperties(
 639     ManagedState::ManagedType type,
 640     const std::string& path,
 641     const std::string& ip_config_path,
 642     const base::DictionaryValue& properties)  {
 643   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
 644     NetworkState* network = GetModifiableNetworkState(path);
 645     if (!network)
 646       return;
 647     network->IPConfigPropertiesChanged(properties);
 648     NotifyNetworkPropertiesUpdated(network);
 649     if (network->path() == default_network_path_)
 650       NotifyDefaultNetworkChanged(network);
 651   } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
 652     DeviceState* device = GetModifiableDeviceState(path);
 653     if (!device)
 654       return;
 655     device->IPConfigPropertiesChanged(ip_config_path, properties);
 656     NotifyDevicePropertiesUpdated(device);
 657     if (!default_network_path_.empty()) {
 658       const NetworkState* default_network =
 659           GetNetworkState(default_network_path_);
 660       if (default_network && default_network->device_path() == path)
 661         NotifyDefaultNetworkChanged(default_network);
 662     }
 663   }
 664 }
 665
 666 void NetworkStateHandler::CheckPortalListChanged(
 667     const std::string& check_portal_list) {
 668   check_portal_list_ = check_portal_list;
 669 }
 670
 671 void NetworkStateHandler::TechnologyListChanged() {
 672   // Eventually we would like to replace Technology state with Device state.
 673   // For now, treat technology state changes as device list changes.
 674   NotifyDeviceListChanged();
 675 }
 676
 677 void NetworkStateHandler::ManagedStateListChanged(
 678     ManagedState::ManagedType type) {
 679   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
 680     SortNetworkList();
 681     UpdateNetworkStats();
 682     // Notify observers that the list of networks has changed.
 683     NET_LOG_EVENT("NOTIFY:NetworkListChanged",
 684                   base::StringPrintf("Size:%" PRIuS, network_list_.size()));
 685     FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
 686                       NetworkListChanged());
 687   } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
 688     std::string devices;
 689     for (ManagedStateList::const_iterator iter = device_list_.begin();
 690          iter != device_list_.end(); ++iter) {
 691       if (iter != device_list_.begin())
 692         devices += ", ";
 693       devices += (*iter)->name();
 694     }
 695     NET_LOG_EVENT("DeviceList", devices);
 696     NotifyDeviceListChanged();
 697   } else {
 698     NOTREACHED();
 699   }
 700 }
 701
 702 void NetworkStateHandler::SortNetworkList() {
 703   // Note: usually active networks will precede inactive networks, however
 704   // this may briefly be untrue during state transitions (e.g. a network may
 705   // transition to idle before the list is updated).
 706   ManagedStateList active, non_wifi_visible, wifi_visible, hidden, new_networks;
 707   for (ManagedStateList::iterator iter = network_list_.begin();
 708        iter != network_list_.end(); ++iter) {
 709     NetworkState* network = (*iter)->AsNetworkState();
 710     if (!network->update_received()) {
 711       new_networks.push_back(network);
 712       continue;
 713     }
 714     if (network->IsConnectedState() || network->IsConnectingState()) {
 715       active.push_back(network);
 716       continue;
 717     }
 718     if (network->visible()) {
 719       if (NetworkTypePattern::WiFi().MatchesType(network->type()))
 720         wifi_visible.push_back(network);
 721       else
 722         non_wifi_visible.push_back(network);
 723     } else {
 724       hidden.push_back(network);
 725     }
 726   }
 727   network_list_.clear();
 728   network_list_.insert(network_list_.end(), active.begin(), active.end());
 729   network_list_.insert(
 730       network_list_.end(), non_wifi_visible.begin(), non_wifi_visible.end());
 731   network_list_.insert(
 732       network_list_.end(), wifi_visible.begin(), wifi_visible.end());
 733   network_list_.insert(network_list_.end(), hidden.begin(), hidden.end());
 734   network_list_.insert(
 735       network_list_.end(), new_networks.begin(), new_networks.end());
 736   network_list_sorted_ = true;
 737 }
 738
 739 void NetworkStateHandler::UpdateNetworkStats() {
 740   size_t shared = 0, unshared = 0, visible = 0;
 741   for (ManagedStateList::iterator iter = network_list_.begin();
 742        iter != network_list_.end(); ++iter) {
 743     NetworkState* network = (*iter)->AsNetworkState();
 744     if (network->visible())
 745       ++visible;
 746     if (network->IsInProfile()) {
 747       if (network->IsPrivate())
 748         ++unshared;
 749       else
 750         ++shared;
 751     }
 752   }
 753   UMA_HISTOGRAM_COUNTS_100("Networks.Visible", visible);
 754   UMA_HISTOGRAM_COUNTS_100("Networks.RememberedShared", shared);
 755   UMA_HISTOGRAM_COUNTS_100("Networks.RememberedUnshared", unshared);
 756 }
 757
 758 void NetworkStateHandler::DefaultNetworkServiceChanged(
 759     const std::string& service_path) {
 760   // Shill uses '/' for empty service path values; check explicitly for that.
 761   const char* kEmptyServicePath = "/";
 762   std::string new_service_path =
 763       (service_path != kEmptyServicePath) ? service_path : "";
 764   if (new_service_path == default_network_path_)
 765     return;
 766
 767   default_network_path_ = service_path;
 768   NET_LOG_EVENT("DefaultNetworkServiceChanged:", default_network_path_);
 769   const NetworkState* network = NULL;
 770   if (!default_network_path_.empty()) {
 771     network = GetNetworkState(default_network_path_);
 772     if (!network) {
 773       // If NetworkState is not available yet, do not notify observers here,
 774       // they will be notified when the state is received.
 775       NET_LOG_DEBUG("Default NetworkState not available",
 776                     default_network_path_);
 777       return;
 778     }
 779   }
 780   if (network && !network->IsConnectedState()) {
 781     NET_LOG_ERROR(
 782         "DefaultNetwork is not connected: " + network->connection_state(),
 783         network->path());
 784   }
 785   NotifyDefaultNetworkChanged(network);
 786 }
 787
 788 //------------------------------------------------------------------------------
 789 // Private methods
 790
 791 void NetworkStateHandler::UpdateGuid(NetworkState* network) {
 792   std::string specifier = network->GetSpecifier();
 793   DCHECK(!specifier.empty());
 794   if (!network->guid().empty()) {
 795     // If the network is saved in a profile, remove the entry from the map.
 796     // Otherwise ensure that the entry matches the specified GUID. (e.g. in
 797     // case a visible network with a specified guid gets configured with a
 798     // new guid).
 799     if (network->IsInProfile())
 800       specifier_guid_map_.erase(specifier);
 801     else
 802       specifier_guid_map_[specifier] = network->guid();
 803     return;
 804   }
 805   // Ensure that the NetworkState has a valid GUID.
 806   std::string guid;
 807   SpecifierGuidMap::iterator iter = specifier_guid_map_.find(specifier);
 808   if (iter != specifier_guid_map_.end()) {
 809     guid = iter->second;
 810   } else {
 811     guid = base::GenerateGUID();
 812     specifier_guid_map_[specifier] = guid;
 813   }
 814   network->SetGuid(guid);
 815 }
 816
 817 void NetworkStateHandler::NotifyDeviceListChanged() {
 818   NET_LOG_DEBUG("NOTIFY:DeviceListChanged",
 819                 base::StringPrintf("Size:%" PRIuS, device_list_.size()));
 820   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
 821                     DeviceListChanged());
 822 }
 823
 824 DeviceState* NetworkStateHandler::GetModifiableDeviceState(
 825     const std::string& device_path) const {
 826   ManagedState* managed = GetModifiableManagedState(&device_list_, device_path);
 827   if (!managed)
 828     return NULL;
 829   return managed->AsDeviceState();
 830 }
 831
 832 NetworkState* NetworkStateHandler::GetModifiableNetworkState(
 833     const std::string& service_path) const {
 834   ManagedState* managed =
 835       GetModifiableManagedState(&network_list_, service_path);
 836   if (!managed)
 837     return NULL;
 838   return managed->AsNetworkState();
 839 }
 840
 841 ManagedState* NetworkStateHandler::GetModifiableManagedState(
 842     const ManagedStateList* managed_list,
 843     const std::string& path) const {
 844   for (ManagedStateList::const_iterator iter = managed_list->begin();
 845        iter != managed_list->end(); ++iter) {
 846     ManagedState* managed = *iter;
 847     if (managed->path() == path)
 848       return managed;
 849   }
 850   return NULL;
 851 }
 852
 853 NetworkStateHandler::ManagedStateList* NetworkStateHandler::GetManagedList(
 854     ManagedState::ManagedType type) {
 855   switch (type) {
 856     case ManagedState::MANAGED_TYPE_NETWORK:
 857       return &network_list_;
 858     case ManagedState::MANAGED_TYPE_DEVICE:
 859       return &device_list_;
 860   }
 861   NOTREACHED();
 862   return NULL;
 863 }
 864
 865 void NetworkStateHandler::OnNetworkConnectionStateChanged(
 866     NetworkState* network) {
 867   DCHECK(network);
 868   std::string event = "NetworkConnectionStateChanged";
 869   if (network->path() == default_network_path_) {
 870     event = "Default" + event;
 871     if (!network->IsConnectedState()) {
 872       NET_LOG_EVENT(
 873           "DefaultNetwork is not connected: " + network->connection_state(),
 874           network->path());
 875       default_network_path_.clear();
 876       SortNetworkList();
 877       NotifyDefaultNetworkChanged(NULL);
 878     }
 879   }
 880   NET_LOG_EVENT("NOTIFY:" + event + ": " + network->connection_state(),
 881                 GetLogName(network));
 882   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
 883                     NetworkConnectionStateChanged(network));
 884   if (network->path() == default_network_path_)
 885     NotifyDefaultNetworkChanged(network);
 886 }
 887
 888 void NetworkStateHandler::NotifyDefaultNetworkChanged(
 889     const NetworkState* default_network) {
 890   NET_LOG_EVENT("NOTIFY:DefaultNetworkChanged", GetLogName(default_network));
 891   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
 892                     DefaultNetworkChanged(default_network));
 893 }
 894
 895 void NetworkStateHandler::NotifyNetworkPropertiesUpdated(
 896     const NetworkState* network) {
 897   NET_LOG_DEBUG("NOTIFY:NetworkPropertiesUpdated", GetLogName(network));
 898   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
 899                     NetworkPropertiesUpdated(network));
 900 }
 901
 902 void NetworkStateHandler::NotifyDevicePropertiesUpdated(
 903     const DeviceState* device) {
 904   NET_LOG_DEBUG("NOTIFY:DevicePropertiesUpdated", GetLogName(device));
 905   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
 906                     DevicePropertiesUpdated(device));
 907 }
 908
 909 void NetworkStateHandler::ScanCompleted(const std::string& type) {
 910   size_t num_callbacks = scan_complete_callbacks_.count(type);
 911   NET_LOG_EVENT("ScanCompleted",
 912                 base::StringPrintf("%s:%" PRIuS, type.c_str(), num_callbacks));
 913   if (num_callbacks == 0)
 914     return;
 915   ScanCallbackList& callback_list = scan_complete_callbacks_[type];
 916   for (ScanCallbackList::iterator iter = callback_list.begin();
 917        iter != callback_list.end(); ++iter) {
 918     (*iter).Run();
 919   }
 920   scan_complete_callbacks_.erase(type);
 921 }
 922
 923 std::string NetworkStateHandler::GetTechnologyForType(
 924     const NetworkTypePattern& type) const {
 925   if (type.MatchesType(shill::kTypeEthernet))
 926     return shill::kTypeEthernet;
 927
 928   if (type.MatchesType(shill::kTypeWifi))
 929     return shill::kTypeWifi;
 930
 931   if (type.Equals(NetworkTypePattern::Wimax()))
 932     return shill::kTypeWimax;
 933
 934   // Prefer Wimax over Cellular only if it's available.
 935   if (type.MatchesType(shill::kTypeWimax) &&
 936       shill_property_handler_->IsTechnologyAvailable(shill::kTypeWimax)) {
 937     return shill::kTypeWimax;
 938   }
 939
 940   if (type.MatchesType(shill::kTypeCellular))
 941     return shill::kTypeCellular;
 942
 943   NOTREACHED();
 944   return std::string();
 945 }
 946
 947 ScopedVector<std::string> NetworkStateHandler::GetTechnologiesForType(
 948     const NetworkTypePattern& type) const {
 949   ScopedVector<std::string> technologies;
 950   if (type.MatchesType(shill::kTypeEthernet))
 951     technologies.push_back(new std::string(shill::kTypeEthernet));
 952   if (type.MatchesType(shill::kTypeWifi))
 953     technologies.push_back(new std::string(shill::kTypeWifi));
 954   if (type.MatchesType(shill::kTypeWimax))
 955     technologies.push_back(new std::string(shill::kTypeWimax));
 956   if (type.MatchesType(shill::kTypeCellular))
 957     technologies.push_back(new std::string(shill::kTypeCellular));
 958   if (type.MatchesType(shill::kTypeBluetooth))
 959     technologies.push_back(new std::string(shill::kTypeBluetooth));
 960   if (type.MatchesType(shill::kTypeVPN))
 961     technologies.push_back(new std::string(shill::kTypeVPN));
 962
 963   CHECK_GT(technologies.size(), 0ul);
 964   return technologies.Pass();
 965 }
 966
 967 }  // namespace chromeos