[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"
@@ skipping 108 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) {
-    bool is_tether_enabled = base::CommandLine::ForCurrentProcess()->HasSwitch(
-        chromeos::switches::kEnableTether);
-    return is_tether_enabled ? TECHNOLOGY_ENABLED : TECHNOLOGY_UNAVAILABLE;
+    return tether_state_;
   }
 
   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) {
+      // Tether does not exist in Shill, so call SetTetherTechnologyState() and

[Ryan Hansberry, 2017/04/20 01:38:35]

The comment suggests that SetTetherTechnologyState() is called here but I don't
see a call.

[Kyle Horimoto, 2017/04/20 02:16:08]

Done.

+      // skip the below interactions with |shill_property_handler_|.
+      tether_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_state_ == technology_state)
+    return;
+
+  tether_state_ = technology_state;
+
+  // 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) {
-  shill_property_handler_->SetProhibitedTechnologies(prohibited_technologies,
-                                                     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 tethering is prohibited, set |tether_state_| and remove tethering

[Ryan Hansberry, 2017/04/20 01:38:35]

Tether*

[Kyle Horimoto, 2017/04/20 02:16:08]

Done.

+      // 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_state_ = TECHNOLOGY_PROHIBITED;
+      it = prohibited_technologies_copy.erase(it);
+    }
+  }
+
+  shill_property_handler_->SetProhibitedTechnologies(
+      prohibited_technologies_copy, 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 133 matching lines @@
       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());

[Ryan Hansberry, 2017/04/20 01:38:35]

Just return empty string here instead.

[Kyle Horimoto, 2017/04/20 02:16:08]

I don't think we should - we should return the MAC address corresponding to the
Wi-Fi network.

[Ryan Hansberry, 2017/04/20 16:53:54]

But we know at this point that the network does not have a MAC address, because
it's a Tether network. Perhaps I'm misunderstanding -- do Tether networks now do
have MAC addresses?

[Kyle Horimoto, 2017/04/20 19:38:46]

stevenjb@, can you comment on this?

[stevenjb, 2017/04/20 20:01:10]

Why wouldn't a tether network show the MAC address of the hotspot? When I set up
my phone as a hotspot and connect to it it has a valid MAC address. (I'm not
sure how useful that is, but for some purposes it may be, and from Chrome's
perspective that *is* the MAC address).

[Ryan Hansberry, 2017/04/20 21:27:02]

If that's the case, then we should return the mac_address() of the WiFi network,
not the Tether network (presumably an empty string).

[Kyle Horimoto, 2017/04/20 21:28:45]

That's what I'm already doing ;)

+  }
   const DeviceState* device = network ? GetDeviceState(network->device_path())
                                       : GetDeviceStateByType(type);
-  if (!device)
+  if (!device || device->mac_address().empty())
     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 85 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);
+  DCHECK(tether_state_ == TECHNOLOGY_ENABLED);
 
   // 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 =
@@ skipping 12 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) {
+  DCHECK(tether_state_ == TECHNOLOGY_ENABLED);
+
   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) {
+  DCHECK(tether_state_ == TECHNOLOGY_ENABLED);
+
   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 179 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 // ShillPropertyHandler::Delegate overrides
 
 void NetworkStateHandler::UpdateManagedList(ManagedState::ManagedType type,
                                             const base::ListValue& entries) {
   ManagedStateList* managed_list = GetManagedList(type);
   NET_LOG_DEBUG("UpdateManagedList: " + ManagedState::TypeToString(type),
                 base::StringPrintf("%" PRIuS, entries.GetSize()));
+
+  // Create a copy of |entries| since it may be edited below.
+  base::ListValue entries_copy(entries);
+  if (type == ManagedState::ManagedType::MANAGED_TYPE_DEVICE) {
+    // If a device list update is received from Shill, the list supplied will
+    // never contain an entry for tether networks since Shill does not recognize
+    // tether networks as a device type. Before processing the list, add an
+    // entry for the tether device type with the constant tether device path.
+    entries_copy.Append(base::MakeUnique<base::Value>(kTetherDevicePath));
+  }
+
   // Create a map of existing entries. Assumes all entries in |managed_list|
   // are unique.
   std::map<std::string, std::unique_ptr<ManagedState>> managed_map;
   for (auto& item : *managed_list) {
     std::string path = item->path();
     DCHECK(!base::ContainsKey(managed_map, path));
     managed_map[path] = std::move(item);
   }
   // Clear the list (objects are temporarily owned by managed_map).
   managed_list->clear();
   // Updates managed_list and request updates for new entries.
   std::set<std::string> list_entries;
-  for (auto& iter : entries) {
+  for (auto& iter : entries_copy) {
     std::string path;
     iter.GetAsString(&path);
     if (path.empty() || path == shill::kFlimflamServicePath) {
       NET_LOG_ERROR(base::StringPrintf("Bad path in list:%d", type), path);
       continue;
     }
     auto found = managed_map.find(path);
     if (found == managed_map.end()) {
       if (list_entries.count(path) != 0) {
         NET_LOG_ERROR("Duplicate entry in list", path);
         continue;
       }
-      managed_list->push_back(ManagedState::Create(type, path));
+      std::unique_ptr<ManagedState> state = ManagedState::Create(type, path);
+      if (type == ManagedState::ManagedType::MANAGED_TYPE_DEVICE &&
+          path == kTetherDevicePath) {
+        // If adding the tether DeviceState, set appropriate properties since
+        // it will never receive a properties update from Shill.
+        state->set_update_received();
+        state->set_update_requested(false);
+        state->set_name(kTetherDeviceName);
+        state->set_type(kTypeTether);
+      }
+      managed_list->push_back(std::move(state));
     } else {
       managed_list->push_back(std::move(found->second));
       managed_map.erase(found);
     }
     list_entries.insert(path);
   }
 
   if (type != ManagedState::ManagedType::MANAGED_TYPE_NETWORK)
     return;
 
@@ skipping 536 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