Eliminate NetworkManagerChanged

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 113 matching lines @@
 
 void NetworkStateHandler::SetTechnologyEnabled(
     const NetworkTypePattern& type,
     bool enabled,
     const network_handler::ErrorCallback& error_callback) {
   std::string technology = GetTechnologyForType(type);
   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();
+  // Signal Device/Technology state changed.
+  NotifyDeviceListChanged();
 }
 
 const DeviceState* NetworkStateHandler::GetDeviceState(
     const std::string& device_path) const {
   const DeviceState* device = GetModifiableDeviceState(device_path);
   DCHECK(!device || device->update_received());
   return device;
 }
 
 const DeviceState* NetworkStateHandler::GetDeviceStateByType(
@@ skipping 404 matching lines @@
   DeviceState* device = GetModifiableDeviceState(device_path);
   if (!device)
     return;
   if (!device->PropertyChanged(key, value))
     return;
 
   std::string detail = device->name() + "." + key;
   detail += " = " + network_event_log::ValueAsString(value);
   NET_LOG_EVENT("DevicePropertyUpdated", detail);
 
-  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                    DeviceListChanged());
+  NotifyDeviceListChanged();
 
   if (key == flimflam::kScanningProperty && device->scanning() == false)
     ScanCompleted(device->type());
 }
 
 void NetworkStateHandler::CheckPortalListChanged(
     const std::string& check_portal_list) {
   check_portal_list_ = check_portal_list;
 }
 
-void NetworkStateHandler::NotifyManagerPropertyChanged() {
-  NET_LOG_DEBUG("NotifyManagerPropertyChanged", "");
-  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                    NetworkManagerChanged());
+void NetworkStateHandler::TechnologyListChanged() {
+  // Eventually we would like to replace Technology state with Device state.
+  // For now, treat technology state changes as device list changes.
+  NotifyDeviceListChanged();
 }
 
 void NetworkStateHandler::ManagedStateListChanged(
     ManagedState::ManagedType type) {
   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
     // Notify observers that the list of networks has changed.
     NET_LOG_EVENT("NetworkListChanged",
                   base::StringPrintf("Size:%" PRIuS, network_list_.size()));
     FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                       NetworkListChanged());
@@ skipping 16 matching lines @@
       if (!favorite->is_favorite())
         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) {
-    NET_LOG_DEBUG("DeviceListChanged",
-                  base::StringPrintf("Size:%" PRIuS, device_list_.size()));
-    FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                      DeviceListChanged());
+    NotifyDeviceListChanged();
   } else {
     NOTREACHED();
   }
 }
 
 //------------------------------------------------------------------------------
 // Private methods
 
+void NetworkStateHandler::NotifyDeviceListChanged() {
+  NET_LOG_DEBUG("NotifyDeviceListChanged",
+                base::StringPrintf("Size:%" PRIuS, device_list_.size()));
+  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
+                    DeviceListChanged());
+}
+
 DeviceState* NetworkStateHandler::GetModifiableDeviceState(
     const std::string& device_path) const {
   ManagedState* managed = GetModifiableManagedState(&device_list_, device_path);
   if (!managed)
     return NULL;
   return managed->AsDeviceState();
 }
 
 NetworkState* NetworkStateHandler::GetModifiableNetworkState(
     const std::string& service_path) const {
@@ skipping 99 matching lines @@
   }
 
   if (type.MatchesType(flimflam::kTypeCellular))
       return flimflam::kTypeCellular;
 
   NOTREACHED();
   return std::string();
 }
 
 }  // namespace chromeos