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 83 matching lines @@
   device_event_log::AddEntry(
       from_here.file_name(), from_here.line_number(),
       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;
+  }
+
   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))
@@ skipping 165 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) {
+  DCHECK(!guid.empty());
+
+  // 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) {
+      NET_LOG(ERROR) << "AddTetherNetworkState: " << name
+                     << " called with existing guid:" << guid;
+      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