Revert of [CrOS Tether] Add the notion of a tether DeviceState.

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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/network/device_state.h"
-#include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_event_log.h"
-#include "chromeos/network/network_handler_callbacks.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler_observer.h"
 #include "chromeos/network/tether_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 bool ConnectionStateChanged(NetworkState* network,
@@ skipping 84 matching lines @@
       device_event_log::LOG_TYPE_NETWORK, device_event_log::LOG_LEVEL_DEBUG,
       base::StringPrintf("NetworkStateHandler::RemoveObserver: 0x%p",
                          observer));
 }
 
 NetworkStateHandler::TechnologyState NetworkStateHandler::GetTechnologyState(
     const NetworkTypePattern& type) const {
   std::string technology = GetTechnologyForType(type);
 
   if (technology == kTypeTether) {
-    return tether_technology_state_;
+    bool is_tether_enabled = base::CommandLine::ForCurrentProcess()->HasSwitch(
+        chromeos::switches::kEnableTether);
+    return is_tether_enabled ? TECHNOLOGY_ENABLED : TECHNOLOGY_UNAVAILABLE;
   }
 
   TechnologyState state;
   if (shill_property_handler_->IsTechnologyEnabled(technology))
     state = TECHNOLOGY_ENABLED;
   else if (shill_property_handler_->IsTechnologyEnabling(technology))
     state = TECHNOLOGY_ENABLING;
   else if (shill_property_handler_->IsTechnologyProhibited(technology))
     state = TECHNOLOGY_PROHIBITED;
   else if (shill_property_handler_->IsTechnologyUninitialized(technology))
     state = TECHNOLOGY_UNINITIALIZED;
   else if (shill_property_handler_->IsTechnologyAvailable(technology))
     state = TECHNOLOGY_AVAILABLE;
   else
     state = TECHNOLOGY_UNAVAILABLE;
   VLOG(2) << "GetTechnologyState: " << type.ToDebugString() << " = " << state;
   return state;
 }
 
 void NetworkStateHandler::SetTechnologyEnabled(
     const NetworkTypePattern& type,
     bool enabled,
     const network_handler::ErrorCallback& error_callback) {
   std::vector<std::string> technologies = GetTechnologiesForType(type);
   for (const std::string& technology : technologies) {
-    if (technology == kTypeTether) {
-      if (tether_technology_state_ != TECHNOLOGY_ENABLED &&
-          tether_technology_state_ != TECHNOLOGY_AVAILABLE) {
-        NET_LOG(ERROR) << "SetTechnologyEnabled() called for the Tether "
-                       << "DeviceState, but the current state was not "
-                       << "TECHNOLOGY_ENABLED or TECHNOLOGY_AVAILABLE.";
-        network_handler::RunErrorCallback(
-            error_callback, kTetherDevicePath,
-            NetworkConnectionHandler::kEnabledOrDisabledWhenNotAvailable, "");
-        continue;
-      }
-
-      // Tether does not exist in Shill, so set |tether_technology_state_| and
-      // skip the below interactions with |shill_property_handler_|.
-      tether_technology_state_ =
-          enabled ? TECHNOLOGY_ENABLED : TECHNOLOGY_AVAILABLE;
-      continue;
-    }
-
     if (!shill_property_handler_->IsTechnologyAvailable(technology))
       continue;
     NET_LOG_USER("SetTechnologyEnabled",
                  base::StringPrintf("%s:%d", technology.c_str(), enabled));
     shill_property_handler_->SetTechnologyEnabled(technology, enabled,
                                                   error_callback);
   }
   // Signal Device/Technology state changed.
   NotifyDeviceListChanged();
 }
 
