Create a Tether section in the system tray network list.

ash/common/system/chromeos/network/network_list_md.cc

 // Copyright 2016 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 "ash/common/system/chromeos/network/network_list_md.h"
 
 #include <stddef.h>
 
 #include "ash/common/system/chromeos/network/network_icon.h"
 #include "ash/common/system/chromeos/network/network_icon_animation.h"
@@ skipping 164 matching lines @@
     NetworkStateHandler* handler =
         NetworkHandler::Get()->network_state_handler();
     handler->SetTechnologyEnabled(NetworkTypePattern::Cellular(), is_on,
                                   chromeos::network_handler::ErrorCallback());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CellularHeaderRowView);
 };
 
+class TetherHeaderRowView : public NetworkListViewMd::SectionHeaderRowView {
+ public:
+  TetherHeaderRowView()
+      : SectionHeaderRowView(IDS_ASH_STATUS_TRAY_NETWORK_TETHER) {}
+
+  ~TetherHeaderRowView() override {}
+
+  const char* GetClassName() const override { return "TetherHeaderRowView"; }
+
+ protected:
+  void OnToggleToggled(bool is_on) override {
+    // TODO (hansberry): Persist toggle to settings/preferences.
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TetherHeaderRowView);
+};
+
 class WifiHeaderRowView : public NetworkListViewMd::SectionHeaderRowView {
  public:
   explicit WifiHeaderRowView(NetworkListDelegate* network_list_delegate)
       : SectionHeaderRowView(IDS_ASH_STATUS_TRAY_NETWORK_WIFI),
         network_list_delegate_(network_list_delegate),
         join_(nullptr) {}
 
   ~WifiHeaderRowView() override {}
 
   void SetEnabled(bool enabled) override {
@@ skipping 61 matching lines @@
 }  // namespace
 
 // NetworkListViewMd:
 
 NetworkListViewMd::NetworkListViewMd(NetworkListDelegate* delegate)
     : needs_relayout_(false),
       delegate_(delegate),
       no_wifi_networks_view_(nullptr),
       no_cellular_networks_view_(nullptr),
       cellular_header_view_(nullptr),
+      tether_header_view_(nullptr),
       wifi_header_view_(nullptr),
       cellular_separator_view_(nullptr),
+      tether_separator_view_(nullptr),
       wifi_separator_view_(nullptr) {
   CHECK(delegate_);
 }
 
 NetworkListViewMd::~NetworkListViewMd() {
   network_icon::NetworkIconAnimation::GetInstance()->RemoveObserver(this);
 }
 
 void NetworkListViewMd::Update() {
   CHECK(container());
+
+  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
+
   NetworkStateHandler::NetworkStateList network_list;
-  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   handler->GetVisibleNetworkList(&network_list);
   UpdateNetworks(network_list);
+
+  NetworkStateHandler::NetworkStateList tether_network_list;
+  handler->GetNetworkListByType(
+      NetworkTypePattern::Tether(), false /* configured_only */,
+      false /* visible_only */, 0 /* no limit */, &tether_network_list);
+  for (const auto& tether_network : tether_network_list) {
+    network_list_.push_back(
+        base::MakeUnique<NetworkInfo>(tether_network->guid()));
+  }
+
   UpdateNetworkIcons();
   OrderNetworks();
   UpdateNetworkListInternal();
 }
 
 bool NetworkListViewMd::IsNetworkEntry(views::View* view,
                                        std::string* service_path) const {
   std::map<views::View*, std::string>::const_iterator found =
       network_map_.find(view);
   if (found == network_map_.end())
@@ skipping 77 matching lines @@
     info->disable =
         (network->activation_state() == shill::kActivationStateActivating) ||
         prohibited_by_policy;
     info->connected = network->IsConnectedState();
     info->connecting = network->IsConnectingState();
     info->highlight = info->connected || info->connecting;
     if (network->Matches(NetworkTypePattern::WiFi()))
       info->type = NetworkInfo::Type::WIFI;
     else if (network->Matches(NetworkTypePattern::Cellular()))
       info->type = NetworkInfo::Type::CELLULAR;
+    else if (network->Matches(NetworkTypePattern::Tether()))
+      info->type = NetworkInfo::Type::TETHER;
     if (prohibited_by_policy) {
       info->tooltip =
           l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_NETWORK_PROHIBITED);
     }
     if (!animating && network->IsConnectingState())
       animating = true;
   }
   if (animating)
     network_icon::NetworkIconAnimation::GetInstance()->AddObserver(this);
   else
