Create a Tether section in the system tray network list.

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/logging.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_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler_observer.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
@@ skipping 94 matching lines @@
   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
+  else if (technology == kTypeTether) {

[Ryan Hansberry, 2017/02/16 22:42:20]

(holding off on writing a test until I get the clear on this implementation)

+    bool isTetherAvailable = base::CommandLine::ForCurrentProcess()->HasSwitch(
+        chromeos::switches::kEnableTether);
+    if (isTetherAvailable) {
+      // TODO (hansberry): Figure this one out.
+      bool isTetherEnabled = true;
+      if (isTetherEnabled) {
+        return TECHNOLOGY_ENABLED;
+      }
+      return 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);
@@ skipping 46 matching lines @@
       continue;
     if (device->Matches(type) && device->scanning())
       return true;
   }
   return false;
 }
 
 const NetworkState* NetworkStateHandler::GetNetworkState(
     const std::string& service_path) const {
   const NetworkState* network = GetModifiableNetworkState(service_path);
+  // This is a hack that I don't intend to keep here.
+  if (!network) {
+    return GetNetworkStateFromGuid(service_path);
+  }
   if (network && !network->update_received())
     return nullptr;
   return network;
 }
 
 const NetworkState* NetworkStateHandler::DefaultNetwork() const {
   if (default_network_path_.empty())
     return nullptr;
   return GetNetworkState(default_network_path_);
 }
@@ skipping 69 matching lines @@
 }
 
 void NetworkStateHandler::GetNetworkListByType(const NetworkTypePattern& type,
                                                bool configured_only,
                                                bool visible_only,
                                                int limit,
                                                NetworkStateList* list) {
   DCHECK(list);
   list->clear();
   int count = 0;
+
+  if (NetworkTypePattern::Tether().MatchesPattern(type)) {

[Ryan Hansberry, 2017/02/16 22:42:20]

Should there actually just be a GetTetherNetworkList()? The arguments like
configured_only and visible_only don't apply to Tether networks. 

(Held off on writing a test until this is resolved)

[Ryan Hansberry, 2017/02/17 19:29:42]

Ping.

[stevenjb, 2017/02/17 20:11:10]

That seems fine also, although this would allow us to create a
NonVirtualWithTether pattern to use when we integrate this with settings and the
extension API, although right now the ordering isn't quite correct... (the
connected network is always expected to be first).

I think for the foreseeable future tether networks will be a special case, so
yeah, I would make it a separate call.

[Ryan Hansberry, 2017/02/17 23:28:13]

Done.

+    for (auto iter = tether_network_list_.begin();
+         iter != tether_network_list_.end(); ++iter) {
+      list->push_back((*iter)->AsNetworkState());
+      if (limit > 0 && ++count >= limit)
+        return;
+    }
+  }
+
   // Sort the network list if necessary.
   if (!network_list_sorted_)
     SortNetworkList();
   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;
     if (configured_only && !network->IsInProfile())
       continue;
@@ skipping 719 matching lines @@
 
   // Prefer Wimax over Cellular only if it's available.
   if (type.MatchesType(shill::kTypeWimax) &&
       shill_property_handler_->IsTechnologyAvailable(shill::kTypeWimax)) {
     return shill::kTypeWimax;
   }
 
   if (type.MatchesType(shill::kTypeCellular))
     return shill::kTypeCellular;
 
+  if (type.MatchesType(kTypeTether))
+    return kTypeTether;
+
   NOTREACHED();
   return std::string();
 }
 
 std::vector<std::string> NetworkStateHandler::GetTechnologiesForType(
     const NetworkTypePattern& type) const {
   std::vector<std::string> technologies;
   if (type.MatchesType(shill::kTypeEthernet))
     technologies.emplace_back(shill::kTypeEthernet);
   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);
 
   CHECK_GT(technologies.size(), 0ul);
   return technologies;
 }
 
 }  // namespace chromeos