Migrate DBus service constants from flimflam namespace to shill namespace.

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 11 matching lines @@
 #include "chromeos/network/shill_property_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 bool ConnectionStateChanged(NetworkState* network,
                             const std::string& prev_connection_state) {
   return (network->connection_state() != prev_connection_state) &&
-         (network->connection_state() != flimflam::kStateIdle ||
+         (network->connection_state() != shill::kStateIdle ||
           !prev_connection_state.empty());
 }
 
 std::string GetManagedStateLogType(const ManagedState* state) {
   switch (state->managed_type()) {
     case ManagedState::MANAGED_TYPE_NETWORK:
       return "Network";
     case ManagedState::MANAGED_TYPE_FAVORITE:
       return "Favorite";
     case ManagedState::MANAGED_TYPE_DEVICE:
@@ skipping 280 matching lines @@
 
 void NetworkStateHandler::WaitForScan(const std::string& type,
                                       const base::Closure& callback) {
   scan_complete_callbacks_[type].push_back(callback);
   if (!GetScanningByType(NetworkTypePattern::Primitive(type)))
     RequestScan();
 }
 
 void NetworkStateHandler::ConnectToBestWifiNetwork() {
   NET_LOG_USER("ConnectToBestWifiNetwork", "");
-  WaitForScan(flimflam::kTypeWifi,
+  WaitForScan(shill::kTypeWifi,
               base::Bind(&internal::ShillPropertyHandler::ConnectToBestServices,
                          shill_property_handler_->AsWeakPtr()));
 }
 
 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);
@@ skipping 156 matching lines @@
 
   // Update the NetworkState.
   NetworkState* network = GetModifiableNetworkState(service_path);
   if (!network)
     return;
   std::string prev_connection_state = network->connection_state();
   std::string prev_profile_path = network->profile_path();
   if (!network->PropertyChanged(key, value))
     return;
 
-  if (key == flimflam::kStateProperty) {
+  if (key == shill::kStateProperty) {
     if (ConnectionStateChanged(network, prev_connection_state)) {
       OnNetworkConnectionStateChanged(network);
       // If the connection state changes, other properties such as IPConfig
       // may have changed, so request a full update.
       RequestUpdateForNetwork(service_path);
     }
   } else {
     bool noisy_property =
-        key == flimflam::kSignalStrengthProperty ||
+        key == shill::kSignalStrengthProperty ||
         key == shill::kWifiFrequencyListProperty;
     if (network->path() == default_network_path_ && !noisy_property) {
       // Wifi SignalStrength and WifiFrequencyList updates are too noisy, so
       // don't trigger default network updates for those changes.
       OnDefaultNetworkChanged();
     }
     if (prev_profile_path.empty() && !network->profile_path().empty()) {
       // If added to a Profile, request a full update so that a FavoriteState
       // gets created.
       RequestUpdateForNetwork(service_path);
     }
     if (!noisy_property) {
       std::string detail = network->name() + "." + key;
       detail += " = " + network_event_log::ValueAsString(value);
       network_event_log::LogLevel log_level;
-      if (key == flimflam::kErrorProperty ||
-          key == shill::kErrorDetailsProperty) {
+      if (key == shill::kErrorProperty || key == shill::kErrorDetailsProperty) {
         log_level = network_event_log::LOG_LEVEL_ERROR;
       } else {
         log_level = network_event_log::LOG_LEVEL_EVENT;
       }
       NET_LOG_LEVEL(log_level, "NetworkPropertyUpdated", detail);
     }
   }
   NetworkPropertiesUpdated(network);
 }
 
 void NetworkStateHandler::UpdateDeviceProperty(const std::string& device_path,
                                                const std::string& key,
                                                const base::Value& value) {
   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);
 
   NotifyDeviceListChanged();
 
-  if (key == flimflam::kScanningProperty && device->scanning() == false)
+  if (key == shill::kScanningProperty && device->scanning() == false)
     ScanCompleted(device->type());
 }
 
 void NetworkStateHandler::CheckPortalListChanged(
     const std::string& check_portal_list) {
   check_portal_list_ = check_portal_list;
 }
 
 void NetworkStateHandler::TechnologyListChanged() {
   // Eventually we would like to replace Technology state with Device state.
@@ skipping 140 matching lines @@
   ScanCallbackList& callback_list = scan_complete_callbacks_[type];
   for (ScanCallbackList::iterator iter = callback_list.begin();
        iter != callback_list.end(); ++iter) {
     (*iter).Run();
   }
   scan_complete_callbacks_.erase(type);
 }
 
 std::string NetworkStateHandler::GetTechnologyForType(
     const NetworkTypePattern& type) const {
-  if (type.MatchesType(flimflam::kTypeEthernet))
-    return flimflam::kTypeEthernet;
+  if (type.MatchesType(shill::kTypeEthernet))
+    return shill::kTypeEthernet;
 
-  if (type.MatchesType(flimflam::kTypeWifi))
-    return flimflam::kTypeWifi;
+  if (type.MatchesType(shill::kTypeWifi))
+    return shill::kTypeWifi;
 
   if (type.Equals(NetworkTypePattern::Wimax()))
-      return flimflam::kTypeWimax;
+    return shill::kTypeWimax;
 
   // Prefer Wimax over Cellular only if it's available.
-  if (type.MatchesType(flimflam::kTypeWimax) &&
-      shill_property_handler_->IsTechnologyAvailable(flimflam::kTypeWimax)) {
-      return flimflam::kTypeWimax;
+  if (type.MatchesType(shill::kTypeWimax) &&
+      shill_property_handler_->IsTechnologyAvailable(shill::kTypeWimax)) {
+    return shill::kTypeWimax;
   }
 
-  if (type.MatchesType(flimflam::kTypeCellular))
-      return flimflam::kTypeCellular;
+  if (type.MatchesType(shill::kTypeCellular))
+    return shill::kTypeCellular;
 
   NOTREACHED();
   return std::string();
 }
 
 }  // namespace chromeos