@@ skipping 70 matching lines @@
       ++index;
 
     // Add cellular networks.
     std::unique_ptr<std::set<std::string>> new_cellular_service_paths =
         UpdateNetworkChildren(NetworkInfo::Type::CELLULAR, index);
     index += new_cellular_service_paths->size();
     new_service_paths->insert(new_cellular_service_paths->begin(),
                               new_cellular_service_paths->end());
   }
 
+  // TODO (hansberry): Can't check on the |pattern| here like with Wi-Fi and
+  // Cellular because Tether does not match NonVirtual. Is that okay? Should
+  // |delegate_|'s GetNetworkTypePattern be adjusted to match Tether?

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

I would replace the question in the comment with something like 'Audit existing
usage of NonVirtual and consider including Tether in NonVirtual. I would also
file a bug for that and reference it here.

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

Done.

+  if (handler->IsTechnologyAvailable(NetworkTypePattern::Tether())) {
+    index = UpdateSectionHeaderRow(
+        NetworkTypePattern::Tether(),
+        handler->IsTechnologyEnabled(NetworkTypePattern::Tether()), index,
+        &tether_header_view_, &tether_separator_view_);
+
+    // TODO (hansberry): Should a message similar to
+    // IDS_ASH_STATUS_TRAY_NO_CELLULAR_NETWORKS be shown if Tether technology
+    // is enabled but no networks are around?
+
+    // Add Tether networks.
+    std::unique_ptr<std::set<std::string>> new_tether_guids =
+        UpdateNetworkChildren(NetworkInfo::Type::TETHER, index);
+    index += new_tether_guids->size();
+    new_service_paths->insert(new_tether_guids->begin(),
+                              new_tether_guids->end());
+  }
+
   if (pattern.MatchesPattern(NetworkTypePattern::WiFi())) {
     index = UpdateSectionHeaderRow(
         NetworkTypePattern::WiFi(),
         handler->IsTechnologyEnabled(NetworkTypePattern::WiFi()), index,
         &wifi_header_view_, &wifi_separator_view_);
 
     // "Wifi Enabled / Disabled".
     int message_id = 0;
     if (network_list_.empty()) {
       message_id = handler->IsTechnologyEnabled(NetworkTypePattern::WiFi())
@@ skipping 89 matching lines @@
 
 int NetworkListViewMd::UpdateSectionHeaderRow(
     NetworkTypePattern pattern,
     bool enabled,
     int child_index,
     SectionHeaderRowView** view,
     views::Separator** separator_view) {
   if (!*view) {
     if (pattern.Equals(NetworkTypePattern::Cellular()))
       *view = new CellularHeaderRowView();
+    else if (pattern.Equals(NetworkTypePattern::Tether()))
+      *view = new TetherHeaderRowView();
     else if (pattern.Equals(NetworkTypePattern::WiFi()))
       *view = new WifiHeaderRowView(delegate_);
     else
       NOTREACHED();
     (*view)->Init(enabled);
   }
   // Show or hide a separator above the header. The separator should only be
   // visible when the header row is not at the top of the list.
   if (child_index > 0) {
     if (!*separator_view)
       *separator_view = TrayPopupUtils::CreateListSubHeaderSeparator();
     PlaceViewAtIndex(*separator_view, child_index++);
   } else {
     if (*separator_view)
       delete *separator_view;
     *separator_view = nullptr;
   }
 
   (*view)->SetEnabled(enabled);
   PlaceViewAtIndex(*view, child_index++);
   return child_index;
 }
 
 void NetworkListViewMd::NetworkIconChanged() {
   Update();
 }
 
 }  // namespace ash