-void NetworkStateHandler::SetTetherTechnologyState(
-    TechnologyState technology_state) {
-  if (tether_technology_state_ == technology_state)
-    return;
-
-  tether_technology_state_ = technology_state;
-  EnsureTetherDeviceState();
-
-  // Signal Device/Technology state changed.
-  NotifyDeviceListChanged();
-}
-
-void NetworkStateHandler::SetTetherScanState(bool is_scanning) {
-  DeviceState* tether_device_state =
-      GetModifiableDeviceState(kTetherDevicePath);
-  DCHECK(tether_device_state);
-
-  bool was_scanning = tether_device_state->scanning();
-  tether_device_state->set_scanning(is_scanning);
-
-  if (was_scanning && !is_scanning) {
-    // If a scan was in progress but has completed, notify observers.
-    NotifyScanCompleted(tether_device_state);
-  }
-}
-
 void NetworkStateHandler::SetProhibitedTechnologies(
     const std::vector<std::string>& prohibited_technologies,
     const network_handler::ErrorCallback& error_callback) {
-  // Make a copy of |prohibited_technologies| since the list may be edited
-  // within this function.
-  std::vector<std::string> prohibited_technologies_copy =
-      prohibited_technologies;
-
-  for (auto it = prohibited_technologies_copy.begin();
-       it < prohibited_technologies_copy.end(); ++it) {
-    if (*it == kTypeTether) {
-      // If Tether networks are prohibited, set |tether_technology_state_| and
-      // remove |kTypeTether| from the list before passing it to
-      // |shill_property_handler_| below. Shill does not have a concept of
-      // Tether networks, so it cannot prohibit that technology type.
-      tether_technology_state_ = TECHNOLOGY_PROHIBITED;
-      it = prohibited_technologies_copy.erase(it);
-    }
-  }
-
-  shill_property_handler_->SetProhibitedTechnologies(
-      prohibited_technologies_copy, error_callback);
+  shill_property_handler_->SetProhibitedTechnologies(prohibited_technologies,
+                                                     error_callback);
   // Signal Device/Technology state changed.
   NotifyDeviceListChanged();
 }
 
 const DeviceState* NetworkStateHandler::GetDeviceState(
     const std::string& device_path) const {
   const DeviceState* device = GetModifiableDeviceState(device_path);
   if (device && !device->update_received())
     return nullptr;
   return device;
@@ skipping 110 matching lines @@
   }
 
   return connecting_network;
 }
 
 const NetworkState* NetworkStateHandler::FirstNetworkByType(
     const NetworkTypePattern& type) {
   if (!network_list_sorted_)
     SortNetworkList();  // Sort to ensure visible networks are listed first.
 
-  // If |type| matches Tether networks and at least one Tether network is
+  // If |type| matches tether networks and at least one tether network is
   // present, return the first network (since it has been sorted already).
   if (type.MatchesPattern(NetworkTypePattern::Tether()) &&
       !tether_network_list_.empty()) {
     return tether_network_list_[0]->AsNetworkState();
   }
 
   for (auto iter = network_list_.begin(); iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
     if (!network->update_received())
       continue;
     if (!network->visible())
       break;
     if (network->Matches(type))
       return network;
   }
   return nullptr;
 }
 
 std::string NetworkStateHandler::FormattedHardwareAddressForType(
     const NetworkTypePattern& type) const {
   const NetworkState* network = ConnectedNetworkByType(type);
-  if (network && network->type() == kTypeTether) {
-    // If this is a Tether network, get the MAC address corresponding to that
-    // network instead.
-    network = GetNetworkStateFromGuid(network->tether_guid());
-  }
   const DeviceState* device = network ? GetDeviceState(network->device_path())
                                       : GetDeviceStateByType(type);
-  if (!device || device->mac_address().empty())
+  if (!device)
     return std::string();
   return network_util::FormattedMacAddress(device->mac_address());
 }
 
 void NetworkStateHandler::GetVisibleNetworkListByType(
     const NetworkTypePattern& type,
     NetworkStateList* list) {
   GetNetworkListByType(type, false /* configured_only */,
                        true /* visible_only */, 0 /* no limit */, list);
 }
