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 &&
+           base::CommandLine::ForCurrentProcess()->HasSwitch(
+               chromeos::switches::kEnableTether)) {
+    // TODO (hansberry): Provide Tether a way to enable and disable the
+    // technology.
+    state = TECHNOLOGY_ENABLED;

[stevenjb, 2017/02/21 22:43:56]

If we but {} around one if clause, we should put it around all of them.

Alternatively we could move this up since it isn't a shill thing, i.e.

if (technology == tether) {
  return (tether enabled) ? ENABLED : UNAVAILABLE;
}

The VLOG below isn't important, but you could add a separate one for your
debugging if you want.

[Ryan Hansberry, 2017/02/21 23:26:37]

Done. Decided to not add a VLOG.

+  } 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 153 matching lines @@
     if (configured_only && !network->IsInProfile())
       continue;
     if (visible_only && !network->visible())
       continue;
     list->push_back(network);
     if (limit > 0 && ++count >= limit)
       break;
   }
 }
 
+void NetworkStateHandler::GetTetherNetworkList(int limit,
+                                               NetworkStateList* list) {
+  DCHECK(list);
+  list->clear();
+  int count = 0;
+
+  for (auto iter = tether_network_list_.begin();
+       iter != tether_network_list_.end(); ++iter) {
+    list->push_back((*iter)->AsNetworkState());
+    if (limit > 0 && ++count >= limit)
+      return;
+  }
+}
+
 const NetworkState* NetworkStateHandler::GetNetworkStateFromServicePath(
     const std::string& service_path,
     bool configured_only) const {
   ManagedState* managed =
       GetModifiableManagedState(&network_list_, service_path);
   if (!managed)
     return nullptr;
   const NetworkState* network = managed->AsNetworkState();
   DCHECK(network);
   if (!network->update_received() ||
@@ skipping 16 matching lines @@
   for (auto iter = tether_network_list_.begin();
        iter != tether_network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     if (network->guid() == guid)
       return network;
   }
 
   return nullptr;
 }
 
-const std::string NetworkStateHandler::CreateTetherNetworkState(
-    const std::string& name) {
-  const std::string& guid = base::GenerateGUID();
+void NetworkStateHandler::AddTetherNetworkState(const std::string& guid,
+                                                const std::string& name) {
+#if DCHECK_IS_ON()

[stevenjb, 2017/02/21 22:43:56]

This #if is only needed if there is logic other than just the DCHECK inside it.

[Ryan Hansberry, 2017/02/21 23:26:37]

Done.

+  DCHECK(!guid.empty());
+#endif
+
+  // If the network already exists, do nothing.
+  for (auto iter = tether_network_list_.begin();
+       iter != tether_network_list_.end(); ++iter) {
+    if (iter->get()->AsNetworkState()->guid() == guid) {

[stevenjb, 2017/02/21 22:43:56]

I would add:
NET_LOG(ERROR) << "Add tether network: " << name << " called with existing guid:
" << guid;

[Ryan Hansberry, 2017/02/21 23:26:37]

Done.

+      return;
+    }
+  }
 
   std::unique_ptr<NetworkState> tether_managed_state =
       base::MakeUnique<NetworkState>(base::GenerateGUID());
 
   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;
 }
 
 void NetworkStateHandler::RemoveTetherNetworkState(const std::string& guid) {
   for (auto iter = tether_network_list_.begin();
        iter != tether_network_list_.end(); ++iter) {
     if (iter->get()->AsNetworkState()->guid() == guid) {
       tether_network_list_.erase(iter);
       NotifyNetworkListChanged();
       return;
     }
@@ skipping 649 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