Prevent that uninitialized ManagedState objects are returned from NetworkStateHandler.

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/metrics/histogram.h"
@@ skipping 150 matching lines @@
   NET_LOG_USER("SetTechnologyEnabled",
                base::StringPrintf("%s:%d", technology.c_str(), enabled));
   shill_property_handler_->SetTechnologyEnabled(
       technology, enabled, error_callback);
   // Signal Technology state changed -> ENABLING
   NotifyManagerPropertyChanged();
 }
 
 const DeviceState* NetworkStateHandler::GetDeviceState(
     const std::string& device_path) const {
-  return GetModifiableDeviceState(device_path);
+  const DeviceState* device = GetModifiableDeviceState(device_path);
+  DCHECK(!device || device->update_received());
+  return device;
 }
 
 const DeviceState* NetworkStateHandler::GetDeviceStateByType(
     const std::string& type) const {
   for (ManagedStateList::const_iterator iter = device_list_.begin();
        iter != device_list_.end(); ++iter) {
     ManagedState* device = *iter;
+    if (!device->update_received())
+      continue;
     if (ManagedStateMatchesType(device, type))
       return device->AsDeviceState();
   }
   return NULL;
 }
 
 bool NetworkStateHandler::GetScanningByType(const std::string& type) const {
   for (ManagedStateList::const_iterator iter = device_list_.begin();
        iter != device_list_.end(); ++iter) {
     const DeviceState* device = (*iter)->AsDeviceState();
     DCHECK(device);
+    if (!device->update_received())
+      continue;
     if (ManagedStateMatchesType(device, type) && device->scanning())
       return true;
   }
   return false;
 }
 
 const NetworkState* NetworkStateHandler::GetNetworkState(
     const std::string& service_path) const {
-  return GetModifiableNetworkState(service_path);
+  const NetworkState* network = GetModifiableNetworkState(service_path);
+  DCHECK(!network || network->update_received());
+  return network;
 }
 
 const NetworkState* NetworkStateHandler::DefaultNetwork() const {
   if (network_list_.empty())
     return NULL;
   const NetworkState* network = network_list_.front()->AsNetworkState();
   DCHECK(network);
-  if (!network->IsConnectedState())
+  if (!network->update_received() || !network->IsConnectedState())
     return NULL;
   return network;
 }
 
 const NetworkState* NetworkStateHandler::ConnectedNetworkByType(
     const std::string& type) const {
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
+    if (!network->update_received())
+      continue;
     if (!network->IsConnectedState())
       break;  // Connected networks are listed first.
     if (ManagedStateMatchesType(network, type))
       return network;
   }
   return NULL;
 }
 
 const NetworkState* NetworkStateHandler::ConnectingNetworkByType(
     const std::string& type) const {
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
-    if (network->IsConnectedState())
+    if (!network->update_received() || network->IsConnectedState())
       continue;
     if (!network->IsConnectingState())
       break;  // Connected and connecting networks are listed first.
     if (ManagedStateMatchesType(network, type))
       return network;
   }
   return NULL;
 }
 
 const NetworkState* NetworkStateHandler::FirstNetworkByType(
     const std::string& type) const {
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
+    if (!network->update_received())
+      continue;
     if (ManagedStateMatchesType(network, type))
       return network;
   }
   return NULL;
 }
 
 std::string NetworkStateHandler::HardwareAddressForType(
     const std::string& type) const {
-  std::string result;
   const NetworkState* network = ConnectedNetworkByType(type);
-  if (network) {
-    const DeviceState* device = GetDeviceState(network->device_path());
-    if (device)
-      result = device->mac_address();
-  }
+  if (!network)
+    return std::string();
+  const DeviceState* device = GetDeviceState(network->device_path());
+  if (!device)
+    return std::string();
+  std::string result = device->mac_address();
   StringToUpperASCII(&result);
   return result;
 }
 
 std::string NetworkStateHandler::FormattedHardwareAddressForType(
     const std::string& type) const {
   std::string address = HardwareAddressForType(type);
   if (address.size() % 2 != 0)
     return address;
   std::string result;
   for (size_t i = 0; i < address.size(); ++i) {
     if ((i != 0) && (i % 2 == 0))
       result.push_back(':');
     result.push_back(address[i]);
   }
   return result;
 }
 
 void NetworkStateHandler::GetNetworkList(NetworkStateList* list) const {
   GetNetworkListByType(kMatchTypeDefault, list);
 }
 
 void NetworkStateHandler::GetNetworkListByType(const std::string& type,
                                                NetworkStateList* list) const {
   DCHECK(list);
   list->clear();
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
-    if (!(*iter)->update_received())
-      continue;
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
+    if (!network->update_received())
+      continue;
     if (ManagedStateMatchesType(network, type))
       list->push_back(network);
   }
 }
 
 void NetworkStateHandler::GetDeviceList(DeviceStateList* list) const {
   DCHECK(list);
   list->clear();
   for (ManagedStateList::const_iterator iter = device_list_.begin();
        iter != device_list_.end(); ++iter) {
-    if (!(*iter)->update_received())
-      continue;
     const DeviceState* device = (*iter)->AsDeviceState();
     DCHECK(device);
+    if (!device->update_received())
+      continue;
     list->push_back(device);
   }
 }
 
 void NetworkStateHandler::GetFavoriteList(FavoriteStateList* list) const {
   DCHECK(list);
   FavoriteStateList result;
   list->clear();
   for (ManagedStateList::const_iterator iter = favorite_list_.begin();
        iter != favorite_list_.end(); ++iter) {
-    if (!(*iter)->update_received())
-      continue;
     const FavoriteState* favorite = (*iter)->AsFavoriteState();
     DCHECK(favorite);
+    if (!favorite->update_received())
+      continue;
     if (favorite->is_favorite())
       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;
+  DCHECK(managed->update_received());
   return managed->AsFavoriteState();
 }
 
 void NetworkStateHandler::RequestScan() const {
   NET_LOG_USER("RequestScan", "");
   shill_property_handler_->RequestScan();
 }
 
 void NetworkStateHandler::WaitForScan(const std::string& type,
                                       const base::Closure& callback) {
@@ skipping 398 matching lines @@
   }
   if (type == kMatchTypeDefault || type == kMatchTypeNonVirtual ||
       type == kMatchTypeWireless) {
     NOTREACHED();
     return flimflam::kTypeWifi;
   }
   return type;
 }
 
 }  // namespace chromeos