@@ skipping 15 matching lines @@
     SortNetworkList();
 
   if (type.MatchesPattern(NetworkTypePattern::Tether())) {
     GetTetherNetworkList(limit, list);
   }
 
   int count = list->size();
 
   if (type.Equals(NetworkTypePattern::Tether()) ||
       (limit != 0 && count >= limit)) {
-    // If only searching for Tether networks, there is no need to continue
+    // If only searching for tether networks, there is no need to continue
     // searching through other network types; likewise, if the limit has already
     // been reached, there is no need to continue searching.
     return;
   }
 
   for (auto iter = network_list_.begin(); iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
     if (!network->update_received() || !network->Matches(type))
       continue;
@@ skipping 50 matching lines @@
 
 void NetworkStateHandler::AddTetherNetworkState(const std::string& guid,
                                                 const std::string& name,
                                                 const std::string& carrier,
                                                 int battery_percentage,
                                                 int signal_strength) {
   DCHECK(!guid.empty());
   DCHECK(battery_percentage >= 0 && battery_percentage <= 100);
   DCHECK(signal_strength >= 0 && signal_strength <= 100);
 
-  if (tether_technology_state_ != TECHNOLOGY_ENABLED) {
-    NET_LOG(ERROR) << "AddTetherNetworkState() called when Tether networks "
-                   << "are not enabled. Cannot add NetworkState.";
-    return;
-  }
-
   // If the network already exists, do nothing.
   if (GetNetworkStateFromGuid(guid)) {
     NET_LOG(ERROR) << "AddTetherNetworkState: " << name
                    << " called with existing guid:" << guid;
     return;
   }
 
   // Use the GUID as the network's service path.
   std::unique_ptr<NetworkState> tether_network_state =
       base::MakeUnique<NetworkState>(guid /* path */);
@@ skipping 11 matching lines @@
 
   tether_network_list_.push_back(std::move(tether_network_state));
   NotifyNetworkListChanged();
 }
 
 bool NetworkStateHandler::UpdateTetherNetworkProperties(
     const std::string& guid,
     const std::string& carrier,
     int battery_percentage,
     int signal_strength) {
-  if (tether_technology_state_ != TECHNOLOGY_ENABLED) {
-    NET_LOG(ERROR) << "UpdateTetherNetworkProperties() called when Tether "
-                   << "networks are not enabled. Cannot update.";
-    return false;
-  }
-
   NetworkState* tether_network_state = GetModifiableNetworkStateFromGuid(guid);
   if (!tether_network_state)
     return false;
 
   tether_network_state->set_carrier(carrier);
   tether_network_state->set_battery_percentage(battery_percentage);
   tether_network_state->set_signal_strength(signal_strength);
 
   NotifyNetworkListChanged();
   return true;
@@ skipping 11 matching lines @@
       tether_network_list_.erase(iter);
       NotifyNetworkListChanged();
       return;
     }
   }
 }
 
 bool NetworkStateHandler::AssociateTetherNetworkStateWithWifiNetwork(
     const std::string& tether_network_guid,
     const std::string& wifi_network_guid) {
-  if (tether_technology_state_ != TECHNOLOGY_ENABLED) {
-    NET_LOG(ERROR) << "AssociateTetherNetworkStateWithWifiNetwork() called "
-                   << "when Tether networks are not enabled. Cannot "
-                   << "associate.";
-    return false;
-  }
-
   NetworkState* tether_network =
       GetModifiableNetworkStateFromGuid(tether_network_guid);
   if (!tether_network) {
     NET_LOG(ERROR) << "Tether network does not exist: " << tether_network_guid;
     return false;
   }
   if (!NetworkTypePattern::Tether().MatchesType(tether_network->type())) {
     NET_LOG(ERROR) << "Network is not a Tether network: "
                    << tether_network_guid;
     return false;
@@ skipping 11 matching lines @@
   }
 
   tether_network->set_tether_guid(wifi_network_guid);
   wifi_network->set_tether_guid(tether_network_guid);
   NotifyNetworkListChanged();
   return true;
 }
 
 void NetworkStateHandler::SetTetherNetworkStateDisconnected(
     const std::string& guid) {
-  // TODO(khorimoto): Remove the Tether network as the default network, and
+  // TODO(khorimoto): Remove the tether network as the default network, and
   // send a connection status change.
   SetTetherNetworkStateConnectionState(guid, shill::kStateDisconnect);
 }
 
 void NetworkStateHandler::SetTetherNetworkStateConnecting(
     const std::string& guid) {
-  // TODO(khorimoto): Set the Tether network as the default network, and send
+  // TODO(khorimoto): Set the tether network as the default network, and send
   // a connection status change.
   SetTetherNetworkStateConnectionState(guid, shill::kStateConfiguration);
 }
 
 void NetworkStateHandler::SetTetherNetworkStateConnected(
     const std::string& guid) {
   // Being connected implies that AssociateTetherNetworkStateWithWifiNetwork()
   // was already called, so ensure that the association is still intact.
   DCHECK(GetNetworkStateFromGuid(GetNetworkStateFromGuid(guid)->tether_guid())
              ->tether_guid() == guid);
@@ skipping 11 matching lines @@
                    << "not found: " << guid;
     return;
   }
 
   DCHECK(NetworkTypePattern::Tether().MatchesType(tether_network->type()));
 
   tether_network->set_connection_state(connection_state);
   NotifyNetworkListChanged();
 }
 
