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) {
+    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;

[stevenjb, 2017/02/16 22:56:35]

Avoid the placeholder code, just return TECHNOLOGY_ENABLED (i.e. eliminate the
bool). The TODO comment is sufficient. I might also replace "Figure this one
out" with "Provide a way for the Tether code to set the enabled state."

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

Done. Added testing.

+    }
+  } 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 135 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)) {
+    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 39 matching lines @@
   }
 
   return nullptr;
 }
 
 const std::string NetworkStateHandler::CreateTetherNetworkState(
     const std::string& name) {
   const std::string& guid = base::GenerateGUID();
 
   std::unique_ptr<NetworkState> tether_managed_state =
       base::MakeUnique<NetworkState>(base::GenerateGUID());

[stevenjb, 2017/02/16 22:56:35]

Thinking about this some more, I think that the Tether code needs to generate
the GUID so that it can persist state for previously connected Tether networks
at some point. Maybe this should be 'AddTethernetwork(guid, name)', and if the
network exists it's just a noop.

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

You're right, oops. Done.

 
   tether_managed_state->set_name(name);
   tether_managed_state->set_type(kTypeTether);
   tether_managed_state->SetGuid(guid);
   tether_managed_state->set_update_received();
 
   tether_network_list_.push_back(std::move(tether_managed_state));
   NotifyNetworkListChanged();
 
   return guid;
@@ skipping 659 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