-void NetworkStateHandler::EnsureTetherDeviceState() {
-  bool should_be_present =
-      tether_technology_state_ != TechnologyState::TECHNOLOGY_UNAVAILABLE;
-
-  for (auto it = device_list_.begin(); it < device_list_.end(); ++it) {
-    std::string path = (*it)->path();
-    if (path == kTetherDevicePath) {
-      // If the Tether DeviceState is in the list and it should not be, remove
-      // it and return. If it is in the list and it should be, the list is
-      // already valid, so return without removing it.
-      if (!should_be_present)
-        device_list_.erase(it);
-      return;
-    }
-  }
-
-  if (!should_be_present) {
-    // If the Tether DeviceState was not in the list and it should not be, the
-    // list is already valid, so return.
-    return;
-  }
-
-  // The Tether DeviceState is not present in the list, but it should be. Since
-  // Tether networks are not recognized by Shill, they will never receive an
-  // update, so set properties on the state here.
-  std::unique_ptr<ManagedState> tether_device_state = ManagedState::Create(
-      ManagedState::ManagedType::MANAGED_TYPE_DEVICE, kTetherDevicePath);
-  tether_device_state->set_update_received();
-  tether_device_state->set_update_requested(false);
-  tether_device_state->set_name(kTetherDeviceName);
-  tether_device_state->set_type(kTypeTether);
-
-  device_list_.push_back(std::move(tether_device_state));
-}
-
 void NetworkStateHandler::GetDeviceList(DeviceStateList* list) const {
   GetDeviceListByType(NetworkTypePattern::Default(), list);
 }
 
 void NetworkStateHandler::GetDeviceListByType(const NetworkTypePattern& type,
                                               DeviceStateList* list) const {
   DCHECK(list);
   list->clear();
-
   for (auto 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::RequestScan() const {
   NET_LOG_USER("RequestScan", "");
@@ skipping 134 matching lines @@
         continue;
       }
       managed_list->push_back(ManagedState::Create(type, path));
     } else {
       managed_list->push_back(std::move(found->second));
       managed_map.erase(found);
     }
     list_entries.insert(path);
   }
 
-  if (type == ManagedState::ManagedType::MANAGED_TYPE_DEVICE) {
-    // Also move the Tether DeviceState if it exists. This will not happen as
-    // part of the loop above since |entries| will never contain the Tether
-    // path.
-    auto iter = managed_map.find(kTetherDevicePath);
-    if (iter != managed_map.end()) {
-      managed_list->push_back(std::move(iter->second));
-      managed_map.erase(iter);
-    }
-  }
-
   if (type != ManagedState::ManagedType::MANAGED_TYPE_NETWORK)
     return;
 
   // Remove associations Tether NetworkStates had with now removed Wi-Fi
   // NetworkStates.
   for (auto& iter : managed_map) {
     if (!iter.second->Matches(NetworkTypePattern::WiFi()))
       continue;
 
     NetworkState* tether_network = GetModifiableNetworkStateFromGuid(
@@ skipping 225 matching lines @@
         devices += ", ";
       devices += (*iter)->name();
     }
     NET_LOG_EVENT("DeviceList", devices);
     NotifyDeviceListChanged();
   } else {
     NOTREACHED();
   }
 }
 
-// TODO(khorimoto): Add sorting for the Tether network list as well.
+// TODO(khorimoto): Add sorting for the tether network list as well.
 void NetworkStateHandler::SortNetworkList() {
   // Note: usually active networks will precede inactive networks, however
   // this may briefly be untrue during state transitions (e.g. a network may
   // transition to idle before the list is updated).
   ManagedStateList active, non_wifi_visible, wifi_visible, hidden, new_networks;
   for (ManagedStateList::iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     NetworkState* network = (*iter)->AsNetworkState();
     if (!network->update_received()) {
       new_networks.push_back(std::move(*iter));
@@ skipping 283 matching lines @@
   if (type.MatchesType(shill::kTypeWifi))
     technologies.emplace_back(shill::kTypeWifi);
   if (type.MatchesType(shill::kTypeWimax))
     technologies.emplace_back(shill::kTypeWimax);
   if (type.MatchesType(shill::kTypeCellular))
     technologies.emplace_back(shill::kTypeCellular);
   if (type.MatchesType(shill::kTypeBluetooth))
     technologies.emplace_back(shill::kTypeBluetooth);
   if (type.MatchesType(shill::kTypeVPN))
     technologies.emplace_back(shill::kTypeVPN);
-  if (type.MatchesType(kTypeTether))
-    technologies.emplace_back(kTypeTether);
 
   CHECK_GT(technologies.size(), 0ul);
   return technologies;
 }
 
 }  // namespace chromeos